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

                        
                            //---------------------------------------------------------------------- 
// 
//      Copyright (c) Microsoft Corporation.  All rights reserved.
// 
// 
// @owner       [....]
// @backupOwner [....] 
//--------------------------------------------------------------------- 
using System;
using System.Collections.Generic; 
using System.Diagnostics;
using System.Data.Common;
using System.Text;
 
namespace System.Data.Metadata.Edm
{ 
    ///  
    /// Represents the Structural Type
    ///  
    public abstract class StructuralType : EdmType
    {
        #region Constructors
        ///  
        /// Internal parameterless constructor for bootstrapping edmtypes
        ///  
        internal StructuralType() 
        {
            _members = new MemberCollection(this); 
            _readOnlyMembers = _members.AsReadOnlyMetadataCollection();
        }

        ///  
        /// Initializes a new instance of Structural Type with the given members
        ///  
        /// name of the structural type 
        /// namespace of the structural type
        /// version of the structural type 
        /// dataSpace in which this edmtype belongs to
        /// Thrown if either name, namespace or version arguments are null
        internal StructuralType(string name, string namespaceName, DataSpace dataSpace)
            : base(name, namespaceName, dataSpace) 
        {
            _members = new MemberCollection(this); 
            _readOnlyMembers = _members.AsReadOnlyMetadataCollection(); 
        }
        #endregion 

        #region Fields
        private readonly MemberCollection _members;
        private readonly ReadOnlyMetadataCollection _readOnlyMembers; 
        #endregion
 
        #region Properties 

        ///  
        /// Returns the collection of members.
        /// 
        [MetadataProperty(BuiltInTypeKind.EdmMember, true)]
        public ReadOnlyMetadataCollection Members 
        {
            get 
            { 
                return _readOnlyMembers;
            } 
        }
        #endregion

        #region Methods 

        ///  
        /// Get the declared only members of a particular type 
        /// 
        internal ReadOnlyMetadataCollection GetDeclaredOnlyMembers() where T : EdmMember 
        {
            return _members.GetDeclaredOnlyMembers();
        }
 
        /// 
        /// Validates the types and sets the readOnly property to true. Once the type is set to readOnly, 
        /// it can never be changed. 
        /// 
        internal override void SetReadOnly() 
        {
            if (!IsReadOnly)
            {
                base.SetReadOnly(); 
                this.Members.Source.SetReadOnly();
            } 
        } 

        ///  
        /// Validates a EdmMember object to determine if it can be added to this type's
        /// Members collection. If this method returns without throwing, it is assumed
        /// the member is valid.
        ///  
        /// The member to validate
        internal abstract void ValidateMemberForAdd(EdmMember member); 
 
        /// 
        /// Adds a member to this type 
        /// 
        /// The member to add
        internal void AddMember(EdmMember member)
        { 
            EntityUtil.GenericCheckArgumentNull(member, "member");
            Util.ThrowIfReadOnly(this); 
            Debug.Assert(this.DataSpace == member.TypeUsage.EdmType.DataSpace || this.BuiltInTypeKind == BuiltInTypeKind.RowType, "Wrong member type getting added in structural type"); 

            //Since we set the DataSpace of the RowType to be -1 in the constructor, we need to initialize it 
            //as and when we add members to it
            if (BuiltInTypeKind.RowType == this.BuiltInTypeKind)
            {
                // Do this only when you are adding the first member 
                if (_members.Count == 0)
                { 
                    this.DataSpace = member.TypeUsage.EdmType.DataSpace; 
                }
                // We need to build types that span across more than one space. For such row types, we set the 
                // DataSpace to -1
                else if (this.DataSpace != (DataSpace)(-1) && member.TypeUsage.EdmType.DataSpace != this.DataSpace)
                {
                    this.DataSpace = (DataSpace)(-1); 
                }
            } 
            this._members.Add(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