metadatamappinghashervisitor.cs source code in C# .NET

Source code for the .NET framework in C#

                        

Code:

/ Dotnetfx_Vista_SP2 / Dotnetfx_Vista_SP2 / 8.0.50727.4016 / DEVDIV / depot / DevDiv / releases / Orcas / QFE / ndp / fx / src / DataEntity / System / Data / Mapping / metadatamappinghashervisitor.cs / 1 / metadatamappinghashervisitor.cs

                            //---------------------------------------------------------------------- 
// 
//      Copyright (c) Microsoft Corporation.  All rights reserved.
// 
 
// @owner       [....]
// @backupOwner [....] 
//--------------------------------------------------------------------- 

using System; 
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Data.Metadata.Edm; 
using System.Data.Common;
using System.Data.Common.Utils; 
using System.Data.Mapping; 
using System.Diagnostics;
 

namespace System.Data.Mapping
{
    internal partial class MetadataMappingHasherVisitor : BaseMetadataMappingVisitor 
    {
        private CompressingHashBuilder m_hashSourceBuilder = new CompressingHashBuilder(); 
        private Dictionary m_itemsAlreadySeen = new Dictionary(); 
        private int m_instanceNumber = 0;
        private ItemCollection m_itemCollection; 

        private MetadataMappingHasherVisitor(ItemCollection edmItemCollection)
        {
            Debug.Assert(edmItemCollection != null, "itemCollection is null!"); 
            this.m_itemCollection = edmItemCollection;
        } 
 
        #region visitor method
        protected override void Visit(StorageEntityContainerMapping storageEntityContainerMapping) 
        {
            int index;
            if (!this.AddObjectToSeenListAndHashBuilder(storageEntityContainerMapping, out index))
            { 
                // if this has been add to the seen list, then just
                return; 
            } 
            if (this.m_itemsAlreadySeen.Count > 1)
            { 

                // this means user try another visit over SECM, this is allowed but all the previous visit all lost due to clean
                // user can visit different SECM objects by using the same visitor to load the SECM object
                this.Clean(); 
                Visit(storageEntityContainerMapping);
                return; 
            } 

            this.AddObjectStartDumpToHashBuilder(storageEntityContainerMapping, index); 

            #region Inner data visit

            this.AddObjectContentToHashBuilder(storageEntityContainerMapping.Identity); 

            base.Visit(storageEntityContainerMapping); 
 
            #endregion
 
            this.AddObjectEndDumpToHashBuilder();
        }

        protected override void Visit(EntityContainer entityContainer) 
        {
            int index; 
            if (!this.AddObjectToSeenListAndHashBuilder(entityContainer, out index)) 
            {
                return; 
            }

            this.AddObjectStartDumpToHashBuilder(entityContainer, index);
 
            #region Inner data visit
 
            this.AddObjectContentToHashBuilder(entityContainer.Identity); 
            // Name is covered by Identity
 
            base.Visit(entityContainer);

            #endregion
 
            this.AddObjectEndDumpToHashBuilder();
        } 
 
        protected override void Visit(StorageSetMapping storageSetMapping)
        { 
            int index;
            if (!this.AddObjectToSeenListAndHashBuilder(storageSetMapping, out index))
            {
                return; 
            }
 
            this.AddObjectStartDumpToHashBuilder(storageSetMapping, index); 

            #region Inner data visit 
            base.Visit(storageSetMapping);
            #endregion

            this.AddObjectEndDumpToHashBuilder(); 
        }
 
        protected override void Visit(StorageTypeMapping storageTypeMapping) 
        {
            int index; 
            if (!this.AddObjectToSeenListAndHashBuilder(storageTypeMapping, out index))
            {
                return;
            } 

            this.AddObjectStartDumpToHashBuilder(storageTypeMapping, index); 
 
            #region Inner data visit
 
            base.Visit(storageTypeMapping);

            #endregion
 
            this.AddObjectEndDumpToHashBuilder();
        } 
 
        protected override void Visit(StorageMappingFragment storageMappingFragment)
        { 
            int index;
            if (!this.AddObjectToSeenListAndHashBuilder(storageMappingFragment, out index))
            {
                return; 
            }
 
            this.AddObjectStartDumpToHashBuilder(storageMappingFragment, index); 

            #region Inner data visit 

            base.Visit(storageMappingFragment);

            #endregion 

            this.AddObjectEndDumpToHashBuilder(); 
        } 

        protected override void Visit(StoragePropertyMapping storagePropertyMapping) 
        {
            base.Visit(storagePropertyMapping);
        }
 
        protected override void Visit(StorageComplexPropertyMapping storageComplexPropertyMapping)
        { 
            int index; 
            if (!this.AddObjectToSeenListAndHashBuilder(storageComplexPropertyMapping, out index))
            { 
                return;
            }

            this.AddObjectStartDumpToHashBuilder(storageComplexPropertyMapping, index); 

            #region Inner data visit 
 
            base.Visit(storageComplexPropertyMapping);
 
            #endregion

            this.AddObjectEndDumpToHashBuilder();
        } 
        protected override void Visit(StorageComplexTypeMapping storageComplexTypeMapping)
        { 
            int index; 
            if (!this.AddObjectToSeenListAndHashBuilder(storageComplexTypeMapping, out index))
            { 
                return;
            }

            this.AddObjectStartDumpToHashBuilder(storageComplexTypeMapping, index); 

            #region Inner data visit 
 
            base.Visit(storageComplexTypeMapping);
 
            #endregion

            this.AddObjectEndDumpToHashBuilder();
        } 

        protected override void Visit(StorageConditionPropertyMapping storageConditionPropertyMapping) 
        { 
            int index;
            if (!this.AddObjectToSeenListAndHashBuilder(storageConditionPropertyMapping, out index)) 
            {
                return;
            }
 
            this.AddObjectStartDumpToHashBuilder(storageConditionPropertyMapping, index);
 
            #region Inner data visit 
            this.AddObjectContentToHashBuilder(storageConditionPropertyMapping.IsNull);
            this.AddObjectContentToHashBuilder(storageConditionPropertyMapping.Value); 

            base.Visit(storageConditionPropertyMapping);

            #endregion 

            this.AddObjectEndDumpToHashBuilder(); 
        } 

        protected override void Visit(StorageScalarPropertyMapping storageScalarPropertyMapping) 
        {
            int index;
            if (!this.AddObjectToSeenListAndHashBuilder(storageScalarPropertyMapping, out index))
            { 
                return;
            } 
 
            this.AddObjectStartDumpToHashBuilder(storageScalarPropertyMapping, index);
 
            #region Inner data visit

            base.Visit(storageScalarPropertyMapping);
 
            #endregion
 
            this.AddObjectEndDumpToHashBuilder(); 
        }
 
        protected override void Visit(EntitySetBase entitySetBase)
        {
            base.Visit(entitySetBase);
        } 

        protected override void Visit(EntitySet entitySet) 
        { 
            int index;
            if (!this.AddObjectToSeenListAndHashBuilder(entitySet, out index)) 
            {
                return;
            }
            #region Inner data visit 

            this.AddObjectStartDumpToHashBuilder(entitySet, index); 
            this.AddObjectContentToHashBuilder(entitySet.Name); 
            this.AddObjectContentToHashBuilder(entitySet.Schema);
            this.AddObjectContentToHashBuilder(entitySet.Table); 

            base.Visit(entitySet);

            foreach (var entityType in MetadataHelper.GetTypeAndSubtypesOf(entitySet.ElementType, this.m_itemCollection, false).Where(type => type != entitySet.ElementType)) 
            {
                this.Visit(entityType); 
            } 

            #endregion 

            this.AddObjectEndDumpToHashBuilder();
        }
 
        protected override void Visit(AssociationSet associationSet)
        { 
            int index; 
            if (!this.AddObjectToSeenListAndHashBuilder(associationSet, out index))
            { 
                return;
            }

            this.AddObjectStartDumpToHashBuilder(associationSet, index); 

            #region Inner data visit 
            this.AddObjectContentToHashBuilder(associationSet.CachedProviderSql); 
            // Name is coverd by Identity
            this.AddObjectContentToHashBuilder(associationSet.Identity); 
            this.AddObjectContentToHashBuilder(associationSet.Schema);
            this.AddObjectContentToHashBuilder(associationSet.Table);

            base.Visit(associationSet); 

            #endregion 
 
            this.AddObjectEndDumpToHashBuilder();
        } 

        protected override void Visit(EntityType entityType)
        {
            int index; 
            if (!this.AddObjectToSeenListAndHashBuilder(entityType, out index))
            { 
                return; 
            }
 
            this.AddObjectStartDumpToHashBuilder(entityType, index);

            #region Inner data visit
            this.AddObjectContentToHashBuilder(entityType.Abstract); 
            this.AddObjectContentToHashBuilder(entityType.Identity);
            // FullName, Namespace and Name are all covered by Identity 
 
            base.Visit(entityType);
 
            #endregion

            this.AddObjectEndDumpToHashBuilder();
        } 

        protected override void Visit(AssociationSetEnd associationSetEnd) 
        { 
            int index;
            if (!this.AddObjectToSeenListAndHashBuilder(associationSetEnd, out index)) 
            {
                return;
            }
 
            this.AddObjectStartDumpToHashBuilder(associationSetEnd, index);
 
            #region Inner data visit 
            this.AddObjectContentToHashBuilder(associationSetEnd.Identity);
            // Name is covered by Identity 

            base.Visit(associationSetEnd);

            #endregion 

            this.AddObjectEndDumpToHashBuilder(); 
        } 

        protected override void Visit(AssociationType associationType) 
        {
            int index;
            if (!this.AddObjectToSeenListAndHashBuilder(associationType, out index))
            { 
                return;
            } 
 
            this.AddObjectStartDumpToHashBuilder(associationType, index);
 
            #region Inner data visit
            this.AddObjectContentToHashBuilder(associationType.Abstract);
            this.AddObjectContentToHashBuilder(associationType.Identity);
            // FullName, Namespace, and Name are all covered by Identity 

            base.Visit(associationType); 
 
            #endregion
 
            this.AddObjectEndDumpToHashBuilder();
        }

        protected override void Visit(EdmProperty edmProperty) 
        {
            int index; 
            if (!this.AddObjectToSeenListAndHashBuilder(edmProperty, out index)) 
            {
                return; 
            }

            this.AddObjectStartDumpToHashBuilder(edmProperty, index);
 
            #region Inner data visit
            // since the delaring type is fixed and referenced to the upper type, 
            // there is no need to hash this 
            //this.AddObjectContentToHashBuilder(edmProperty.DeclaringType);
            this.AddObjectContentToHashBuilder(edmProperty.DefaultValue); 
            this.AddObjectContentToHashBuilder(edmProperty.Identity);
            // Name is covered by Identity
            this.AddObjectContentToHashBuilder(edmProperty.IsStoreGeneratedComputed);
            this.AddObjectContentToHashBuilder(edmProperty.IsStoreGeneratedIdentity); 
            this.AddObjectContentToHashBuilder(edmProperty.Nullable);
 
            base.Visit(edmProperty); 

            #endregion 

            this.AddObjectEndDumpToHashBuilder();
        }
 
        protected override void Visit(NavigationProperty navigationProperty)
        { 
            // navigation properties are not considered in view generation 
            return;
        } 

        protected override void Visit(EdmMember edmMember)
        {
            int index; 
            if (!this.AddObjectToSeenListAndHashBuilder(edmMember, out index))
            { 
                return; 
            }
 
            this.AddObjectStartDumpToHashBuilder(edmMember, index);

            #region Inner data visit
            this.AddObjectContentToHashBuilder(edmMember.Identity); 
            // Name is covered by Identity
            this.AddObjectContentToHashBuilder(edmMember.IsStoreGeneratedComputed); 
            this.AddObjectContentToHashBuilder(edmMember.IsStoreGeneratedIdentity); 

            base.Visit(edmMember); 

            #endregion

            this.AddObjectEndDumpToHashBuilder(); 
        }
 
        protected override void Visit(AssociationEndMember associationEndMember) 
        {
            int index; 
            if (!this.AddObjectToSeenListAndHashBuilder(associationEndMember, out index))
            {
                return;
            } 

            this.AddObjectStartDumpToHashBuilder(associationEndMember, index); 
 
            #region Inner data visit
            this.AddObjectContentToHashBuilder(associationEndMember.DeleteBehavior); 
            this.AddObjectContentToHashBuilder(associationEndMember.Identity);
            // Name is covered by Identity
            this.AddObjectContentToHashBuilder(associationEndMember.IsStoreGeneratedComputed);
            this.AddObjectContentToHashBuilder(associationEndMember.IsStoreGeneratedIdentity); 
            this.AddObjectContentToHashBuilder(associationEndMember.RelationshipMultiplicity);
 
            base.Visit(associationEndMember); 

            #endregion 

            this.AddObjectEndDumpToHashBuilder();
        }
 
        protected override void Visit(ReferentialConstraint referentialConstraint)
        { 
            int index; 
            if (!this.AddObjectToSeenListAndHashBuilder(referentialConstraint, out index))
            { 
                return;
            }

            this.AddObjectStartDumpToHashBuilder(referentialConstraint, index); 

            #region Inner data visit 
            this.AddObjectContentToHashBuilder(referentialConstraint.Identity); 

            base.Visit(referentialConstraint); 

            #endregion

            this.AddObjectEndDumpToHashBuilder(); 
        }
 
        protected override void Visit(RelationshipEndMember relationshipEndMember) 
        {
            int index; 
            if (!this.AddObjectToSeenListAndHashBuilder(relationshipEndMember, out index))
            {
                return;
            } 

            this.AddObjectStartDumpToHashBuilder(relationshipEndMember, index); 
 
            #region Inner data visit
            this.AddObjectContentToHashBuilder(relationshipEndMember.DeleteBehavior); 
            this.AddObjectContentToHashBuilder(relationshipEndMember.Identity);
            // Name is covered by Identity
            this.AddObjectContentToHashBuilder(relationshipEndMember.IsStoreGeneratedComputed);
            this.AddObjectContentToHashBuilder(relationshipEndMember.IsStoreGeneratedIdentity); 
            this.AddObjectContentToHashBuilder(relationshipEndMember.RelationshipMultiplicity);
 
            base.Visit(relationshipEndMember); 

            #endregion 

            this.AddObjectEndDumpToHashBuilder();
        }
 
        protected override void Visit(TypeUsage typeUsage)
        { 
            int index; 
            if (!this.AddObjectToSeenListAndHashBuilder(typeUsage, out index))
            { 
                return;
            }

            this.AddObjectStartDumpToHashBuilder(typeUsage, index); 

            #region Inner data visit 
            //No need to add identity of TypeUsage to the hash since it would take into account 
            //facets that viewgen would not care and we visit the important facets anyway.
 
            base.Visit(typeUsage);

            #endregion
 
            this.AddObjectEndDumpToHashBuilder();
        } 
 
        protected override void Visit(RelationshipType relationshipType)
        { 
            base.Visit(relationshipType);
        }

        protected override void Visit(EdmType edmType) 
        {
            base.Visit(edmType); 
        } 

        protected override void Visit(EnumType enumType) 
        {
            Debug.Fail("We don't allow enumTypes publicly");
        }
 
        protected override void Visit(EnumMember enumMember)
        { 
            Debug.Fail("We don't allow enumMembers publicly"); 
        }
 
        protected override void Visit(CollectionType collectionType)
        {
            int index;
            if (!this.AddObjectToSeenListAndHashBuilder(collectionType, out index)) 
            {
                return; 
            } 

            this.AddObjectStartDumpToHashBuilder(collectionType, index); 

            #region Inner data visit
            this.AddObjectContentToHashBuilder(collectionType.Identity);
            // Identity contains Name, NamespaceName and FullName 

            base.Visit(collectionType); 
 
            #endregion
 
            this.AddObjectEndDumpToHashBuilder();
        }

        protected override void Visit(RefType refType) 
        {
            int index; 
            if (!this.AddObjectToSeenListAndHashBuilder(refType, out index)) 
            {
                return; 
            }

            this.AddObjectStartDumpToHashBuilder(refType, index);
 
            #region Inner data visit
            this.AddObjectContentToHashBuilder(refType.Identity); 
            // Identity contains Name, NamespaceName and FullName 

            base.Visit(refType); 

            #endregion

            this.AddObjectEndDumpToHashBuilder(); 
        }
 
        protected override void Visit(EntityTypeBase entityTypeBase) 
        {
            base.Visit(entityTypeBase); 
        }

        protected override void Visit(Facet facet)
        { 
            int index;
            if (facet.Name != DbProviderManifest.NullableFacetName) 
            { 
                // skip all the non interesting facets
                return; 
            }

            if (!this.AddObjectToSeenListAndHashBuilder(facet, out index))
            { 
                return;
            } 
 
            this.AddObjectStartDumpToHashBuilder(facet, index);
 
            #region Inner data visit
            this.AddObjectContentToHashBuilder(facet.Identity);
            // Identity already contains Name
            this.AddObjectContentToHashBuilder(facet.Value); 

            base.Visit(facet); 
 
            #endregion
 
            this.AddObjectEndDumpToHashBuilder();
        }

        protected override void Visit(EdmFunction edmFunction) 
        {
            // View Generation doesn't deal with functions 
            // so just return; 
        }
 
        protected override void Visit(ComplexType complexType)
        {
            int index;
            if (!this.AddObjectToSeenListAndHashBuilder(complexType, out index)) 
            {
                return; 
            } 

            this.AddObjectStartDumpToHashBuilder(complexType, index); 

            #region Inner data visit
            this.AddObjectContentToHashBuilder(complexType.Abstract);
            this.AddObjectContentToHashBuilder(complexType.Identity); 
            // Identity covers, FullName, Name, and NamespaceName
 
            base.Visit(complexType); 

            #endregion 

            this.AddObjectEndDumpToHashBuilder();
        }
 
        protected override void Visit(PrimitiveType primitiveType)
        { 
            int index; 
            if (!this.AddObjectToSeenListAndHashBuilder(primitiveType, out index))
            { 
                return;
            }

            this.AddObjectStartDumpToHashBuilder(primitiveType, index); 

            #region Inner data visit 
            this.AddObjectContentToHashBuilder(primitiveType.Name); 
            this.AddObjectContentToHashBuilder(primitiveType.NamespaceName);
 
            base.Visit(primitiveType);

            #endregion
 
            this.AddObjectEndDumpToHashBuilder();
        } 
 
        protected override void Visit(FunctionParameter functionParameter)
        { 
            int index;
            if (!this.AddObjectToSeenListAndHashBuilder(functionParameter, out index))
            {
                return; 
            }
 
            this.AddObjectStartDumpToHashBuilder(functionParameter, index); 

            #region Inner data visit 
            this.AddObjectContentToHashBuilder(functionParameter.Identity);
            // Identity already has Name
            this.AddObjectContentToHashBuilder(functionParameter.Mode);
 
            base.Visit(functionParameter);
 
            #endregion 

            this.AddObjectEndDumpToHashBuilder(); 
        }

        protected override void Visit(DbProviderManifest providerManifest)
        { 
            // the provider manifest will be checked by all the other types lining up.
            // no need to store more info. 
        } 
        #endregion
 
        #region hasher helper method

        internal string HashValue
        { 
            get
            { 
                return m_hashSourceBuilder.ComputeHash(); 
            }
        } 

        private void Clean()
        {
            this.m_hashSourceBuilder = new CompressingHashBuilder(); 
            this.m_instanceNumber = 0;
            this.m_itemsAlreadySeen = new Dictionary(); 
        } 

        ///  
        /// if already seen, then out the object instance index, return false;
        /// if haven't seen, then add it to the m_itemAlreadySeen, out the current index, return true
        /// 
        ///  
        /// 
        ///  
        private bool TryAddSeenItem(Object o, out int indexSeen) 
        {
            if (!this.m_itemsAlreadySeen.TryGetValue(o, out indexSeen)) 
            {
                this.m_itemsAlreadySeen.Add(o, this.m_instanceNumber);

                indexSeen = this.m_instanceNumber; 
                this.m_instanceNumber++;
 
                return true; 
            }
            return false; 
        }

        /// 
        /// if the object has seen, then add the seen object style to the hash source, return false; 
        /// if not, then add it to the seen list, and append the object start dump to the hash source, return true
        ///  
        ///  
        /// 
        private bool AddObjectToSeenListAndHashBuilder(object o, out int instanceIndex) 
        {
            if (o == null)
            {
                instanceIndex = -1; 
                return false;
            } 
            if (!TryAddSeenItem(o, out instanceIndex)) 
            {
                this.AddObjectStartDumpToHashBuilder(o, instanceIndex); 
                this.AddSeenObjectToHashBuilder(o, instanceIndex);
                this.AddObjectEndDumpToHashBuilder();
                return false;
            } 
            return true;
        } 
 
        private void AddSeenObjectToHashBuilder(object o, int instanceIndex)
        { 
            Debug.Assert(instanceIndex >= 0, "referencing index should not be less than 0");
            this.m_hashSourceBuilder.AppendLine("Instance Reference: " + instanceIndex);
        }
 
        private void AddObjectStartDumpToHashBuilder(object o, int objectIndex)
        { 
            this.m_hashSourceBuilder.AppendObjectStartDump(o, objectIndex); 
        }
 
        private void AddObjectEndDumpToHashBuilder()
        {
            this.m_hashSourceBuilder.AppendObjectEndDump();
        } 

        private void AddObjectContentToHashBuilder(object content) 
        { 
            if (content != null)
            { 
                this.m_hashSourceBuilder.AppendLine(content.ToString());
            }
            else
            { 
                this.m_hashSourceBuilder.AppendLine("NULL");
            } 
        } 

        internal static string GetMappingClosureHash(StorageEntityContainerMapping storageEntityContainerMapping, ItemCollection itemCollection) 
        {
            Debug.Assert(storageEntityContainerMapping != null, "storageEntityContainerMapping is null!");

            MetadataMappingHasherVisitor visitor = new MetadataMappingHasherVisitor(itemCollection); 
            visitor.Visit(storageEntityContainerMapping);
            return visitor.HashValue; 
        } 
        #endregion
 
    }
}

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
//---------------------------------------------------------------------- 
// 
//      Copyright (c) Microsoft Corporation.  All rights reserved.
// 
 
// @owner       [....]
// @backupOwner [....] 
//--------------------------------------------------------------------- 

using System; 
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Data.Metadata.Edm; 
using System.Data.Common;
using System.Data.Common.Utils; 
using System.Data.Mapping; 
using System.Diagnostics;
 

namespace System.Data.Mapping
{
    internal partial class MetadataMappingHasherVisitor : BaseMetadataMappingVisitor 
    {
        private CompressingHashBuilder m_hashSourceBuilder = new CompressingHashBuilder(); 
        private Dictionary m_itemsAlreadySeen = new Dictionary(); 
        private int m_instanceNumber = 0;
        private ItemCollection m_itemCollection; 

        private MetadataMappingHasherVisitor(ItemCollection edmItemCollection)
        {
            Debug.Assert(edmItemCollection != null, "itemCollection is null!"); 
            this.m_itemCollection = edmItemCollection;
        } 
 
        #region visitor method
        protected override void Visit(StorageEntityContainerMapping storageEntityContainerMapping) 
        {
            int index;
            if (!this.AddObjectToSeenListAndHashBuilder(storageEntityContainerMapping, out index))
            { 
                // if this has been add to the seen list, then just
                return; 
            } 
            if (this.m_itemsAlreadySeen.Count > 1)
            { 

                // this means user try another visit over SECM, this is allowed but all the previous visit all lost due to clean
                // user can visit different SECM objects by using the same visitor to load the SECM object
                this.Clean(); 
                Visit(storageEntityContainerMapping);
                return; 
            } 

            this.AddObjectStartDumpToHashBuilder(storageEntityContainerMapping, index); 

            #region Inner data visit

            this.AddObjectContentToHashBuilder(storageEntityContainerMapping.Identity); 

            base.Visit(storageEntityContainerMapping); 
 
            #endregion
 
            this.AddObjectEndDumpToHashBuilder();
        }

        protected override void Visit(EntityContainer entityContainer) 
        {
            int index; 
            if (!this.AddObjectToSeenListAndHashBuilder(entityContainer, out index)) 
            {
                return; 
            }

            this.AddObjectStartDumpToHashBuilder(entityContainer, index);
 
            #region Inner data visit
 
            this.AddObjectContentToHashBuilder(entityContainer.Identity); 
            // Name is covered by Identity
 
            base.Visit(entityContainer);

            #endregion
 
            this.AddObjectEndDumpToHashBuilder();
        } 
 
        protected override void Visit(StorageSetMapping storageSetMapping)
        { 
            int index;
            if (!this.AddObjectToSeenListAndHashBuilder(storageSetMapping, out index))
            {
                return; 
            }
 
            this.AddObjectStartDumpToHashBuilder(storageSetMapping, index); 

            #region Inner data visit 
            base.Visit(storageSetMapping);
            #endregion

            this.AddObjectEndDumpToHashBuilder(); 
        }
 
        protected override void Visit(StorageTypeMapping storageTypeMapping) 
        {
            int index; 
            if (!this.AddObjectToSeenListAndHashBuilder(storageTypeMapping, out index))
            {
                return;
            } 

            this.AddObjectStartDumpToHashBuilder(storageTypeMapping, index); 
 
            #region Inner data visit
 
            base.Visit(storageTypeMapping);

            #endregion
 
            this.AddObjectEndDumpToHashBuilder();
        } 
 
        protected override void Visit(StorageMappingFragment storageMappingFragment)
        { 
            int index;
            if (!this.AddObjectToSeenListAndHashBuilder(storageMappingFragment, out index))
            {
                return; 
            }
 
            this.AddObjectStartDumpToHashBuilder(storageMappingFragment, index); 

            #region Inner data visit 

            base.Visit(storageMappingFragment);

            #endregion 

            this.AddObjectEndDumpToHashBuilder(); 
        } 

        protected override void Visit(StoragePropertyMapping storagePropertyMapping) 
        {
            base.Visit(storagePropertyMapping);
        }
 
        protected override void Visit(StorageComplexPropertyMapping storageComplexPropertyMapping)
        { 
            int index; 
            if (!this.AddObjectToSeenListAndHashBuilder(storageComplexPropertyMapping, out index))
            { 
                return;
            }

            this.AddObjectStartDumpToHashBuilder(storageComplexPropertyMapping, index); 

            #region Inner data visit 
 
            base.Visit(storageComplexPropertyMapping);
 
            #endregion

            this.AddObjectEndDumpToHashBuilder();
        } 
        protected override void Visit(StorageComplexTypeMapping storageComplexTypeMapping)
        { 
            int index; 
            if (!this.AddObjectToSeenListAndHashBuilder(storageComplexTypeMapping, out index))
            { 
                return;
            }

            this.AddObjectStartDumpToHashBuilder(storageComplexTypeMapping, index); 

            #region Inner data visit 
 
            base.Visit(storageComplexTypeMapping);
 
            #endregion

            this.AddObjectEndDumpToHashBuilder();
        } 

        protected override void Visit(StorageConditionPropertyMapping storageConditionPropertyMapping) 
        { 
            int index;
            if (!this.AddObjectToSeenListAndHashBuilder(storageConditionPropertyMapping, out index)) 
            {
                return;
            }
 
            this.AddObjectStartDumpToHashBuilder(storageConditionPropertyMapping, index);
 
            #region Inner data visit 
            this.AddObjectContentToHashBuilder(storageConditionPropertyMapping.IsNull);
            this.AddObjectContentToHashBuilder(storageConditionPropertyMapping.Value); 

            base.Visit(storageConditionPropertyMapping);

            #endregion 

            this.AddObjectEndDumpToHashBuilder(); 
        } 

        protected override void Visit(StorageScalarPropertyMapping storageScalarPropertyMapping) 
        {
            int index;
            if (!this.AddObjectToSeenListAndHashBuilder(storageScalarPropertyMapping, out index))
            { 
                return;
            } 
 
            this.AddObjectStartDumpToHashBuilder(storageScalarPropertyMapping, index);
 
            #region Inner data visit

            base.Visit(storageScalarPropertyMapping);
 
            #endregion
 
            this.AddObjectEndDumpToHashBuilder(); 
        }
 
        protected override void Visit(EntitySetBase entitySetBase)
        {
            base.Visit(entitySetBase);
        } 

        protected override void Visit(EntitySet entitySet) 
        { 
            int index;
            if (!this.AddObjectToSeenListAndHashBuilder(entitySet, out index)) 
            {
                return;
            }
            #region Inner data visit 

            this.AddObjectStartDumpToHashBuilder(entitySet, index); 
            this.AddObjectContentToHashBuilder(entitySet.Name); 
            this.AddObjectContentToHashBuilder(entitySet.Schema);
            this.AddObjectContentToHashBuilder(entitySet.Table); 

            base.Visit(entitySet);

            foreach (var entityType in MetadataHelper.GetTypeAndSubtypesOf(entitySet.ElementType, this.m_itemCollection, false).Where(type => type != entitySet.ElementType)) 
            {
                this.Visit(entityType); 
            } 

            #endregion 

            this.AddObjectEndDumpToHashBuilder();
        }
 
        protected override void Visit(AssociationSet associationSet)
        { 
            int index; 
            if (!this.AddObjectToSeenListAndHashBuilder(associationSet, out index))
            { 
                return;
            }

            this.AddObjectStartDumpToHashBuilder(associationSet, index); 

            #region Inner data visit 
            this.AddObjectContentToHashBuilder(associationSet.CachedProviderSql); 
            // Name is coverd by Identity
            this.AddObjectContentToHashBuilder(associationSet.Identity); 
            this.AddObjectContentToHashBuilder(associationSet.Schema);
            this.AddObjectContentToHashBuilder(associationSet.Table);

            base.Visit(associationSet); 

            #endregion 
 
            this.AddObjectEndDumpToHashBuilder();
        } 

        protected override void Visit(EntityType entityType)
        {
            int index; 
            if (!this.AddObjectToSeenListAndHashBuilder(entityType, out index))
            { 
                return; 
            }
 
            this.AddObjectStartDumpToHashBuilder(entityType, index);

            #region Inner data visit
            this.AddObjectContentToHashBuilder(entityType.Abstract); 
            this.AddObjectContentToHashBuilder(entityType.Identity);
            // FullName, Namespace and Name are all covered by Identity 
 
            base.Visit(entityType);
 
            #endregion

            this.AddObjectEndDumpToHashBuilder();
        } 

        protected override void Visit(AssociationSetEnd associationSetEnd) 
        { 
            int index;
            if (!this.AddObjectToSeenListAndHashBuilder(associationSetEnd, out index)) 
            {
                return;
            }
 
            this.AddObjectStartDumpToHashBuilder(associationSetEnd, index);
 
            #region Inner data visit 
            this.AddObjectContentToHashBuilder(associationSetEnd.Identity);
            // Name is covered by Identity 

            base.Visit(associationSetEnd);

            #endregion 

            this.AddObjectEndDumpToHashBuilder(); 
        } 

        protected override void Visit(AssociationType associationType) 
        {
            int index;
            if (!this.AddObjectToSeenListAndHashBuilder(associationType, out index))
            { 
                return;
            } 
 
            this.AddObjectStartDumpToHashBuilder(associationType, index);
 
            #region Inner data visit
            this.AddObjectContentToHashBuilder(associationType.Abstract);
            this.AddObjectContentToHashBuilder(associationType.Identity);
            // FullName, Namespace, and Name are all covered by Identity 

            base.Visit(associationType); 
 
            #endregion
 
            this.AddObjectEndDumpToHashBuilder();
        }

        protected override void Visit(EdmProperty edmProperty) 
        {
            int index; 
            if (!this.AddObjectToSeenListAndHashBuilder(edmProperty, out index)) 
            {
                return; 
            }

            this.AddObjectStartDumpToHashBuilder(edmProperty, index);
 
            #region Inner data visit
            // since the delaring type is fixed and referenced to the upper type, 
            // there is no need to hash this 
            //this.AddObjectContentToHashBuilder(edmProperty.DeclaringType);
            this.AddObjectContentToHashBuilder(edmProperty.DefaultValue); 
            this.AddObjectContentToHashBuilder(edmProperty.Identity);
            // Name is covered by Identity
            this.AddObjectContentToHashBuilder(edmProperty.IsStoreGeneratedComputed);
            this.AddObjectContentToHashBuilder(edmProperty.IsStoreGeneratedIdentity); 
            this.AddObjectContentToHashBuilder(edmProperty.Nullable);
 
            base.Visit(edmProperty); 

            #endregion 

            this.AddObjectEndDumpToHashBuilder();
        }
 
        protected override void Visit(NavigationProperty navigationProperty)
        { 
            // navigation properties are not considered in view generation 
            return;
        } 

        protected override void Visit(EdmMember edmMember)
        {
            int index; 
            if (!this.AddObjectToSeenListAndHashBuilder(edmMember, out index))
            { 
                return; 
            }
 
            this.AddObjectStartDumpToHashBuilder(edmMember, index);

            #region Inner data visit
            this.AddObjectContentToHashBuilder(edmMember.Identity); 
            // Name is covered by Identity
            this.AddObjectContentToHashBuilder(edmMember.IsStoreGeneratedComputed); 
            this.AddObjectContentToHashBuilder(edmMember.IsStoreGeneratedIdentity); 

            base.Visit(edmMember); 

            #endregion

            this.AddObjectEndDumpToHashBuilder(); 
        }
 
        protected override void Visit(AssociationEndMember associationEndMember) 
        {
            int index; 
            if (!this.AddObjectToSeenListAndHashBuilder(associationEndMember, out index))
            {
                return;
            } 

            this.AddObjectStartDumpToHashBuilder(associationEndMember, index); 
 
            #region Inner data visit
            this.AddObjectContentToHashBuilder(associationEndMember.DeleteBehavior); 
            this.AddObjectContentToHashBuilder(associationEndMember.Identity);
            // Name is covered by Identity
            this.AddObjectContentToHashBuilder(associationEndMember.IsStoreGeneratedComputed);
            this.AddObjectContentToHashBuilder(associationEndMember.IsStoreGeneratedIdentity); 
            this.AddObjectContentToHashBuilder(associationEndMember.RelationshipMultiplicity);
 
            base.Visit(associationEndMember); 

            #endregion 

            this.AddObjectEndDumpToHashBuilder();
        }
 
        protected override void Visit(ReferentialConstraint referentialConstraint)
        { 
            int index; 
            if (!this.AddObjectToSeenListAndHashBuilder(referentialConstraint, out index))
            { 
                return;
            }

            this.AddObjectStartDumpToHashBuilder(referentialConstraint, index); 

            #region Inner data visit 
            this.AddObjectContentToHashBuilder(referentialConstraint.Identity); 

            base.Visit(referentialConstraint); 

            #endregion

            this.AddObjectEndDumpToHashBuilder(); 
        }
 
        protected override void Visit(RelationshipEndMember relationshipEndMember) 
        {
            int index; 
            if (!this.AddObjectToSeenListAndHashBuilder(relationshipEndMember, out index))
            {
                return;
            } 

            this.AddObjectStartDumpToHashBuilder(relationshipEndMember, index); 
 
            #region Inner data visit
            this.AddObjectContentToHashBuilder(relationshipEndMember.DeleteBehavior); 
            this.AddObjectContentToHashBuilder(relationshipEndMember.Identity);
            // Name is covered by Identity
            this.AddObjectContentToHashBuilder(relationshipEndMember.IsStoreGeneratedComputed);
            this.AddObjectContentToHashBuilder(relationshipEndMember.IsStoreGeneratedIdentity); 
            this.AddObjectContentToHashBuilder(relationshipEndMember.RelationshipMultiplicity);
 
            base.Visit(relationshipEndMember); 

            #endregion 

            this.AddObjectEndDumpToHashBuilder();
        }
 
        protected override void Visit(TypeUsage typeUsage)
        { 
            int index; 
            if (!this.AddObjectToSeenListAndHashBuilder(typeUsage, out index))
            { 
                return;
            }

            this.AddObjectStartDumpToHashBuilder(typeUsage, index); 

            #region Inner data visit 
            //No need to add identity of TypeUsage to the hash since it would take into account 
            //facets that viewgen would not care and we visit the important facets anyway.
 
            base.Visit(typeUsage);

            #endregion
 
            this.AddObjectEndDumpToHashBuilder();
        } 
 
        protected override void Visit(RelationshipType relationshipType)
        { 
            base.Visit(relationshipType);
        }

        protected override void Visit(EdmType edmType) 
        {
            base.Visit(edmType); 
        } 

        protected override void Visit(EnumType enumType) 
        {
            Debug.Fail("We don't allow enumTypes publicly");
        }
 
        protected override void Visit(EnumMember enumMember)
        { 
            Debug.Fail("We don't allow enumMembers publicly"); 
        }
 
        protected override void Visit(CollectionType collectionType)
        {
            int index;
            if (!this.AddObjectToSeenListAndHashBuilder(collectionType, out index)) 
            {
                return; 
            } 

            this.AddObjectStartDumpToHashBuilder(collectionType, index); 

            #region Inner data visit
            this.AddObjectContentToHashBuilder(collectionType.Identity);
            // Identity contains Name, NamespaceName and FullName 

            base.Visit(collectionType); 
 
            #endregion
 
            this.AddObjectEndDumpToHashBuilder();
        }

        protected override void Visit(RefType refType) 
        {
            int index; 
            if (!this.AddObjectToSeenListAndHashBuilder(refType, out index)) 
            {
                return; 
            }

            this.AddObjectStartDumpToHashBuilder(refType, index);
 
            #region Inner data visit
            this.AddObjectContentToHashBuilder(refType.Identity); 
            // Identity contains Name, NamespaceName and FullName 

            base.Visit(refType); 

            #endregion

            this.AddObjectEndDumpToHashBuilder(); 
        }
 
        protected override void Visit(EntityTypeBase entityTypeBase) 
        {
            base.Visit(entityTypeBase); 
        }

        protected override void Visit(Facet facet)
        { 
            int index;
            if (facet.Name != DbProviderManifest.NullableFacetName) 
            { 
                // skip all the non interesting facets
                return; 
            }

            if (!this.AddObjectToSeenListAndHashBuilder(facet, out index))
            { 
                return;
            } 
 
            this.AddObjectStartDumpToHashBuilder(facet, index);
 
            #region Inner data visit
            this.AddObjectContentToHashBuilder(facet.Identity);
            // Identity already contains Name
            this.AddObjectContentToHashBuilder(facet.Value); 

            base.Visit(facet); 
 
            #endregion
 
            this.AddObjectEndDumpToHashBuilder();
        }

        protected override void Visit(EdmFunction edmFunction) 
        {
            // View Generation doesn't deal with functions 
            // so just return; 
        }
 
        protected override void Visit(ComplexType complexType)
        {
            int index;
            if (!this.AddObjectToSeenListAndHashBuilder(complexType, out index)) 
            {
                return; 
            } 

            this.AddObjectStartDumpToHashBuilder(complexType, index); 

            #region Inner data visit
            this.AddObjectContentToHashBuilder(complexType.Abstract);
            this.AddObjectContentToHashBuilder(complexType.Identity); 
            // Identity covers, FullName, Name, and NamespaceName
 
            base.Visit(complexType); 

            #endregion 

            this.AddObjectEndDumpToHashBuilder();
        }
 
        protected override void Visit(PrimitiveType primitiveType)
        { 
            int index; 
            if (!this.AddObjectToSeenListAndHashBuilder(primitiveType, out index))
            { 
                return;
            }

            this.AddObjectStartDumpToHashBuilder(primitiveType, index); 

            #region Inner data visit 
            this.AddObjectContentToHashBuilder(primitiveType.Name); 
            this.AddObjectContentToHashBuilder(primitiveType.NamespaceName);
 
            base.Visit(primitiveType);

            #endregion
 
            this.AddObjectEndDumpToHashBuilder();
        } 
 
        protected override void Visit(FunctionParameter functionParameter)
        { 
            int index;
            if (!this.AddObjectToSeenListAndHashBuilder(functionParameter, out index))
            {
                return; 
            }
 
            this.AddObjectStartDumpToHashBuilder(functionParameter, index); 

            #region Inner data visit 
            this.AddObjectContentToHashBuilder(functionParameter.Identity);
            // Identity already has Name
            this.AddObjectContentToHashBuilder(functionParameter.Mode);
 
            base.Visit(functionParameter);
 
            #endregion 

            this.AddObjectEndDumpToHashBuilder(); 
        }

        protected override void Visit(DbProviderManifest providerManifest)
        { 
            // the provider manifest will be checked by all the other types lining up.
            // no need to store more info. 
        } 
        #endregion
 
        #region hasher helper method

        internal string HashValue
        { 
            get
            { 
                return m_hashSourceBuilder.ComputeHash(); 
            }
        } 

        private void Clean()
        {
            this.m_hashSourceBuilder = new CompressingHashBuilder(); 
            this.m_instanceNumber = 0;
            this.m_itemsAlreadySeen = new Dictionary(); 
        } 

        ///  
        /// if already seen, then out the object instance index, return false;
        /// if haven't seen, then add it to the m_itemAlreadySeen, out the current index, return true
        /// 
        ///  
        /// 
        ///  
        private bool TryAddSeenItem(Object o, out int indexSeen) 
        {
            if (!this.m_itemsAlreadySeen.TryGetValue(o, out indexSeen)) 
            {
                this.m_itemsAlreadySeen.Add(o, this.m_instanceNumber);

                indexSeen = this.m_instanceNumber; 
                this.m_instanceNumber++;
 
                return true; 
            }
            return false; 
        }

        /// 
        /// if the object has seen, then add the seen object style to the hash source, return false; 
        /// if not, then add it to the seen list, and append the object start dump to the hash source, return true
        ///  
        ///  
        /// 
        private bool AddObjectToSeenListAndHashBuilder(object o, out int instanceIndex) 
        {
            if (o == null)
            {
                instanceIndex = -1; 
                return false;
            } 
            if (!TryAddSeenItem(o, out instanceIndex)) 
            {
                this.AddObjectStartDumpToHashBuilder(o, instanceIndex); 
                this.AddSeenObjectToHashBuilder(o, instanceIndex);
                this.AddObjectEndDumpToHashBuilder();
                return false;
            } 
            return true;
        } 
 
        private void AddSeenObjectToHashBuilder(object o, int instanceIndex)
        { 
            Debug.Assert(instanceIndex >= 0, "referencing index should not be less than 0");
            this.m_hashSourceBuilder.AppendLine("Instance Reference: " + instanceIndex);
        }
 
        private void AddObjectStartDumpToHashBuilder(object o, int objectIndex)
        { 
            this.m_hashSourceBuilder.AppendObjectStartDump(o, objectIndex); 
        }
 
        private void AddObjectEndDumpToHashBuilder()
        {
            this.m_hashSourceBuilder.AppendObjectEndDump();
        } 

        private void AddObjectContentToHashBuilder(object content) 
        { 
            if (content != null)
            { 
                this.m_hashSourceBuilder.AppendLine(content.ToString());
            }
            else
            { 
                this.m_hashSourceBuilder.AppendLine("NULL");
            } 
        } 

        internal static string GetMappingClosureHash(StorageEntityContainerMapping storageEntityContainerMapping, ItemCollection itemCollection) 
        {
            Debug.Assert(storageEntityContainerMapping != null, "storageEntityContainerMapping is null!");

            MetadataMappingHasherVisitor visitor = new MetadataMappingHasherVisitor(itemCollection); 
            visitor.Visit(storageEntityContainerMapping);
            return visitor.HashValue; 
        } 
        #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