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

                        
                            //------------------------------------------------------------------------------ 
// Copyright (c) Microsoft Corporation.  All rights reserved.
//-----------------------------------------------------------------------------
namespace System.Runtime.Serialization
{ 
    using System;
    using System.Xml; 
    using System.Collections.Generic; 
    using System.Globalization;
 
 	public sealed class ExtensionDataObject
	{
        IList members;
 
#if USE_REFEMIT
        public ExtensionDataObject() 
#else 
        internal ExtensionDataObject()
#endif 
        {
        }
	
#if USE_REFEMIT 
        public IList Members
#else 
        internal IList Members 
#endif
        { 
            get { return members; }
            set { members = value; }
        }
    } 

#if USE_REFEMIT 
    public class ExtensionDataMember 
#else
    internal class ExtensionDataMember 
#endif
    {
        string name;
        string ns; 
        IDataNode value;
        int memberIndex; 
        #if USE_REFEMIT 
        public string Name
        #else 
        internal string Name
        #endif
        {
            get { return name; } 
            set { name = value; }
        } 
 
        #if USE_REFEMIT
        public string Namespace 
        #else
        internal string Namespace
        #endif
        { 
            get { return ns; }
            set { ns = value; } 
        } 

        #if USE_REFEMIT 
        public IDataNode Value
        #else
        internal IDataNode Value
        #endif 
        {
            get { return value; } 
            set { this.value = value; } 
        }
 
        #if USE_REFEMIT
        public int MemberIndex
        #else
        internal int MemberIndex 
        #endif
        { 
            get { return memberIndex; } 
            set { memberIndex = value; }
        } 

    }

    #if USE_REFEMIT 
    public interface IDataNode
    #else 
    internal interface IDataNode 
    #endif
    { 
        Type DataType { get; }
        object Value { get; set; }  // boxes for primitives
        string DataContractName { get; set; }
        string DataContractNamespace { get; set; } 
        string ClrTypeName { get; set; }
        string ClrAssemblyName { get; set; } 
        string Id { get; set; } 
        bool PreservesReferences { get; }
 
        // NOTE: consider moving below APIs to DataNode if IDataNode API is made public
        void GetData(ElementData element);
        bool IsFinalValue { get; set; }
        void Clear(); 
    }
 
    internal class DataNode : IDataNode 
    {
        protected Type dataType; 
        T value;
        string dataContractName;
        string dataContractNamespace;
        string clrTypeName; 
        string clrAssemblyName;
        string id = Globals.NewObjectId; 
        bool isFinalValue; 

        internal DataNode() 
        {
            this.dataType = typeof(T);
            this.isFinalValue = true;
        } 

        internal DataNode(T value) : this() 
        { 
            this.value = value;
        } 

        public Type DataType
        {
            get { return dataType; } 
        }
 
        public object Value 
        {
            get { return value; } 
            set { this.value = (T)value; }
        }

        bool IDataNode.IsFinalValue 
        {
            get { return isFinalValue; } 
            set { isFinalValue = value; } 
        }
 
        public T GetValue()
        {
            return value;
        } 

#if NotUsed 
        public void SetValue(T value) 
        {
            this.value = value; 
        }
#endif

        public string DataContractName 
        {
            get { return dataContractName; } 
            set { dataContractName = value; } 
        }
 
        public string DataContractNamespace
        {
            get { return dataContractNamespace; }
            set { dataContractNamespace = value; } 
        }
 
        public string ClrTypeName 
        {
            get { return clrTypeName; } 
            set { clrTypeName = value; }
        }

        public string ClrAssemblyName 
        {
            get { return clrAssemblyName; } 
            set { clrAssemblyName = value; } 
        }
 
        public bool PreservesReferences
        {
            get { return (Id != Globals.NewObjectId); }
        } 

        public string Id 
        { 
            get { return id; }
            set { id = value; } 
        }

        public virtual void GetData(ElementData element)
        { 
            element.dataNode = this;
            element.attributeCount = 0; 
            element.childElementIndex = 0; 

            if (DataContractName != null) 
                AddQualifiedNameAttribute(element, Globals.XsiPrefix, Globals.XsiTypeLocalName, Globals.SchemaInstanceNamespace, DataContractName, DataContractNamespace);
            if (ClrTypeName != null)
                element.AddAttribute(Globals.SerPrefix, Globals.SerializationNamespace, Globals.ClrTypeLocalName, ClrTypeName);
            if (ClrAssemblyName != null) 
                element.AddAttribute(Globals.SerPrefix, Globals.SerializationNamespace, Globals.ClrAssemblyLocalName, ClrAssemblyName);
        } 
 
        public virtual void Clear()
        { 
            // dataContractName not cleared because it is used when re-serializing from unknown data
            clrTypeName = clrAssemblyName = null;
        }
 
        internal void AddQualifiedNameAttribute(ElementData element, string elementPrefix, string elementName, string elementNs, string valueName, string valueNs)
        { 
            string prefix = ExtensionDataReader.GetPrefix(valueNs); 
            element.AddAttribute(elementPrefix, elementNs, elementName, String.Format(CultureInfo.InvariantCulture, "{0}:{1}", prefix, valueName));
 
            bool prefixDeclaredOnElement = false;
            if (element.attributes != null)
            {
                for (int i = 0; i < element.attributes.Length; i++) 
                {
                    AttributeData attribute = element.attributes[i]; 
                    if (attribute != null && attribute.prefix == Globals.XmlnsPrefix && attribute.localName == prefix) 
                    {
                        prefixDeclaredOnElement = true; 
                        break;
                    }
                }
            } 
            if (!prefixDeclaredOnElement)
                element.AddAttribute(Globals.XmlnsPrefix, Globals.XmlnsNamespace, prefix, valueNs); 
        } 
    }
 
    internal class ClassDataNode : DataNode
    {
        IList members;
 
        internal ClassDataNode()
        { 
            dataType = Globals.TypeOfClassDataNode; 
        }
 
        internal IList Members
        {
            get { return members; }
            set { members = value; } 
        }
 
        public override void Clear() 
        {
            base.Clear(); 
            members = null;
        }
    }
 
    internal class CollectionDataNode : DataNode
    { 
        IList items; 
        string itemName;
        string itemNamespace; 
        int size = -1;

        internal CollectionDataNode()
        { 
            dataType = Globals.TypeOfCollectionDataNode;
        } 
 
        internal IList Items
        { 
            get { return items; }
            set { items = value; }
        }
 
        internal string ItemName
        { 
            get { return itemName; } 
            set { itemName = value; }
        } 

        internal string ItemNamespace
        {
            get { return itemNamespace; } 
            set { itemNamespace = value; }
        } 
 
        internal int Size
        { 
            get { return size; }
            set { size = value; }
        }
 
        public override void GetData(ElementData element)
        { 
            base.GetData(element); 

            element.AddAttribute(Globals.SerPrefix, Globals.SerializationNamespace, Globals.ArraySizeLocalName, Size.ToString(NumberFormatInfo.InvariantInfo)); 
        }

        public override void Clear()
        { 
            base.Clear();
            items = null; 
            size = -1; 
        }
    } 

    internal class XmlDataNode : DataNode
    {
        IList xmlAttributes; 
        IList xmlChildNodes;
        XmlDocument ownerDocument; 
 
        internal XmlDataNode()
        { 
            dataType = Globals.TypeOfXmlDataNode;
        }

        internal IList XmlAttributes 
        {
            get { return xmlAttributes; } 
            set { xmlAttributes = value; } 
        }
 
        internal IList XmlChildNodes
        {
            get { return xmlChildNodes; }
            set { xmlChildNodes = value; } 
        }
 
        internal XmlDocument OwnerDocument 
        {
            get { return ownerDocument; } 
            set { ownerDocument = value; }
        }

        public override void Clear() 
        {
            base.Clear(); 
            xmlAttributes = null; 
            xmlChildNodes = null;
            ownerDocument = null; 
        }
    }

    internal class ISerializableDataNode : DataNode 
    {
        string factoryTypeName; 
        string factoryTypeNamespace; 
        IList members;
 
        internal ISerializableDataNode()
        {
            dataType = Globals.TypeOfISerializableDataNode;
        } 

        internal string FactoryTypeName 
        { 
            get { return factoryTypeName; }
            set { factoryTypeName = value; } 
        }

        internal string FactoryTypeNamespace
        { 
            get { return factoryTypeNamespace; }
            set { factoryTypeNamespace = value; } 
        } 

        internal IList Members 
        {
            get { return members; }
            set { members = value; }
        } 

        public override void GetData(ElementData element) 
        { 
            base.GetData(element);
 
            if (FactoryTypeName != null)
                AddQualifiedNameAttribute(element, Globals.SerPrefix, Globals.ISerializableFactoryTypeLocalName, Globals.SerializationNamespace, FactoryTypeName, FactoryTypeNamespace);
        }
 
        public override void Clear()
        { 
            base.Clear(); 
            members = null;
            factoryTypeName = factoryTypeNamespace = null; 
        }
    }

    internal class ISerializableDataMember 
    {
        string name; 
        IDataNode value; 

        internal string Name 
        {
            get { return name; }
            set { name = value; }
        } 

        internal IDataNode Value 
        { 
            get { return value; }
            set { this.value = value; } 
        }
    }

} 

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