EntityTypeBase.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 / EntityTypeBase.cs / 1305376 / EntityTypeBase.cs

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

namespace System.Data.Metadata.Edm 
{ 
    /// 
    /// Represents the Entity Type 
    /// 
    public abstract class EntityTypeBase : StructuralType
    {
        #region Constructors 
        /// 
        /// Initializes a new instance of Entity Type 
        ///  
        /// name of the entity type
        /// namespace of the entity type 
        /// version of the entity type
        /// dataSpace in which this edmtype belongs to
        /// Thrown if either name, namespace or version arguments are null
        internal EntityTypeBase(string name, string namespaceName, DataSpace dataSpace) 
            : base(name, namespaceName, dataSpace)
        { 
            _keyMembers = new ReadOnlyMetadataCollection(new MetadataCollection()); 
        }
        #endregion 

        #region Fields
        private readonly ReadOnlyMetadataCollection _keyMembers;
        private string[] _keyMemberNames; 
        #endregion
 
        #region Properties 
        /// 
        /// Returns the list of all the key members for this entity type 
        /// 
        [MetadataProperty(BuiltInTypeKind.EdmMember, true)]
        public ReadOnlyMetadataCollection KeyMembers
        { 
            get
            { 
                // Since we allow entity types with no keys, we should first check if there are 
                // keys defined on the base class. If yes, then return the keys otherwise, return
                // the keys defined on this class 
                if (this.BaseType != null && ((EntityTypeBase)this.BaseType).KeyMembers.Count != 0)
                {
                    Debug.Assert(_keyMembers.Count == 0, "Since the base type have keys, current type cannot have keys defined");
                    return ((EntityTypeBase)this.BaseType).KeyMembers; 
                }
                else 
                { 
                    return _keyMembers;
                } 
            }
        }

        ///  
        /// Returns the list of the member names that form the key for this entity type
        /// Perf Bug #529294: To cache the list of member names that form the key for the entity type 
        ///  
        internal string[] KeyMemberNames
        { 
            get
            {
                String[] keyNames = _keyMemberNames;
                if (keyNames == null) 
                {
                    keyNames = new string[this.KeyMembers.Count]; 
                    for (int i = 0; i < keyNames.Length; i++) 
                    {
                        keyNames[i] = this.KeyMembers[i].Name; 
                    }
                    _keyMemberNames = keyNames;
                }
                Debug.Assert(_keyMemberNames.Length == this.KeyMembers.Count, "This list is out of [....] with the key members count. This property was called before all the keymembers were added"); 
                return _keyMemberNames;
            } 
        } 

        #endregion 

        #region Methods
        /// 
        /// Returns the list of all the key members for this entity type 
        /// 
        /// if member argument is null 
        /// Thrown if the EntityType has a base type of another EntityTypeBase. In this case KeyMembers should be added to the base type 
        /// If the EntityType instance is in ReadOnly state
        internal void AddKeyMember(EdmMember member) 
        {
            EntityUtil.GenericCheckArgumentNull(member, "member");
            Util.ThrowIfReadOnly(this);
            Debug.Assert(this.BaseType == null || ((EntityTypeBase)this.BaseType).KeyMembers.Count == 0, 
                "Key cannot be added if there is a basetype with keys");
 
            if (!Members.Contains(member)) 
            {
                this.AddMember(member); 
            }
            _keyMembers.Source.Add(member);
        }
 
        /// 
        /// Makes this property readonly 
        ///  
        internal override void SetReadOnly()
        { 
            if (!IsReadOnly)
            {
                _keyMembers.Source.SetReadOnly();
                base.SetReadOnly(); 
            }
        } 
 
        /// 
        /// Checks for each property to be non-null and then adds it to the member collection 
        /// 
        /// members for this type
        /// the membersCollection to which the members should be added
        internal static void CheckAndAddMembers(IEnumerable members, 
                                                EntityType entityType)
        { 
            foreach (EdmMember member in members) 
            {
                // Check for each property to be non-null 
                if (null == member)
                    throw EntityUtil.CollectionParameterElementIsNull("members");

                // Add the property to the member collection 
                entityType.AddMember(member);
            } 
        } 

 
        /// 
        /// Checks for each key member to be non-null
        /// also check for it to be present in the members collection
        /// and then adds it to the KeyMembers collection. 
        ///
        /// Throw if the key member is not already in the members 
        /// collection. Cannot do much other than that as the 
        /// Key members is just an Ienumerable of the names
        /// of the members. 
        /// 
        /// the list of keys (member names) to be added for the given type
        internal void CheckAndAddKeyMembers(IEnumerable keyMembers)
        { 
            foreach (string keyMember in keyMembers)
            { 
                // Check for each keymember to be non-null 
                if (null == keyMember)
                { 
                    throw EntityUtil.CollectionParameterElementIsNull("keyMembers");
                }
                // Check for whether the key exists in the members collection
                EdmMember member; 
                if (!Members.TryGetValue(keyMember, false, out member))
                { 
                    throw EntityUtil.Argument(System.Data.Entity.Strings.InvalidKeyMember(keyMember)); //--- to do, identify the right exception to throw here 
                }
                // Add the key member to the key member collection 
                AddKeyMember(member);
            }
        }
 
        #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