Code:
/ 4.0 / 4.0 / untmp / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / fx / src / DataEntity / System / Data / Metadata / StoreItemCollection.cs / 1305376 / StoreItemCollection.cs
//---------------------------------------------------------------------- //// Copyright (c) Microsoft Corporation. All rights reserved. // // // @owner [....] // @backupOwner [....] //--------------------------------------------------------------------- using System.Collections.Generic; using System.Data.Common; using System.Data.Common.Utils; using System.Diagnostics; using System.Xml; using System.Data.Entity; using System.Linq; using System.Runtime.Versioning; namespace System.Data.Metadata.Edm { ////// Class for representing a collection of items in Store space. /// [CLSCompliant(false)] public sealed partial class StoreItemCollection : ItemCollection { #region Fields double _schemaVersion = XmlConstants.UndefinedVersion; // Cache for primitive type maps for Edm to provider private readonly CacheForPrimitiveTypes _primitiveTypeMaps = new CacheForPrimitiveTypes(); private readonly Memoizer_cachedCTypeFunction; private readonly DbProviderManifest _providerManifest; private readonly string _providerManifestToken; private readonly DbProviderFactory _providerFactory; // Storing the query cache manager in the store item collection since all queries are currently bound to the // store. So storing it in StoreItemCollection makes sense. Also, since query cache requires version and other // stuff of the provider, we can assume that the connection is always open and we have the store metadata. // Also we can use the same cache manager both for Entity Client and Object Query, since query cache has // no reference to any metadata in OSpace. Also we assume that ObjectMaterializer loads the assembly // before it tries to do object materialization, since we might not have loaded an assembly in another workspace // where this store item collection is getting reused private readonly System.Data.Common.QueryCache.QueryCacheManager _queryCacheManager = System.Data.Common.QueryCache.QueryCacheManager.Create(); #endregion #region Constructors // used by EntityStoreSchemaGenerator to start with an empty (primitive types only) StoreItemCollection and // add types discovered from the database internal StoreItemCollection(DbProviderFactory factory, DbProviderManifest manifest, string providerManifestToken) : base(DataSpace.SSpace) { Debug.Assert(factory != null, "factory is null"); Debug.Assert(manifest != null, "manifest is null"); _providerFactory = factory; _providerManifest = manifest; _providerManifestToken = providerManifestToken; _cachedCTypeFunction = new Memoizer (ConvertFunctionParameterToCType, null); LoadProviderManifest(_providerManifest, true /*checkForSystemNamespace*/); } /// /// constructor that loads the metadata files from the specified xmlReaders, and returns the list of errors /// encountered during load as the out parameter errors. /// /// Publicly available from System.Data.Entity.Desgin.dll /// /// xmlReaders where the CDM schemas are loaded /// the paths where the files can be found that match the xml readers collection /// An out parameter to return the collection of errors encountered while loading [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")] // referenced by System.Data.Entity.Design.dll internal StoreItemCollection(IEnumerablexmlReaders, System.Collections.ObjectModel.ReadOnlyCollection filePaths, out IList errors) : base(DataSpace.SSpace) { // we will check the parameters for this internal ctor becuase // it is pretty much publicly exposed through the MetadataItemCollectionFactory // in System.Data.Entity.Design EntityUtil.CheckArgumentNull(xmlReaders, "xmlReaders"); EntityUtil.CheckArgumentContainsNull(ref xmlReaders, "xmlReaders"); EntityUtil.CheckArgumentEmpty(ref xmlReaders, Strings.StoreItemCollectionMustHaveOneArtifact, "xmlReader"); // filePaths is allowed to be null errors = this.Init(xmlReaders, filePaths, false, out _providerManifest, out _providerFactory, out _providerManifestToken, out _cachedCTypeFunction); } /// /// constructor that loads the metadata files from the specified xmlReaders, and returns the list of errors /// encountered during load as the out parameter errors. /// /// Publicly available from System.Data.Entity.Desgin.dll /// /// xmlReaders where the CDM schemas are loaded /// the paths where the files can be found that match the xml readers collection internal StoreItemCollection(IEnumerablexmlReaders, IEnumerable filePaths) : base(DataSpace.SSpace) { EntityUtil.CheckArgumentNull(filePaths, "filePaths"); EntityUtil.CheckArgumentEmpty(ref xmlReaders, Strings.StoreItemCollectionMustHaveOneArtifact, "xmlReader"); this.Init(xmlReaders, filePaths, true, out _providerManifest, out _providerFactory, out _providerManifestToken, out _cachedCTypeFunction); } /// /// Public constructor that loads the metadata files from the specified xmlReaders. /// Throws when encounter errors. /// /// xmlReaders where the CDM schemas are loaded public StoreItemCollection(IEnumerablexmlReaders) : base(DataSpace.SSpace) { EntityUtil.CheckArgumentNull(xmlReaders, "xmlReaders"); EntityUtil.CheckArgumentEmpty(ref xmlReaders, Strings.StoreItemCollectionMustHaveOneArtifact, "xmlReader"); MetadataArtifactLoader composite = MetadataArtifactLoader.CreateCompositeFromXmlReaders(xmlReaders); this.Init(composite.GetReaders(), composite.GetPaths(), true, out _providerManifest, out _providerFactory, out _providerManifestToken, out _cachedCTypeFunction); } /// /// Constructs the new instance of StoreItemCollection /// with the list of CDM files provided. /// /// paths where the CDM schemas are loaded ///Thrown if path name is not valid ///thrown if paths argument is null ///For errors related to invalid schemas. [ResourceExposure(ResourceScope.Machine)] //Exposes the file path names which are a Machine resource [ResourceConsumption(ResourceScope.Machine)] //For MetadataArtifactLoader.CreateCompositeFromFilePaths method call but we do not create the file paths in this method public StoreItemCollection(params string[] filePaths) : base(DataSpace.SSpace) { EntityUtil.CheckArgumentNull(filePaths, "filePaths"); IEnumerableenumerableFilePaths = filePaths; EntityUtil.CheckArgumentEmpty(ref enumerableFilePaths, Strings.StoreItemCollectionMustHaveOneArtifact, "filePaths"); // Wrap the file paths in instances of the MetadataArtifactLoader class, which provides // an abstraction and a uniform interface over a diverse set of metadata artifacts. // MetadataArtifactLoader composite = null; List readers = null; try { composite = MetadataArtifactLoader.CreateCompositeFromFilePaths(enumerableFilePaths, XmlConstants.SSpaceSchemaExtension); readers = composite.CreateReaders(DataSpace.SSpace); IEnumerable ieReaders = readers.AsEnumerable(); EntityUtil.CheckArgumentEmpty(ref ieReaders, Strings.StoreItemCollectionMustHaveOneArtifact, "filePaths"); this.Init(readers, composite.GetPaths(DataSpace.SSpace), true, out _providerManifest, out _providerFactory, out _providerManifestToken, out _cachedCTypeFunction); } finally { if (readers != null) { Helper.DisposeXmlReaders(readers); } } } private IList Init(IEnumerable xmlReaders, IEnumerable filePaths, bool throwOnError, out DbProviderManifest providerManifest, out DbProviderFactory providerFactory, out string providerManifestToken, out Memoizer cachedCTypeFunction) { EntityUtil.CheckArgumentNull(xmlReaders, "xmlReaders"); // 'filePaths' can be null cachedCTypeFunction = new Memoizer (ConvertFunctionParameterToCType, null); Loader loader = new Loader(xmlReaders, filePaths, throwOnError); providerFactory = loader.ProviderFactory; providerManifest = loader.ProviderManifest; providerManifestToken = loader.ProviderManifestToken; // load the items into the colleciton if (!loader.HasNonWarningErrors) { LoadProviderManifest(loader.ProviderManifest, true /* check for system namespace */); List errorList = EdmItemCollection.LoadItems(_providerManifest, loader.Schemas, this); foreach (var error in errorList) { loader.Errors.Add(error); } if (throwOnError && errorList.Count != 0) loader.ThrowOnNonWarningErrors(); } return loader.Errors; } #endregion #region Properties /// /// Returns the query cache manager /// internal System.Data.Common.QueryCache.QueryCacheManager QueryCacheManager { get { return _queryCacheManager; } } internal DbProviderFactory StoreProviderFactory { get { return _providerFactory; } } internal DbProviderManifest StoreProviderManifest { get { return _providerManifest; } } internal string StoreProviderManifestToken { get { return _providerManifestToken; } } internal Double SchemaVersion { get { return _schemaVersion; } set { _schemaVersion = value; } } #endregion #region Methods ////// Get the list of primitive types for the given space /// ///public System.Collections.ObjectModel.ReadOnlyCollection GetPrimitiveTypes() { return _primitiveTypeMaps.GetTypes(); } /// /// Given the canonical primitive type, get the mapping primitive type in the given dataspace /// /// canonical primitive type ///The mapped scalar type internal override PrimitiveType GetMappedPrimitiveType(PrimitiveTypeKind primitiveTypeKind) { PrimitiveType type = null; _primitiveTypeMaps.TryGetType(primitiveTypeKind, null, out type); return type; } ////// checks if the schemaKey refers to the provider manifest schema key /// and if true, loads the provider manifest /// /// The connection where the store manifest is loaded from /// Check for System namespace ///The provider manifest object that was loaded private void LoadProviderManifest(DbProviderManifest storeManifest, bool checkForSystemNamespace) { foreach (PrimitiveType primitiveType in storeManifest.GetStoreTypes()) { //Add it to the collection and the primitive type maps this.AddInternal(primitiveType); _primitiveTypeMaps.Add(primitiveType); } foreach (EdmFunction function in storeManifest.GetStoreFunctions()) { AddInternal(function); } } #endregion ////// Get all the overloads of the function with the given name, this method is used for internal perspective /// /// The full name of the function /// true for case-insensitive lookup ///A collection of all the functions with the given name in the given data space ///Thrown if functionaName argument passed in is null internal System.Collections.ObjectModel.ReadOnlyCollectionGetCTypeFunctions(string functionName, bool ignoreCase) { System.Collections.ObjectModel.ReadOnlyCollection functionOverloads; if (this.FunctionLookUpTable.TryGetValue(functionName, out functionOverloads)) { functionOverloads = ConvertToCTypeFunctions(functionOverloads); if (ignoreCase) { return functionOverloads; } return GetCaseSensitiveFunctions(functionOverloads, functionName); } return Helper.EmptyEdmFunctionReadOnlyCollection; } private System.Collections.ObjectModel.ReadOnlyCollection ConvertToCTypeFunctions( System.Collections.ObjectModel.ReadOnlyCollection functionOverloads) { List cTypeFunctions = new List (); foreach (var sTypeFunction in functionOverloads) { cTypeFunctions.Add(this._cachedCTypeFunction.Evaluate(sTypeFunction)); } return cTypeFunctions.AsReadOnly(); } /// /// Convert the S type function parameters and returnType to C type /// /// ///private EdmFunction ConvertFunctionParameterToCType(EdmFunction sTypeFunction) { if (sTypeFunction.IsFromProviderManifest) { return sTypeFunction; } FunctionParameter returnParameter = null; if (sTypeFunction.ReturnParameter != null) { TypeUsage edmTypeUsageReturnParameter = MetadataHelper.ConvertStoreTypeUsageToEdmTypeUsage(sTypeFunction.ReturnParameter.TypeUsage); returnParameter = new FunctionParameter( sTypeFunction.ReturnParameter.Name, edmTypeUsageReturnParameter, sTypeFunction.ReturnParameter.GetParameterMode()); } List parameters = new List (); if (sTypeFunction.Parameters.Count > 0) { foreach (var parameter in sTypeFunction.Parameters) { TypeUsage edmTypeUsage = MetadataHelper.ConvertStoreTypeUsageToEdmTypeUsage(parameter.TypeUsage); FunctionParameter edmTypeParameter = new FunctionParameter(parameter.Name, edmTypeUsage, parameter.GetParameterMode()); parameters.Add(edmTypeParameter); } } EdmFunction edmFunction = new EdmFunction(sTypeFunction.Name, sTypeFunction.NamespaceName, DataSpace.CSpace, new EdmFunctionPayload { Schema = sTypeFunction.Schema, StoreFunctionName = sTypeFunction.StoreFunctionNameAttribute, CommandText = sTypeFunction.CommandTextAttribute, IsAggregate = sTypeFunction.AggregateAttribute, IsBuiltIn = sTypeFunction.BuiltInAttribute, IsNiladic = sTypeFunction.NiladicFunctionAttribute, IsComposable = sTypeFunction.IsComposableAttribute, IsFromProviderManifest = sTypeFunction.IsFromProviderManifest, IsCachedStoreFunction = true, ReturnParameter = returnParameter, Parameters = parameters.ToArray(), ParameterTypeSemantics = sTypeFunction.ParameterTypeSemanticsAttribute, }); edmFunction.SetReadOnly(); return edmFunction; } }//---- ItemCollection }//---- // 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
- KeyedCollection.cs
- Random.cs
- ValidationPropertyAttribute.cs
- DataGridCommandEventArgs.cs
- ZipIOZip64EndOfCentralDirectoryLocatorBlock.cs
- GlyphTypeface.cs
- PerformanceCounterLib.cs
- SingleKeyFrameCollection.cs
- ScrollProperties.cs
- PeerContact.cs
- Transform.cs
- XmlEventCache.cs
- RoleManagerModule.cs
- SystemWebExtensionsSectionGroup.cs
- SafeMILHandle.cs
- Model3D.cs
- DesignTimeTemplateParser.cs
- DeleteMemberBinder.cs
- XmlAttributeCache.cs
- AppSettingsSection.cs
- Win32Exception.cs
- MinimizableAttributeTypeConverter.cs
- RenderData.cs
- CodeNamespaceImportCollection.cs
- CannotUnloadAppDomainException.cs
- HttpListener.cs
- DirectoryInfo.cs
- LinqDataSourceView.cs
- GroupItemAutomationPeer.cs
- BitSet.cs
- MetadataSerializer.cs
- ConfigXmlText.cs
- StrokeNodeEnumerator.cs
- BitmapFrame.cs
- CompositeFontInfo.cs
- MultiTrigger.cs
- DesignerTransactionCloseEvent.cs
- SqlCachedBuffer.cs
- HostSecurityManager.cs
- TableLayoutStyleCollection.cs
- MethodRental.cs
- InternalConfigHost.cs
- UIntPtr.cs
- DataBoundControl.cs
- ColumnBinding.cs
- ObjectStateEntryDbUpdatableDataRecord.cs
- RelationshipFixer.cs
- FileEnumerator.cs
- Section.cs
- ExcCanonicalXml.cs
- FieldDescriptor.cs
- RSAPKCS1SignatureFormatter.cs
- BitmapEffectState.cs
- _HeaderInfoTable.cs
- DataBindingCollection.cs
- ToolStripManager.cs
- EpmHelper.cs
- Accessors.cs
- BasePropertyDescriptor.cs
- TypedAsyncResult.cs
- OSFeature.cs
- BitmapDecoder.cs
- MobileTemplatedControlDesigner.cs
- TransformCollection.cs
- CertificateReferenceElement.cs
- XmlUtil.cs
- DesignerActionGlyph.cs
- TemplateFactory.cs
- ExecutorLocksHeldException.cs
- ALinqExpressionVisitor.cs
- SqlStatistics.cs
- SpellerInterop.cs
- ContentIterators.cs
- SQLChars.cs
- PersonalizationStateInfoCollection.cs
- DataControlReferenceCollection.cs
- XmlSchemaParticle.cs
- XmlComment.cs
- BoundPropertyEntry.cs
- SchemaElementLookUpTableEnumerator.cs
- CapabilitiesUse.cs
- CheckBoxRenderer.cs
- DataGridViewColumnCollection.cs
- SettingsPropertyWrongTypeException.cs
- WorkflowCommandExtensionItem.cs
- CompilerErrorCollection.cs
- ListViewTableRow.cs
- DesignSurfaceEvent.cs
- HttpStaticObjectsCollectionWrapper.cs
- login.cs
- webbrowsersite.cs
- OverflowException.cs
- BitmapInitialize.cs
- StylusPointProperty.cs
- EmulateRecognizeCompletedEventArgs.cs
- RouteCollection.cs
- COM2ColorConverter.cs
- NativeMethods.cs
- ReadContentAsBinaryHelper.cs
- ArrayConverter.cs