AssociationSetMetadata.cs source code in C# .NET

                        Code:
                         / 4.0 / 4.0 / untmp / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / fx / src / DataEntity / System / Data / Map / Update / Internal / AssociationSetMetadata.cs / 1305376 / AssociationSetMetadata.cs
                        
                        
                            //---------------------------------------------------------------------- 
// 
//      Copyright (c) Microsoft Corporation.  All rights reserved.
// 
// 
// @owner [....]
// @backupOwner [....] 
//--------------------------------------------------------------------- 

using System.Data.Metadata.Edm; 
using System.Data.Common.Utils;
using System.Data.Common.CommandTrees;
using System.Collections.Generic;
using System.Linq; 
namespace System.Data.Mapping.Update.Internal
{ 
    ///  
    /// Encapsulates information about ends of an association set needed to correctly
    /// interpret updates. 
    /// 
    internal sealed class AssociationSetMetadata
    {
        ///  
        /// Gets association ends that must be modified if the association
        /// is changed (e.g. the mapping of the association is conditioned 
        /// on some property of the end) 
        /// 
        internal readonly Set RequiredEnds; 
        /// 
        /// Gets association ends that may be implicitly modified as a result
        /// of changes to the association (e.g. collocated entity with server
        /// generated value) 
        /// 
        internal readonly Set OptionalEnds; 
        ///  
        /// Gets association ends whose values may influence the association
        /// (e.g. where there is a ReferentialIntegrity or "foreign key" constraint) 
        /// 
        internal readonly Set IncludedValueEnds;
        /// 
        /// true iff. there are interesting ends for this association set. 
        /// 
        internal bool HasEnds 
        { 
            get { return 0 < RequiredEnds.Count || 0 < OptionalEnds.Count || 0 < IncludedValueEnds.Count; }
        } 

        /// 
        /// Initialize Metadata for an AssociationSet
        ///  
        internal AssociationSetMetadata(Set affectedTables, AssociationSet associationSet, MetadataWorkspace workspace)
        { 
            // If there is only 1 table, there can be no ambiguity about the "destination" of a relationship, so such 
            // sets are not typically required.
            bool isRequired = 1 < affectedTables.Count; 

            // determine the ends of the relationship
            var ends = associationSet.AssociationSetEnds;
 
            // find collocated entities
            foreach (EntitySet table in affectedTables) 
            { 
                // Find extents influencing the table
                var influencingExtents = MetadataHelper.GetInfluencingEntitySetsForTable(table, workspace); 

                foreach (EntitySet influencingExtent in influencingExtents)
                {
                    foreach (var end in ends) 
                    {
                        // If the extent is an end of the relationship and we haven't already added it to the 
                        // required set... 
                        if (end.EntitySet.EdmEquals(influencingExtent))
                        { 
                            if (isRequired)
                            {
                                AddEnd(ref RequiredEnds, end.CorrespondingAssociationEndMember);
                            } 
                            else if (null == RequiredEnds || !RequiredEnds.Contains(end.CorrespondingAssociationEndMember))
                            { 
                                AddEnd(ref OptionalEnds, end.CorrespondingAssociationEndMember); 
                            }
                        } 
                    }
                }
            }
 
            // fix Required and Optional sets
            FixSet(ref RequiredEnds); 
            FixSet(ref OptionalEnds); 

            // for associations with referential constraints, the principal end is always interesting 
            // since its key values may take precedence over the key values of the dependent end
            foreach (ReferentialConstraint constraint in associationSet.ElementType.ReferentialConstraints)
            {
                // FromRole is the principal end in the referential constraint 
                AssociationEndMember principalEnd = (AssociationEndMember)constraint.FromRole;
 
                if (!RequiredEnds.Contains(principalEnd) && 
                    !OptionalEnds.Contains(principalEnd))
                { 
                    AddEnd(ref IncludedValueEnds, principalEnd);
                }
            }
 
            FixSet(ref IncludedValueEnds);
        } 
 
        /// 
        /// Initialize given required ends. 
        /// 
        internal AssociationSetMetadata(IEnumerable requiredEnds)
        {
            if (requiredEnds.Any()) 
            {
                RequiredEnds = new Set(requiredEnds); 
            } 
            FixSet(ref RequiredEnds);
            FixSet(ref OptionalEnds); 
            FixSet(ref IncludedValueEnds);
        }

        static private void AddEnd(ref Set set, AssociationEndMember element) 
        {
            if (null == set) 
            { 
                set = new Set();
            } 
            set.Add(element);
        }

        static private void FixSet(ref Set set) 
        {
            if (null == set) 
            { 
                set = Set.Empty;
            } 
            else
            {
                set.MakeReadOnly();
            } 
        }
    } 
} 

// 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
AssociationSetMetadata.cs source code in C# .NET

Source code for the .NET framework in C#

Code:

Link Menu
