NetDataContractSerializer.cs source code in C# .NET

Source code for the .NET framework in C#

                        
Code:

                         / WCF / WCF / 3.5.30729.1 / untmp / Orcas / SP / ndp / cdf / src / WCF / Serialization / System / Runtime / Serialization / NetDataContractSerializer.cs / 1 / NetDataContractSerializer.cs
                        

                        
                            //------------------------------------------------------------ 
// Copyright (c) Microsoft Corporation.  All rights reserved.
//-----------------------------------------------------------

namespace System.Runtime.Serialization 
{
    using System; 
    using System.IO; 
    using System.Xml;
    using System.Collections; 
    using System.Runtime.Serialization.Formatters;

    public sealed class NetDataContractSerializer : XmlObjectSerializer, IFormatter
    { 
        XmlDictionaryString rootName;
        XmlDictionaryString rootNamespace; 
        StreamingContext context; 
        SerializationBinder binder;
        ISurrogateSelector surrogateSelector; 
        int maxItemsInObjectGraph;
        bool ignoreExtensionDataObject;
        FormatterAssemblyStyle assemblyFormat;
        DataContract cachedDataContract; 

        public NetDataContractSerializer() 
            : this(new StreamingContext(StreamingContextStates.All)) 
        {
        } 

        public NetDataContractSerializer(StreamingContext context)
            : this(context, Int32.MaxValue, false, FormatterAssemblyStyle.Full, null)
        { 
        }
 
        public NetDataContractSerializer(StreamingContext context, 
            int maxItemsInObjectGraph,
            bool ignoreExtensionDataObject, 
            FormatterAssemblyStyle assemblyFormat,
            ISurrogateSelector surrogateSelector)
        {
            Initialize(context, maxItemsInObjectGraph, ignoreExtensionDataObject, assemblyFormat, surrogateSelector); 
        }
 
        public NetDataContractSerializer(string rootName, string rootNamespace) 
            : this(rootName, rootNamespace, new StreamingContext(StreamingContextStates.All), Int32.MaxValue, false, FormatterAssemblyStyle.Full, null)
        { 
        }

        public NetDataContractSerializer(string rootName, string rootNamespace,
            StreamingContext context, 
            int maxItemsInObjectGraph,
            bool ignoreExtensionDataObject, 
            FormatterAssemblyStyle assemblyFormat, 
            ISurrogateSelector surrogateSelector)
        { 
            XmlDictionary dictionary = new XmlDictionary(2);
            Initialize(dictionary.Add(rootName), dictionary.Add(DataContract.GetNamespace(rootNamespace)), context, maxItemsInObjectGraph, ignoreExtensionDataObject, assemblyFormat, surrogateSelector);
        }
 
        public NetDataContractSerializer(XmlDictionaryString rootName, XmlDictionaryString rootNamespace)
            : this(rootName, rootNamespace, new StreamingContext(StreamingContextStates.All), Int32.MaxValue, false, FormatterAssemblyStyle.Full, null) 
        { 
        }
 
        public NetDataContractSerializer(XmlDictionaryString rootName, XmlDictionaryString rootNamespace,
            StreamingContext context,
            int maxItemsInObjectGraph,
            bool ignoreExtensionDataObject, 
            FormatterAssemblyStyle assemblyFormat,
            ISurrogateSelector surrogateSelector) 
        { 
            Initialize(rootName, rootNamespace, context, maxItemsInObjectGraph, ignoreExtensionDataObject, assemblyFormat, surrogateSelector);
        } 

        void Initialize(StreamingContext context,
            int maxItemsInObjectGraph,
            bool ignoreExtensionDataObject, 
            FormatterAssemblyStyle assemblyFormat,
            ISurrogateSelector surrogateSelector) 
        { 
            this.context = context;
            if (maxItemsInObjectGraph < 0) 
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("maxItemsInObjectGraph", SR.GetString(SR.ValueMustBeNonNegative)));
            this.maxItemsInObjectGraph = maxItemsInObjectGraph;
            this.ignoreExtensionDataObject = ignoreExtensionDataObject;
            this.surrogateSelector = surrogateSelector; 
            this.AssemblyFormat = assemblyFormat;
        } 
 
        void Initialize(XmlDictionaryString rootName, XmlDictionaryString rootNamespace,
            StreamingContext context, 
            int maxItemsInObjectGraph,
            bool ignoreExtensionDataObject,
            FormatterAssemblyStyle assemblyFormat,
            ISurrogateSelector surrogateSelector) 
        {
            Initialize(context, maxItemsInObjectGraph, ignoreExtensionDataObject, assemblyFormat, surrogateSelector); 
            this.rootName = rootName; 
            this.rootNamespace = rootNamespace;
        } 

        public StreamingContext Context
        {
            get { return context; } 
            set { context = value; }
        } 
 
        public SerializationBinder Binder
        { 
            get { return binder; }
            set { binder = value; }
        }
 
        public ISurrogateSelector SurrogateSelector
        { 
            get { return surrogateSelector; } 
            set { surrogateSelector = value; }
        } 

        public FormatterAssemblyStyle AssemblyFormat
        {
            get { return assemblyFormat; } 
            set
            { 
                if (value != FormatterAssemblyStyle.Full && value != FormatterAssemblyStyle.Simple) 
                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(SR.GetString(SR.InvalidAssemblyFormat, value)));
                assemblyFormat = value; 
            }
        }

        public int MaxItemsInObjectGraph 
        {
            get { return maxItemsInObjectGraph; } 
        } 

        public bool IgnoreExtensionDataObject 
        {
            get { return ignoreExtensionDataObject; }
        }
 
        public void Serialize(Stream stream, object graph)
        { 
            base.WriteObject(stream, graph); 
        }
 
        public object Deserialize(Stream stream)
        {
            return base.ReadObject(stream);
        } 

        internal override void InternalWriteObject(XmlWriterDelegator writer, object graph) 
        { 
            Hashtable surrogateDataContracts = null;
            DataContract contract = GetDataContract(graph, ref surrogateDataContracts); 

            InternalWriteStartObject(writer, graph, contract);
            InternalWriteObjectContent(writer, graph, contract, surrogateDataContracts);
            InternalWriteEndObject(writer); 
        }
 
        public override void WriteObject(XmlWriter writer, object graph) 
        {
            WriteObjectHandleExceptions(new XmlWriterDelegator(writer), graph); 
        }

        public override void WriteStartObject(XmlWriter writer, object graph)
        { 
            WriteStartObjectHandleExceptions(new XmlWriterDelegator(writer), graph);
        } 
 
        public override void WriteObjectContent(XmlWriter writer, object graph)
        { 
            WriteObjectContentHandleExceptions(new XmlWriterDelegator(writer), graph);
        }

        public override void WriteEndObject(XmlWriter writer) 
        {
            WriteEndObjectHandleExceptions(new XmlWriterDelegator(writer)); 
        } 

        public override void WriteStartObject(XmlDictionaryWriter writer, object graph) 
        {
            WriteStartObjectHandleExceptions(new XmlWriterDelegator(writer), graph);
        }
 
        internal override void InternalWriteStartObject(XmlWriterDelegator writer, object graph)
        { 
            Hashtable surrogateDataContracts = null; 
            DataContract contract = GetDataContract(graph, ref surrogateDataContracts);
            InternalWriteStartObject(writer, graph, contract); 
        }

        void InternalWriteStartObject(XmlWriterDelegator writer, object graph, DataContract contract)
        { 
            WriteRootElement(writer, contract, rootName, rootNamespace, CheckIfNeedsContractNsAtRoot(rootName, rootNamespace, contract));
        } 
 
        public override void WriteObjectContent(XmlDictionaryWriter writer, object graph)
        { 
            WriteObjectContentHandleExceptions(new XmlWriterDelegator(writer), graph);
        }

        internal override void InternalWriteObjectContent(XmlWriterDelegator writer, object graph) 
        {
            Hashtable surrogateDataContracts = null; 
            DataContract contract = GetDataContract(graph, ref surrogateDataContracts); 
            InternalWriteObjectContent(writer, graph, contract, surrogateDataContracts);
        } 

        void InternalWriteObjectContent(XmlWriterDelegator writer, object graph, DataContract contract, Hashtable surrogateDataContracts)
        {
            if (MaxItemsInObjectGraph == 0) 
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(XmlObjectSerializer.CreateSerializationException(SR.GetString(SR.ExceededMaxItemsQuota, MaxItemsInObjectGraph)));
 
            if (IsRootXmlAny(rootName, contract)) 
            {
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(XmlObjectSerializer.CreateSerializationException(SR.GetString(SR.IsAnyNotSupportedByNetDataContractSerializer, contract.UnderlyingType))); 
            }
            else if (graph == null)
            {
                WriteNull(writer); 
            }
            else 
            { 
                Type graphType = graph.GetType();
                if (contract.UnderlyingType != graphType) 
                    contract = GetDataContract(graph, ref surrogateDataContracts);

                XmlObjectSerializerWriteContext context = null;
                if (contract.CanContainReferences) 
                {
                    context = XmlObjectSerializerWriteContext.CreateContext(this, surrogateDataContracts); 
                    context.HandleGraphAtTopLevel(writer, graph, contract); 
                }
 
                WriteClrTypeInfo(writer, contract);
                contract.WriteXmlValue(writer, graph, context);
            }
        } 

        internal static void WriteClrTypeInfo(XmlWriterDelegator writer, DataContract dataContract) 
        { 
            if (!dataContract.IsISerializable && !(dataContract is SurrogateDataContract))
            { 
                if (dataContract.UnderlyingType == Globals.TypeOfDateTimeOffsetAdapter)
                {
                    WriteClrTypeInfo(writer, DataContract.GetClrTypeFullName(Globals.TypeOfDateTimeOffset), Globals.TypeOfDateTimeOffset.Assembly.FullName);
                } 
                else
                { 
                    WriteClrTypeInfo(writer, DataContract.GetClrTypeFullName(dataContract.UnderlyingType), dataContract.UnderlyingType.Assembly.FullName); 
                }
            } 
        }

        internal static void WriteClrTypeInfo(XmlWriterDelegator writer, string clrTypeName, string clrAssemblyName)
        { 
            if (clrTypeName != null)
                writer.WriteAttributeString(Globals.SerPrefix, DictionaryGlobals.ClrTypeLocalName, DictionaryGlobals.SerializationNamespace, DataContract.GetClrTypeString(clrTypeName)); 
            if (clrAssemblyName != null) 
                writer.WriteAttributeString(Globals.SerPrefix, DictionaryGlobals.ClrAssemblyLocalName, DictionaryGlobals.SerializationNamespace, DataContract.GetClrTypeString(clrAssemblyName));
        } 

        public override void WriteEndObject(XmlDictionaryWriter writer)
        {
            WriteEndObjectHandleExceptions(new XmlWriterDelegator(writer)); 
        }
 
        internal override void InternalWriteEndObject(XmlWriterDelegator writer) 
        {
            writer.WriteEndElement(); 
        }

        public override object ReadObject(XmlReader reader)
        { 
            return ReadObjectHandleExceptions(new XmlReaderDelegator(reader), true /*verifyObjectName*/);
        } 
 
        public override object ReadObject(XmlReader reader, bool verifyObjectName)
        { 
            return ReadObjectHandleExceptions(new XmlReaderDelegator(reader), verifyObjectName);
        }

        public override bool IsStartObject(XmlReader reader) 
        {
            return IsStartObjectHandleExceptions(new XmlReaderDelegator(reader)); 
        } 

        public override object ReadObject(XmlDictionaryReader reader, bool verifyObjectName) 
        {
            return ReadObjectHandleExceptions(new XmlReaderDelegator(reader), verifyObjectName);
        }
 
        public override bool IsStartObject(XmlDictionaryReader reader)
        { 
            return IsStartObjectHandleExceptions(new XmlReaderDelegator(reader)); 
        }
 
        internal override object InternalReadObject(XmlReaderDelegator xmlReader, bool verifyObjectName)
        {
            if (MaxItemsInObjectGraph == 0)
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(XmlObjectSerializer.CreateSerializationException(SR.GetString(SR.ExceededMaxItemsQuota, MaxItemsInObjectGraph))); 

            // verifyObjectName has no effect in SharedType mode 
            if (!IsStartElement(xmlReader)) 
            {
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(XmlObjectSerializer.CreateSerializationExceptionWithReaderDetails(SR.GetString(SR.ExpectingElementAtDeserialize, XmlNodeType.Element), xmlReader)); 
            }

            XmlObjectSerializerReadContext context = XmlObjectSerializerReadContext.CreateContext(this);
            return context.InternalDeserialize(xmlReader, null, null, null); 
        }
 
        internal override bool InternalIsStartObject(XmlReaderDelegator reader) 
        {
            return IsStartElement(reader); 
        }

        internal DataContract GetDataContract(object obj, ref Hashtable surrogateDataContracts)
        { 
            return GetDataContract(((obj == null) ? Globals.TypeOfObject : obj.GetType()), ref surrogateDataContracts);
        } 
 
        internal DataContract GetDataContract(Type type, ref Hashtable surrogateDataContracts)
        { 
            return GetDataContract(type.TypeHandle, type, ref surrogateDataContracts);
        }

        internal DataContract GetDataContract(RuntimeTypeHandle typeHandle, Type type, ref Hashtable surrogateDataContracts) 
        {
            DataContract dataContract = GetDataContractFromSurrogateSelector(surrogateSelector, Context, typeHandle, type, ref surrogateDataContracts); 
            if (dataContract != null) 
                return dataContract;
 
            if (cachedDataContract == null)
            {
                dataContract = DataContract.GetDataContract(typeHandle, type, SerializationMode.SharedType);
                cachedDataContract = dataContract; 
                return dataContract;
            } 
 
            DataContract currentCachedDataContract = cachedDataContract;
            if (currentCachedDataContract.UnderlyingType.TypeHandle.Equals(typeHandle)) 
                return currentCachedDataContract;

            return DataContract.GetDataContract(typeHandle, type, SerializationMode.SharedType);
        } 

        internal static DataContract GetDataContractFromSurrogateSelector(ISurrogateSelector surrogateSelector, StreamingContext context, RuntimeTypeHandle typeHandle, Type type, ref Hashtable surrogateDataContracts) 
        { 
            if (surrogateSelector == null)
                return null; 

            if (type == null)
                type = Type.GetTypeFromHandle(typeHandle);
            DataContract builtInDataContract = DataContract.GetBuiltInDataContract(type); 
            if (builtInDataContract != null)
                return builtInDataContract; 
            if (surrogateDataContracts != null) 
            {
                DataContract cachedSurrogateContract = (DataContract)surrogateDataContracts[type]; 
                if (cachedSurrogateContract != null)
                    return cachedSurrogateContract;
            }
            DataContract surrogateContract = null; 
            ISurrogateSelector surrogateSelectorNotUsed;
            ISerializationSurrogate surrogate = surrogateSelector.GetSurrogate(type, context, out surrogateSelectorNotUsed); 
            if (surrogate != null) 
                surrogateContract = new SurrogateDataContract(type, surrogate);
            else if (type.IsArray) 
            {
                Type elementType = type.GetElementType();
                DataContract itemContract = GetDataContractFromSurrogateSelector(surrogateSelector, context, elementType.TypeHandle, elementType, ref surrogateDataContracts);
                if (itemContract == null) 
                    itemContract = DataContract.GetDataContract(elementType.TypeHandle, elementType, SerializationMode.SharedType);
                surrogateContract = new CollectionDataContract(type, itemContract); 
            } 
            if (surrogateContract != null)
            { 
                if (surrogateDataContracts == null)
                    surrogateDataContracts = new Hashtable();
                surrogateDataContracts.Add(type, surrogateContract);
                return surrogateContract; 
            }
            return null; 
        } 

    } 

}

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.

Link Menu

Network programming in C#, Network Programming in VB.NET, Network Programming in .NET
This book is available now!
Buy at Amazon US or
Buy at Amazon UK