columnmapkeybuilder.cs source code in C# .NET

                        
Code:
                         / 4.0 / 4.0 / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / fx / src / DataEntity / System / Data / Common / internal / materialization / columnmapkeybuilder.cs / 1305376 / columnmapkeybuilder.cs
                        

                        
                            //------------------------------------------------------------------------------ 
// 
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// 
// [....] 
// [....]
//----------------------------------------------------------------------------- 
 
using System.Collections.Generic;
using System.Data.Metadata.Edm; 
using System.Data.Objects.ELinq;
using System.Data.Objects.Internal;
using System.Data.Query.InternalTrees;
using System.Diagnostics; 
using System.Globalization;
using System.Linq; 
using System.Text; 

namespace System.Data.Common.Internal.Materialization 
{
    /// 

    /// Supports building a unique key for a column map so that compiled delegates ()
    /// can be cached. The general rule: if the  cares about some property of 
    /// the column map, the generated key must include that property value.
    /// 
 
    ///  
    /// IMPORTANT:
    /// The "X-" prefixes introduced in the different column map types should be unique. This avoids 
    /// conflicts for different column maps with similar properties (e.g. ComplexType and EntityType)
    /// 
    internal class ColumnMapKeyBuilder : ColumnMapVisitor
    { 
        #region private state
 
        private readonly StringBuilder _builder = new StringBuilder(); 
        private readonly SpanIndex _spanIndex;
 
        #endregion

        #region constructor
 
        private ColumnMapKeyBuilder(SpanIndex spanIndex)
        { 
            _spanIndex = spanIndex; 
        }
 
        #endregion

        #region "public" surface area
 
        /// 

        /// Returns a string uniquely identifying the given ColumnMap. 
        /// 
 
        internal static string GetColumnMapKey(ColumnMap columnMap, SpanIndex spanIndex)
        { 
            ColumnMapKeyBuilder builder = new ColumnMapKeyBuilder(spanIndex);
            columnMap.Accept(builder, 0);
            return builder._builder.ToString();
        } 

        internal void Append(string value) 
        { 
            _builder.Append(value);
        } 

        internal void Append(string prefix, Type type)
        {
            Append(prefix, type.AssemblyQualifiedName); 
        }
 
        internal void Append(string prefix, TypeUsage type) 
        {
            if (null != type) 
            {
                // LINQ has anonymous types that aren't going to show up in our
                // metadata workspace, and we don't want to hydrate a record when
                // we need an anonymous type.  LINQ solves this by annotating the 
                // edmType with some additional information, which we'll pick up
                // here. 
                InitializerMetadata initializer; 
                if (InitializerMetadata.TryGetInitializerMetadata(type, out initializer))
                { 
                    initializer.AppendColumnMapKey(this);
                }
                Append(prefix, type.EdmType);
            } 
        }
 
        internal void Append(string prefix, EdmType type) 
        {
            if (null != type) 
            {
                Append(prefix, type.NamespaceName);
                Append(".", type.Name);
 
                if (type.BuiltInTypeKind == BuiltInTypeKind.RowType)
                { 
                    if (_spanIndex != null) 
                    {
                        Append("<<"); 
                        Dictionary spanMap = _spanIndex.GetSpanMap((RowType)type);
                        if (null != spanMap)
                        {
                            string separator = string.Empty; 
                            foreach (var pair in spanMap)
                            { 
                                Append(separator); 
                                AppendValue("C", pair.Key);
                                Append(":", pair.Value.DeclaringType); 
                                Append(".", pair.Value.Name);
                                separator = ",";
                            }
                        } 
                        Append(">>");
                    } 
                } 
            }
        } 

        #endregion

        #region helper methods 

        private void Append(string prefix, string value) 
        { 
            Append(prefix);
            Append("'"); 
            Append(value);
            Append("'");
        }
 
        private void Append(string prefix, ColumnMap columnMap)
        { 
            Append(prefix); 
            Append("[");
            if (null != columnMap) 
            {
                columnMap.Accept(this, 0);
            }
            Append("]"); 
        }
 
        private void Append(string prefix, IEnumerable elements) 
        {
            Append(prefix); 
            Append("{");
            if (null != elements)
            {
                string separator = string.Empty; 
                foreach (ColumnMap element in elements)
                { 
                    Append(separator, element); 
                    separator = ",";
                } 
            }
            Append("}");
        }
 
        private void Append(string prefix, EntityIdentity entityIdentity)
        { 
            Append(prefix); 
            Append("[");
 
            Append(",K", entityIdentity.Keys);

            SimpleEntityIdentity simple = entityIdentity as SimpleEntityIdentity;
            if (null != simple) 
            {
                Append(",", simple.EntitySet); 
            } 
            else
            { 
                DiscriminatedEntityIdentity discriminated = (DiscriminatedEntityIdentity)entityIdentity;
                Append("CM", discriminated.EntitySetColumnMap);
                foreach (EntitySet entitySet in discriminated.EntitySetMap)
                { 
                    Append(",E", entitySet);
                } 
            } 

            Append("]"); 
        }

        private void Append(string prefix, EntitySet entitySet)
        { 
            if (null != entitySet)
            { 
                Append(prefix, entitySet.EntityContainer.Name); 
                Append(".", entitySet.Name);
            } 
        }

        private void AppendValue(string prefix, object value)
        { 
            Append(prefix, String.Format(CultureInfo.InvariantCulture, "{0}", value));
        } 
 
        #endregion
 
        #region visitor methods

        internal override void Visit(ComplexTypeColumnMap columnMap, int dummy)
        { 
            Append("C-", columnMap.Type);
            Append(",N", columnMap.NullSentinel); 
            Append(",P", columnMap.Properties); 
        }
 
        internal override void Visit(DiscriminatedCollectionColumnMap columnMap, int dummy)
        {
            Append("DC-D", columnMap.Discriminator);
            AppendValue(",DV", columnMap.DiscriminatorValue); 
            Append(",FK", columnMap.ForeignKeys);
            Append(",K", columnMap.Keys); 
            Append(",E", columnMap.Element); 
        }
 
        internal override void Visit(EntityColumnMap columnMap, int dummy)
        {
            Append("E-", columnMap.Type);
            Append(",N", columnMap.NullSentinel); 
            Append(",P", columnMap.Properties);
            Append(",I", columnMap.EntityIdentity); 
        } 

        internal override void Visit(SimplePolymorphicColumnMap columnMap, int dummy) 
        {
            Append("SP-", columnMap.Type);
            Append(",D", columnMap.TypeDiscriminator);
            Append(",N", columnMap.NullSentinel); 
            Append(",P", columnMap.Properties);
            foreach (var typeChoice in columnMap.TypeChoices) 
            { 
                AppendValue(",K", typeChoice.Key);
                Append(":", typeChoice.Value); 
            }
        }

        internal override void Visit(RecordColumnMap columnMap, int dummy) 
        {
            Append("R-", columnMap.Type); 
            Append(",N", columnMap.NullSentinel); 
            Append(",P", columnMap.Properties);
        } 

        internal override void Visit(RefColumnMap columnMap, int dummy)
        {
            Append("Ref-", columnMap.EntityIdentity); 
        }
 
        internal override void Visit(ScalarColumnMap columnMap, int dummy) 
        {
            String description = String.Format(CultureInfo.InvariantCulture, 
                                            "S({0}-{1}:{2})", columnMap.CommandId, columnMap.ColumnPos, columnMap.Type.Identity);
            Append(description);
        }
 
        internal override void Visit(SimpleCollectionColumnMap columnMap, int dummy)
        { 
            Append("DC-FK", columnMap.ForeignKeys); 
            Append(",K", columnMap.Keys);
            Append(",E", columnMap.Element); 
        }

        internal override void Visit(VarRefColumnMap columnMap, int dummy)
        { 
            Debug.Fail("must not encounter VarRef in ColumnMap for key (eliminated in final ColumnMap)");
        } 
 
        internal override void Visit(MultipleDiscriminatorPolymorphicColumnMap columnMap, int dummy)
        { 
            // MultipleDiscriminator maps contain an opaque discriminator delegate, so recompilation
            // is always required. Generate a unique key for the discriminator.
            //
            Append(String.Format(CultureInfo.InvariantCulture, "MD-{0}", Guid.NewGuid())); 
        }
 
        #endregion 
    }
} 

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
//------------------------------------------------------------------------------ 
// 
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// 
// [....] 
// [....]
//----------------------------------------------------------------------------- 
 
using System.Collections.Generic;
using System.Data.Metadata.Edm; 
using System.Data.Objects.ELinq;
using System.Data.Objects.Internal;
using System.Data.Query.InternalTrees;
using System.Diagnostics; 
using System.Globalization;
using System.Linq; 
using System.Text; 

namespace System.Data.Common.Internal.Materialization 
{
    /// 

    /// Supports building a unique key for a column map so that compiled delegates ()
    /// can be cached. The general rule: if the  cares about some property of 
    /// the column map, the generated key must include that property value.
    /// 
 
    ///  
    /// IMPORTANT:
    /// The "X-" prefixes introduced in the different column map types should be unique. This avoids 
    /// conflicts for different column maps with similar properties (e.g. ComplexType and EntityType)
    /// 
    internal class ColumnMapKeyBuilder : ColumnMapVisitor
    { 
        #region private state
 
        private readonly StringBuilder _builder = new StringBuilder(); 
        private readonly SpanIndex _spanIndex;
 
        #endregion

        #region constructor
 
        private ColumnMapKeyBuilder(SpanIndex spanIndex)
        { 
            _spanIndex = spanIndex; 
        }
 
        #endregion

        #region "public" surface area
 
        /// 

        /// Returns a string uniquely identifying the given ColumnMap. 
        /// 
 
        internal static string GetColumnMapKey(ColumnMap columnMap, SpanIndex spanIndex)
        { 
            ColumnMapKeyBuilder builder = new ColumnMapKeyBuilder(spanIndex);
            columnMap.Accept(builder, 0);
            return builder._builder.ToString();
        } 

        internal void Append(string value) 
        { 
            _builder.Append(value);
        } 

        internal void Append(string prefix, Type type)
        {
            Append(prefix, type.AssemblyQualifiedName); 
        }
 
        internal void Append(string prefix, TypeUsage type) 
        {
            if (null != type) 
            {
                // LINQ has anonymous types that aren't going to show up in our
                // metadata workspace, and we don't want to hydrate a record when
                // we need an anonymous type.  LINQ solves this by annotating the 
                // edmType with some additional information, which we'll pick up
                // here. 
                InitializerMetadata initializer; 
                if (InitializerMetadata.TryGetInitializerMetadata(type, out initializer))
                { 
                    initializer.AppendColumnMapKey(this);
                }
                Append(prefix, type.EdmType);
            } 
        }
 
        internal void Append(string prefix, EdmType type) 
        {
            if (null != type) 
            {
                Append(prefix, type.NamespaceName);
                Append(".", type.Name);
 
                if (type.BuiltInTypeKind == BuiltInTypeKind.RowType)
                { 
                    if (_spanIndex != null) 
                    {
                        Append("<<"); 
                        Dictionary spanMap = _spanIndex.GetSpanMap((RowType)type);
                        if (null != spanMap)
                        {
                            string separator = string.Empty; 
                            foreach (var pair in spanMap)
                            { 
                                Append(separator); 
                                AppendValue("C", pair.Key);
                                Append(":", pair.Value.DeclaringType); 
                                Append(".", pair.Value.Name);
                                separator = ",";
                            }
                        } 
                        Append(">>");
                    } 
                } 
            }
        } 

        #endregion

        #region helper methods 

        private void Append(string prefix, string value) 
        { 
            Append(prefix);
            Append("'"); 
            Append(value);
            Append("'");
        }
 
        private void Append(string prefix, ColumnMap columnMap)
        { 
            Append(prefix); 
            Append("[");
            if (null != columnMap) 
            {
                columnMap.Accept(this, 0);
            }
            Append("]"); 
        }
 
        private void Append(string prefix, IEnumerable elements) 
        {
            Append(prefix); 
            Append("{");
            if (null != elements)
            {
                string separator = string.Empty; 
                foreach (ColumnMap element in elements)
                { 
                    Append(separator, element); 
                    separator = ",";
                } 
            }
            Append("}");
        }
 
        private void Append(string prefix, EntityIdentity entityIdentity)
        { 
            Append(prefix); 
            Append("[");
 
            Append(",K", entityIdentity.Keys);

            SimpleEntityIdentity simple = entityIdentity as SimpleEntityIdentity;
            if (null != simple) 
            {
                Append(",", simple.EntitySet); 
            } 
            else
            { 
                DiscriminatedEntityIdentity discriminated = (DiscriminatedEntityIdentity)entityIdentity;
                Append("CM", discriminated.EntitySetColumnMap);
                foreach (EntitySet entitySet in discriminated.EntitySetMap)
                { 
                    Append(",E", entitySet);
                } 
            } 

            Append("]"); 
        }

        private void Append(string prefix, EntitySet entitySet)
        { 
            if (null != entitySet)
            { 
                Append(prefix, entitySet.EntityContainer.Name); 
                Append(".", entitySet.Name);
            } 
        }

        private void AppendValue(string prefix, object value)
        { 
            Append(prefix, String.Format(CultureInfo.InvariantCulture, "{0}", value));
        } 
 
        #endregion
 
        #region visitor methods

        internal override void Visit(ComplexTypeColumnMap columnMap, int dummy)
        { 
            Append("C-", columnMap.Type);
            Append(",N", columnMap.NullSentinel); 
            Append(",P", columnMap.Properties); 
        }
 
        internal override void Visit(DiscriminatedCollectionColumnMap columnMap, int dummy)
        {
            Append("DC-D", columnMap.Discriminator);
            AppendValue(",DV", columnMap.DiscriminatorValue); 
            Append(",FK", columnMap.ForeignKeys);
            Append(",K", columnMap.Keys); 
            Append(",E", columnMap.Element); 
        }
 
        internal override void Visit(EntityColumnMap columnMap, int dummy)
        {
            Append("E-", columnMap.Type);
            Append(",N", columnMap.NullSentinel); 
            Append(",P", columnMap.Properties);
            Append(",I", columnMap.EntityIdentity); 
        } 

        internal override void Visit(SimplePolymorphicColumnMap columnMap, int dummy) 
        {
            Append("SP-", columnMap.Type);
            Append(",D", columnMap.TypeDiscriminator);
            Append(",N", columnMap.NullSentinel); 
            Append(",P", columnMap.Properties);
            foreach (var typeChoice in columnMap.TypeChoices) 
            { 
                AppendValue(",K", typeChoice.Key);
                Append(":", typeChoice.Value); 
            }
        }

        internal override void Visit(RecordColumnMap columnMap, int dummy) 
        {
            Append("R-", columnMap.Type); 
            Append(",N", columnMap.NullSentinel); 
            Append(",P", columnMap.Properties);
        } 

        internal override void Visit(RefColumnMap columnMap, int dummy)
        {
            Append("Ref-", columnMap.EntityIdentity); 
        }
 
        internal override void Visit(ScalarColumnMap columnMap, int dummy) 
        {
            String description = String.Format(CultureInfo.InvariantCulture, 
                                            "S({0}-{1}:{2})", columnMap.CommandId, columnMap.ColumnPos, columnMap.Type.Identity);
            Append(description);
        }
 
        internal override void Visit(SimpleCollectionColumnMap columnMap, int dummy)
        { 
            Append("DC-FK", columnMap.ForeignKeys); 
            Append(",K", columnMap.Keys);
            Append(",E", columnMap.Element); 
        }

        internal override void Visit(VarRefColumnMap columnMap, int dummy)
        { 
            Debug.Fail("must not encounter VarRef in ColumnMap for key (eliminated in final ColumnMap)");
        } 
 
        internal override void Visit(MultipleDiscriminatorPolymorphicColumnMap columnMap, int dummy)
        { 
            // MultipleDiscriminator maps contain an opaque discriminator delegate, so recompilation
            // is always required. Generate a unique key for the discriminator.
            //
            Append(String.Format(CultureInfo.InvariantCulture, "MD-{0}", Guid.NewGuid())); 
        }
 
        #endregion 
    }
} 

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

                        

                        
                        

Link Menu

This book is available now!
Buy at Amazon US or
Buy at Amazon UK

• Profiler.cs
• StringFormat.cs
• MimeTypeMapper.cs
• BoundPropertyEntry.cs
• ClientType.cs
• AspProxy.cs
• JsonByteArrayDataContract.cs
• DataColumnMappingCollection.cs
• DataGridView.cs
• SqlDeflator.cs
• BitStream.cs
• SymLanguageVendor.cs
• ExceptionCollection.cs
• SmtpMail.cs
• EndpointConfigContainer.cs
• BypassElementCollection.cs
• SoapIgnoreAttribute.cs
• DoubleCollectionValueSerializer.cs
• SQLInt64Storage.cs
• TrustSection.cs
• ResourceDescriptionAttribute.cs
• QueryResponse.cs
• MergeExecutor.cs
• GeneralTransform3D.cs
• ToolboxItemLoader.cs
• SQLRoleProvider.cs
• ArcSegment.cs
• XmlSchemaAnnotation.cs
• ToolStripTextBox.cs
• ResolveCriteriaApril2005.cs
• ScrollItemPattern.cs
• CodeDirectiveCollection.cs
• DataServices.cs
• CompiledXpathExpr.cs
• dtdvalidator.cs
• HttpFileCollectionBase.cs
• RijndaelCryptoServiceProvider.cs
• HwndStylusInputProvider.cs
• ConstNode.cs
• SqlUdtInfo.cs
• AuthenticatedStream.cs
• MsmqIntegrationBindingElement.cs
• ObjectDataSourceEventArgs.cs
• ClientBuildManager.cs
• XPathAxisIterator.cs
• TCPListener.cs
• InvalidStoreProtectionKeyException.cs
• ListViewItemEventArgs.cs
• _CommandStream.cs
• CertificateManager.cs
• WebServiceData.cs
• WebServicesInteroperability.cs
• DependencyPropertyConverter.cs
• TextFormatterContext.cs
• PackagePartCollection.cs
• DispatchWrapper.cs
• MapPathBasedVirtualPathProvider.cs
• ArithmeticException.cs
• DocComment.cs
• CodeConditionStatement.cs
• ExpandedProjectionNode.cs
• ProfileBuildProvider.cs
• SingleKeyFrameCollection.cs
• ArgumentNullException.cs
• ApplicationFileParser.cs
• ThreadStateException.cs
• FocusWithinProperty.cs
• Rect.cs
• SafeNativeMethods.cs
• RawStylusInputCustomDataList.cs
• CodeComment.cs
• NumberSubstitution.cs
• ExecutionEngineException.cs
• GroupStyle.cs
• FolderLevelBuildProviderCollection.cs
• DataGridViewButtonColumn.cs
• MaterialGroup.cs
• Evaluator.cs
• QueueProcessor.cs
• ComponentCollection.cs
• BaseResourcesBuildProvider.cs
• WSAddressing10ProblemHeaderQNameFault.cs
• DataGridViewBindingCompleteEventArgs.cs
• StubHelpers.cs
• ListView.cs
• ProxyGenerator.cs
• SafeLibraryHandle.cs
• SqlNotificationRequest.cs
• ByteStream.cs
• DesignerTransactionCloseEvent.cs
• GridView.cs
• Setter.cs
• xml.cs
• Query.cs
• LassoSelectionBehavior.cs
• SoapParser.cs
• StringToken.cs
• PageAdapter.cs
• AspNetSynchronizationContext.cs
• QilTernary.cs