XmlObjectSerializerWriteContextComplex.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 / XmlObjectSerializerWriteContextComplex.cs / 2 / XmlObjectSerializerWriteContextComplex.cs

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

namespace System.Runtime.Serialization 
{
    using System; 
    using System.Collections; 
    using System.Diagnostics;
    using System.Globalization; 
    using System.IO;
    using System.Reflection;
    using System.Text;
    using System.Xml; 
    using System.Collections.Generic;
 
#if USE_REFEMIT 
    public class XmlObjectSerializerWriteContextComplex : XmlObjectSerializerWriteContext
#else 
    internal class XmlObjectSerializerWriteContextComplex : XmlObjectSerializerWriteContext
#endif
    {
        protected IDataContractSurrogate dataContractSurrogate; 
        SerializationMode mode;
        SerializationBinder binder; 
        ISurrogateSelector surrogateSelector; 
        StreamingContext streamingContext;
        Hashtable surrogateDataContracts; 

        internal XmlObjectSerializerWriteContextComplex(DataContractSerializer serializer, DataContract rootTypeDataContract)
            : base(serializer, rootTypeDataContract)
        { 
            this.mode = SerializationMode.SharedContract;
            this.preserveObjectReferences = serializer.PreserveObjectReferences; 
            this.dataContractSurrogate = serializer.DataContractSurrogate; 
        }
 
        internal XmlObjectSerializerWriteContextComplex(NetDataContractSerializer serializer, Hashtable surrogateDataContracts)
            : base(serializer)
        {
            this.mode = SerializationMode.SharedType; 
            this.preserveObjectReferences = true;
            this.streamingContext = serializer.Context; 
            this.binder = serializer.Binder; 
            this.surrogateSelector = serializer.SurrogateSelector;
            this.surrogateDataContracts = surrogateDataContracts; 
        }

        internal XmlObjectSerializerWriteContextComplex(XmlObjectSerializer serializer, int maxItemsInObjectGraph, StreamingContext streamingContext, bool ignoreExtensionDataObject)
            : base(serializer, maxItemsInObjectGraph, streamingContext, ignoreExtensionDataObject) 
        {
        } 
 
        internal override SerializationMode Mode
        { 
            get { return mode; }
        }

        internal override DataContract GetDataContract(RuntimeTypeHandle typeHandle, Type type) 
        {
            DataContract dataContract = NetDataContractSerializer.GetDataContractFromSurrogateSelector(surrogateSelector, streamingContext, typeHandle, type, ref surrogateDataContracts); 
            if (dataContract != null) 
            {
                if (this.IsGetOnlyCollection && dataContract is SurrogateDataContract) 
                {
                    throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidDataContractException(SR.GetString(SR.SurrogatesWithGetOnlyCollectionsNotSupportedSerDeser,
                        DataContract.GetClrTypeFullName(dataContract.UnderlyingType))));
                } 
                return dataContract;
            } 
 
            return base.GetDataContract(typeHandle, type);
        } 

        internal override DataContract GetDataContract(int id, RuntimeTypeHandle typeHandle)
        {
            DataContract dataContract = NetDataContractSerializer.GetDataContractFromSurrogateSelector(surrogateSelector, streamingContext, typeHandle, null /*type*/, ref surrogateDataContracts); 
            if (dataContract != null)
            { 
                if (this.IsGetOnlyCollection && dataContract is SurrogateDataContract) 
                {
                    throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidDataContractException(SR.GetString(SR.SurrogatesWithGetOnlyCollectionsNotSupportedSerDeser, 
                        DataContract.GetClrTypeFullName(dataContract.UnderlyingType))));
                }
                return dataContract;
            } 

            return base.GetDataContract(id, typeHandle); 
        } 

        internal override DataContract GetDataContractSkipValidation(int typeId, RuntimeTypeHandle typeHandle, Type type) 
        {
            DataContract dataContract = NetDataContractSerializer.GetDataContractFromSurrogateSelector(surrogateSelector, streamingContext, typeHandle, null /*type*/, ref surrogateDataContracts);
            if (dataContract != null)
            { 
                if (this.IsGetOnlyCollection && dataContract is SurrogateDataContract)
                { 
                    throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidDataContractException(SR.GetString(SR.SurrogatesWithGetOnlyCollectionsNotSupportedSerDeser, 
                        DataContract.GetClrTypeFullName(dataContract.UnderlyingType))));
                } 
                return dataContract;
            }

            return base.GetDataContractSkipValidation(typeId, typeHandle, type); 
        }
 
        internal override bool WriteClrTypeInfo(XmlWriterDelegator xmlWriter, DataContract dataContract) 
        {
            if (mode == SerializationMode.SharedType) 
            {
                NetDataContractSerializer.WriteClrTypeInfo(xmlWriter, dataContract);
                return true;
            } 
            return false;
        } 
 
        internal override bool WriteClrTypeInfo(XmlWriterDelegator xmlWriter, string clrTypeName, string clrAssemblyName)
        { 
            if (mode == SerializationMode.SharedType)
            {
                NetDataContractSerializer.WriteClrTypeInfo(xmlWriter, clrTypeName, clrAssemblyName);
                return true; 
            }
            return false; 
        } 

#if USE_REFEMIT 
        public override void WriteAnyType(XmlWriterDelegator xmlWriter, object value)
#else
        internal override void WriteAnyType(XmlWriterDelegator xmlWriter, object value)
#endif 
        {
            if (!OnHandleReference(xmlWriter, value, false /*canContainCyclicReference*/)) 
                xmlWriter.WriteAnyType(value); 
        }
 
#if USE_REFEMIT
        public override void WriteString(XmlWriterDelegator xmlWriter, string value)
#else
        internal override void WriteString(XmlWriterDelegator xmlWriter, string value) 
#endif
        { 
            if (!OnHandleReference(xmlWriter, value, false /*canContainCyclicReference*/)) 
                xmlWriter.WriteString(value);
        } 
#if USE_REFEMIT
        public override void WriteString(XmlWriterDelegator xmlWriter, string value, XmlDictionaryString name, XmlDictionaryString ns)
#else
        internal override void WriteString(XmlWriterDelegator xmlWriter, string value, XmlDictionaryString name, XmlDictionaryString ns) 
#endif
        { 
            if (value == null) 
                WriteNull(xmlWriter, typeof(string), true/*isMemberTypeSerializable*/, name, ns);
            else 
            {
                xmlWriter.WriteStartElementPrimitive(name, ns);
                if (!OnHandleReference(xmlWriter, value, false /*canContainCyclicReference*/))
                    xmlWriter.WriteString(value); 
                xmlWriter.WriteEndElementPrimitive();
            } 
        } 

#if USE_REFEMIT 
        public override void WriteBase64(XmlWriterDelegator xmlWriter, byte[] value)
#else
        internal override void WriteBase64(XmlWriterDelegator xmlWriter, byte[] value)
#endif 
        {
            if (!OnHandleReference(xmlWriter, value, false /*canContainCyclicReference*/)) 
                xmlWriter.WriteBase64(value); 
        }
#if USE_REFEMIT 
        public override void WriteBase64(XmlWriterDelegator xmlWriter, byte[] value, XmlDictionaryString name, XmlDictionaryString ns)
#else
        internal override void WriteBase64(XmlWriterDelegator xmlWriter, byte[] value, XmlDictionaryString name, XmlDictionaryString ns)
#endif 
        {
            if (value == null) 
                WriteNull(xmlWriter, typeof(byte[]), true/*isMemberTypeSerializable*/, name, ns); 
            else
            { 
                xmlWriter.WriteStartElementPrimitive(name, ns);
                if (!OnHandleReference(xmlWriter, value, false /*canContainCyclicReference*/))
                    xmlWriter.WriteBase64(value);
                xmlWriter.WriteEndElementPrimitive(); 
            }
        } 
 
#if USE_REFEMIT
        public override void WriteUri(XmlWriterDelegator xmlWriter, Uri value) 
#else
        internal override void WriteUri(XmlWriterDelegator xmlWriter, Uri value)
#endif
        { 
            if (!OnHandleReference(xmlWriter, value, false /*canContainCyclicReference*/))
                xmlWriter.WriteUri(value); 
        } 
#if USE_REFEMIT
        public override void WriteUri(XmlWriterDelegator xmlWriter, Uri value, XmlDictionaryString name, XmlDictionaryString ns) 
#else
        internal override void WriteUri(XmlWriterDelegator xmlWriter, Uri value, XmlDictionaryString name, XmlDictionaryString ns)
#endif
        { 
            if (value == null)
                WriteNull(xmlWriter, typeof(Uri), true/*isMemberTypeSerializable*/, name, ns); 
            else 
            {
                xmlWriter.WriteStartElementPrimitive(name, ns); 
                if (!OnHandleReference(xmlWriter, value, false /*canContainCyclicReference*/))
                    xmlWriter.WriteUri(value);
                xmlWriter.WriteEndElementPrimitive();
            } 
        }
 
#if USE_REFEMIT 
        public override void WriteQName(XmlWriterDelegator xmlWriter, XmlQualifiedName value)
#else 
        internal override void WriteQName(XmlWriterDelegator xmlWriter, XmlQualifiedName value)
#endif
        {
            if (!OnHandleReference(xmlWriter, value, false /*canContainCyclicReference*/)) 
                xmlWriter.WriteQName(value);
        } 
#if USE_REFEMIT 
        public override void WriteQName(XmlWriterDelegator xmlWriter, XmlQualifiedName value, XmlDictionaryString name, XmlDictionaryString ns)
#else 
        internal override void WriteQName(XmlWriterDelegator xmlWriter, XmlQualifiedName value, XmlDictionaryString name, XmlDictionaryString ns)
#endif
        {
            if (value == null) 
                WriteNull(xmlWriter, typeof(XmlQualifiedName), true/*isMemberTypeSerializable*/, name, ns);
            else 
            { 
                if (ns != null && ns.Value != null && ns.Value.Length > 0)
                    xmlWriter.WriteStartElement(Globals.ElementPrefix, name, ns); 
                else
                    xmlWriter.WriteStartElement(name, ns);
                if (!OnHandleReference(xmlWriter, value, false /*canContainCyclicReference*/))
                    xmlWriter.WriteQName(value); 
                xmlWriter.WriteEndElement();
            } 
        } 

#if USE_REFEMIT 
        public override void InternalSerialize(XmlWriterDelegator xmlWriter, object obj, bool isDeclaredType, bool writeXsiType, int declaredTypeID, RuntimeTypeHandle declaredTypeHandle)
#else
        internal override void InternalSerialize(XmlWriterDelegator xmlWriter, object obj, bool isDeclaredType, bool writeXsiType, int declaredTypeID, RuntimeTypeHandle declaredTypeHandle)
#endif 
        {
            if (dataContractSurrogate == null) 
            { 
                base.InternalSerialize(xmlWriter, obj, isDeclaredType, writeXsiType, declaredTypeID, declaredTypeHandle);
            } 
            else
            {
                InternalSerializeWithSurrogate(xmlWriter, obj, isDeclaredType, writeXsiType, declaredTypeID, declaredTypeHandle);
            } 
        }
 
        internal override bool OnHandleReference(XmlWriterDelegator xmlWriter, object obj, bool canContainCyclicReference) 
        {
            if (preserveObjectReferences && !this.IsGetOnlyCollection) 
            {
                bool isNew = true;
                int objectId = SerializedObjects.GetId(obj, ref isNew);
                if (isNew) 
                    xmlWriter.WriteAttributeInt(Globals.SerPrefix, DictionaryGlobals.IdLocalName, DictionaryGlobals.SerializationNamespace, objectId);
                else 
                { 
                    xmlWriter.WriteAttributeInt(Globals.SerPrefix, DictionaryGlobals.RefLocalName, DictionaryGlobals.SerializationNamespace, objectId);
                    xmlWriter.WriteAttributeBool(Globals.XsiPrefix, DictionaryGlobals.XsiNilLocalName, DictionaryGlobals.SchemaInstanceNamespace, true); 
                }
                return !isNew;
            }
            return base.OnHandleReference(xmlWriter, obj, canContainCyclicReference); 
        }
 
        internal override void OnEndHandleReference(XmlWriterDelegator xmlWriter, object obj, bool canContainCyclicReference) 
        {
            if (preserveObjectReferences && !this.IsGetOnlyCollection) 
                return;
            base.OnEndHandleReference(xmlWriter, obj, canContainCyclicReference);
        }
 
        internal override void CheckIfTypeSerializable(Type memberType, bool isMemberTypeSerializable)
        { 
            if (mode == SerializationMode.SharedType) 
            {
                ISurrogateSelector surrogateSelectorNotUsed; 
                if (surrogateSelector != null && surrogateSelector.GetSurrogate(memberType, streamingContext, out surrogateSelectorNotUsed) != null)
                    return;
            }
            else 
            {
                if (dataContractSurrogate != null) 
                { 
                    while (memberType.IsArray)
                        memberType = memberType.GetElementType(); 
                    memberType = DataContractSurrogateCaller.GetDataContractType(dataContractSurrogate, memberType);
                    if (!DataContract.IsTypeSerializable(memberType))
                        throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidDataContractException(SR.GetString(SR.TypeNotSerializable, memberType)));
                    return; 
                }
            } 
 
            base.CheckIfTypeSerializable(memberType, isMemberTypeSerializable);
        } 

        internal override Type GetSurrogatedType(Type type)
        {
            if (dataContractSurrogate == null) 
            {
                return base.GetSurrogatedType(type); 
            } 
            else
            { 
                type = DataContract.UnwrapNullableType(type);
                Type surrogateType = DataContractSerializer.GetSurrogatedType(dataContractSurrogate, type);
                if (this.IsGetOnlyCollection && surrogateType != type)
                { 
                    throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidDataContractException(SR.GetString(SR.SurrogatesWithGetOnlyCollectionsNotSupportedSerDeser,
                        DataContract.GetClrTypeFullName(type)))); 
                } 
                else
                { 
                    return surrogateType;
                }
            }
        } 

        void InternalSerializeWithSurrogate(XmlWriterDelegator xmlWriter, object obj, bool isDeclaredType, bool writeXsiType, int declaredTypeID, RuntimeTypeHandle declaredTypeHandle) 
        { 
            RuntimeTypeHandle objTypeHandle = isDeclaredType ? declaredTypeHandle : Type.GetTypeHandle(obj);
            object oldObj = obj; 
            int objOldId = 0;
            Type objType = Type.GetTypeFromHandle(objTypeHandle);
            Type declaredType = GetSurrogatedType(Type.GetTypeFromHandle(declaredTypeHandle));
            declaredTypeHandle = declaredType.TypeHandle; 
            obj = DataContractSerializer.SurrogateToDataContractType(dataContractSurrogate, obj, declaredType, ref objType);
            objTypeHandle = objType.TypeHandle; 
            if (oldObj != obj) 
                objOldId = SerializedObjects.ReassignId(0, oldObj, obj);
 
            if (writeXsiType)
            {
                declaredType = Globals.TypeOfObject;
                SerializeWithXsiType(xmlWriter, obj, objTypeHandle, objType, -1, declaredType.TypeHandle, declaredType); 
            }
            else if (declaredTypeHandle.Value == objTypeHandle.Value) 
            { 
                DataContract contract = GetDataContract(objTypeHandle, objType);
                SerializeWithoutXsiType(contract, xmlWriter, obj, declaredTypeHandle); 
            }
            else
            {
                SerializeWithXsiType(xmlWriter, obj, objTypeHandle, objType, -1, declaredTypeHandle, declaredType); 
            }
            if (oldObj != obj) 
                SerializedObjects.ReassignId(objOldId, obj, oldObj); 
        }
 
        internal override void WriteArraySize(XmlWriterDelegator xmlWriter, int size)
        {
            if (preserveObjectReferences && size > -1)
                xmlWriter.WriteAttributeInt(Globals.SerPrefix, DictionaryGlobals.ArraySizeLocalName, DictionaryGlobals.SerializationNamespace, size); 
        }
 
    } 

} 

// 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