EdmType.cs source code in C# .NET

Source code for the .NET framework in C#

                        

Code:

/ 4.0 / 4.0 / untmp / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / fx / src / DataEntity / System / Data / Metadata / Edm / EdmType.cs / 1305376 / EdmType.cs

                            //---------------------------------------------------------------------- 
// 
//      Copyright (c) Microsoft Corporation.  All rights reserved.
// 
// 
// @owner       [....]
// @backupOwner [....] 
//--------------------------------------------------------------------- 
using System.Data.Common;
using System.Globalization; 
using System.Diagnostics;
using System.Collections.Generic;
using System.Text;
using System.Threading; 

namespace System.Data.Metadata.Edm 
{ 
    /// 
    /// Base EdmType class for all the model types 
    /// 
    [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "Edm")]
    public abstract class EdmType : GlobalItem
    { 
        #region Constructors
        ///  
        /// Initializes a new instance of EdmType 
        /// 
        internal EdmType() 
        {
            // No initialization of item attributes in here, it's used as a pass thru in the case for delay population
            // of item attributes
        } 

        ///  
        /// Constructs a new instance of EdmType with the given name, namespace and version 
        /// 
        /// name of the type 
        /// namespace of the type
        /// version of the type
        /// dataSpace in which this edmtype belongs to
        /// Thrown if either the name, namespace or version arguments are null 
        internal EdmType(string name,
                         string namespaceName, 
                         DataSpace dataSpace) 
        {
            EntityUtil.GenericCheckArgumentNull(name, "name"); 
            EntityUtil.GenericCheckArgumentNull(namespaceName, "namespaceName");

            // Initialize the item attributes
            EdmType.Initialize(this, 
                               name,
                               namespaceName, 
                               dataSpace, 
                               false,
                               null); 
        }
        #endregion

        #region Fields 
        private CollectionType _collectionType;
        private string _identity; 
        private string _name; 
        private string _namespace;
        private EdmType _baseType; 
        #endregion

        #region Properties
        ///  
        /// Direct accessor for the field Identity. The reason we need to do this is that for derived class,
        /// they want to cache things only when they are readonly. Plus they want to check for null before 
        /// updating the value 
        /// 
        internal string CacheIdentity 
        {
            get
            {
                return _identity; 
            }
            private set 
            { 
                _identity = value;
            } 
        }

        /// 
        /// Returns the identity of the edm type 
        /// 
        internal override string Identity 
        { 
            get
            { 
                if (this.CacheIdentity == null)
                {
                    StringBuilder builder = new StringBuilder(50);
                    BuildIdentity(builder); 
                    this.CacheIdentity = builder.ToString();
                } 
                return this.CacheIdentity; 
            }
        } 

        /// 
        /// Returns the name of the EdmType
        ///  
        [MetadataProperty(PrimitiveTypeKind.String, false)]
        public String Name 
        { 
            get
            { 
                return _name;
            }
            internal set
            { 
                Debug.Assert(value != null, "The name should never be set to null");
                _name = value; 
            } 
        }
 
        /// 
        /// Returns the namespace of the EdmType
        /// 
        [MetadataProperty(PrimitiveTypeKind.String, false)] 
        public String NamespaceName
        { 
            get 
            {
                return _namespace; 
            }
            internal set
            {
                Debug.Assert(value != null, "Namespace should never be set to null"); 
                _namespace = value;
            } 
        } 

        ///  
        /// Returns true if the EdmType is abstract
        /// 
        /// Thrown if the setter is called on instance that is in ReadOnly state
        [MetadataProperty(PrimitiveTypeKind.Boolean, false)] 
        public bool Abstract
        { 
            get 
            {
                return GetFlag(MetadataFlags.IsAbstract); 
            }
            internal set
            {
                SetFlag(MetadataFlags.IsAbstract, value); 
            }
        } 
 
        /// 
        /// Returns the base type of the EdmType 
        /// 
        /// Thrown if the setter is called on instance that is in ReadOnly state
        /// Thrown if the value passed in for setter will create a loop in the inheritance chain
        [MetadataProperty(BuiltInTypeKind.EdmType, false)] 
        public EdmType BaseType
        { 
            get 
            {
                return _baseType; 
            }
            internal set
            {
                Util.ThrowIfReadOnly(this); 
                Debug.Assert(_baseType == null, "BaseType can't be set multiple times");
 
                // Check to make sure there won't be a loop in the inheritance 
                EdmType type = value;
                while (type != null) 
                {
                    Debug.Assert(type != this, "Cannot set the given type as base type because it would introduce a loop in inheritance");

                    type = type.BaseType; 
                }
 
                // Also if the base type is EntityTypeBase, make sure it doesn't have keys 
                Debug.Assert(value == null ||
                             !Helper.IsEntityTypeBase(this) || 
                             ((EntityTypeBase)this).KeyMembers.Count == 0 ||
                             ((EntityTypeBase)value).KeyMembers.Count == 0,
                             " For EntityTypeBase, both base type and derived types cannot have keys defined");
 
                _baseType = value;
            } 
        } 

        ///  
        /// Returns the full name of this type, which is namespace + "." + name.
        /// Since the identity of all EdmTypes, except EdmFunction, is same as of that
        /// of the full name, FullName just returns the identity. This property is
        /// over-ridden in EdmFunctin, just to return NamespaceName + "." + Name 
        /// 
        public virtual string FullName 
        { 
            get
            { 
                return this.Identity;
           }
        }
 
        /// 
        /// If OSpace, return the CLR Type else null 
        ///  
        /// Thrown if the setter is called on instance that is in ReadOnly state
        internal virtual System.Type ClrType 
        {
            get { return null; }
        }
 
        internal override void BuildIdentity(StringBuilder builder)
        { 
            // if we already know the identity, simply append it 
            if (null != this.CacheIdentity)
            { 
                builder.Append(this.CacheIdentity);
                return;
            }
 
            builder.Append(CreateEdmTypeIdentity(NamespaceName, Name));
        } 
 
        internal static string CreateEdmTypeIdentity(string namespaceName, string name)
        { 
            string identity = string.Empty;
            if (string.Empty != namespaceName)
            {
                identity = namespaceName + "."; 
            }
 
            identity += name; 

            return identity; 

        }

        #endregion 

        #region Methods 
        ///  
        /// Initialize the type. This method must be called since for bootstraping we only call the constructor.
        /// This method will help us initialize the type 
        /// 
        /// The edm type to initialize with item attributes
        /// The name of this type
        /// The namespace of this type 
        /// The version of this type
        /// dataSpace in which this edmtype belongs to 
        /// If the type is abstract 
        /// If the type is sealed
        /// The base type for this type 
        internal static void
            Initialize(EdmType edmType,
                                        string name,
                                        string namespaceName, 
                                        DataSpace dataSpace,
                                        bool isAbstract, 
                                        EdmType baseType) 
        {
            edmType._baseType = baseType; 
            edmType._name = name;
            edmType._namespace = namespaceName;
            edmType.DataSpace = dataSpace;
            edmType.Abstract = isAbstract; 
        }
 
        ///  
        /// Overriding System.Object.ToString to provide better String representation
        /// for this type. 
        /// 
        public override string ToString()
        {
            return this.FullName; 
        }
 
        ///  
        /// Returns the collection type whose element type is this edm type
        ///  
        public CollectionType GetCollectionType()
        {
            if (_collectionType == null)
            { 
                Interlocked.CompareExchange(ref _collectionType, new CollectionType(this), null);
            } 
 
            return _collectionType;
        } 

        /// 
        /// check to see if otherType is among the base types,
        ///  
        /// 
        ///  
        /// if otherType is among the base types, return true, 
        /// otherwise returns false.
        /// when othertype is same as the current type, return false. 
        /// 
        internal virtual bool IsSubtypeOf(EdmType otherType)
        {
            return Helper.IsSubtypeOf(this, otherType); 
        }
 
        ///  
        /// check to see if otherType is among the sub-types,
        ///  
        /// 
        /// 
        /// if otherType is among the sub-types, returns true,
        /// otherwise returns false. 
        /// when othertype is same as the current type, return false.
        ///  
        internal virtual bool IsBaseTypeOf(EdmType otherType) 
        {
            if (otherType == null) 
                return false;
            return otherType.IsSubtypeOf(this);
        }
 
        /// 
        /// Check if this type is assignable from otherType 
        ///  
        /// 
        ///  
        internal virtual bool IsAssignableFrom(EdmType otherType)
        {
            return Helper.IsAssignableFrom(this, otherType);
        } 

        ///  
        /// Sets this item to be readonly, once this is set, the item will never be writable again. 
        /// 
        internal override void SetReadOnly() 
        {
            if (!IsReadOnly)
            {
                base.SetReadOnly(); 

                EdmType baseType = BaseType; 
                if (baseType != null) 
                {
                    baseType.SetReadOnly(); 
                }
            }
        }
 
        /// 
        /// Returns all facet descriptions associated with this type. 
        ///  
        /// Descriptions for all built-in facets for this type.
        internal virtual IEnumerable GetAssociatedFacetDescriptions() 
        {
            return MetadataItem.GetGeneralFacetDescriptions();
        }
        #endregion 
    }
} 

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
                        

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