private static StorageMappingItemCollection LoadStoreCollection( EdmItemCollection edmItemCollection, MetadataArtifactLoader loader) { List <XmlReader> readers1 = loader.CreateReaders(DataSpace.SSpace); StoreItemCollection storeCollection; try { storeCollection = new StoreItemCollection((IEnumerable <XmlReader>)readers1, (IEnumerable <string>)loader.GetPaths(DataSpace.SSpace)); } finally { Helper.DisposeXmlReaders((IEnumerable <XmlReader>)readers1); } List <XmlReader> readers2 = loader.CreateReaders(DataSpace.CSSpace); try { return(new StorageMappingItemCollection(edmItemCollection, storeCollection, (IEnumerable <XmlReader>)readers2, (IList <string>)loader.GetPaths(DataSpace.CSSpace))); } finally { Helper.DisposeXmlReaders((IEnumerable <XmlReader>)readers2); } }
/// <summary> /// Initializes a new instance of the <see cref="T:System.Data.Entity.Core.Metadata.Edm.StoreItemCollection" /> class using the specified file paths. /// </summary> /// <param name="filePaths">The file paths used to create metadata.</param> public StoreItemCollection(params string[] filePaths) : base(DataSpace.SSpace) { Check.NotNull <string[]>(filePaths, nameof(filePaths)); IEnumerable <string> enumerableArgument1 = (IEnumerable <string>)filePaths; EntityUtil.CheckArgumentEmpty <string>(ref enumerableArgument1, new Func <string, string>(Strings.StoreItemCollectionMustHaveOneArtifact), nameof(filePaths)); List <XmlReader> source = (List <XmlReader>)null; try { MetadataArtifactLoader compositeFromFilePaths = MetadataArtifactLoader.CreateCompositeFromFilePaths(enumerableArgument1, ".ssdl"); source = compositeFromFilePaths.CreateReaders(DataSpace.SSpace); IEnumerable <XmlReader> enumerableArgument2 = source.AsEnumerable <XmlReader>(); EntityUtil.CheckArgumentEmpty <XmlReader>(ref enumerableArgument2, new Func <string, string>(Strings.StoreItemCollectionMustHaveOneArtifact), nameof(filePaths)); this.Init((IEnumerable <XmlReader>)source, (IEnumerable <string>)compositeFromFilePaths.GetPaths(DataSpace.SSpace), true, (IDbDependencyResolver)null, out this._providerManifest, out this._providerFactory, out this._providerInvariantName, out this._providerManifestToken, out this._cachedCTypeFunction); } finally { if (source != null) { Helper.DisposeXmlReaders((IEnumerable <XmlReader>)source); } } }
internal void LoadEdmItemCollection(MetadataArtifactLoader loader) { DebugCheck.NotNull(loader); var readers = loader.CreateReaders(DataSpace.CSpace); try { var itemCollection = new EdmItemCollection( readers, loader.GetPaths(DataSpace.CSpace) ); var permissionPaths = new List <string>(); loader.CollectFilePermissionPaths(permissionPaths, DataSpace.CSpace); FileIOPermission filePermissions = null; if (permissionPaths.Count > 0) { filePermissions = new FileIOPermission(FileIOPermissionAccess.Read, permissionPaths.ToArray()); } UpdateMetadataEntry(itemCollection, filePermissions); } finally { Helper.DisposeXmlReaders(readers); } }
public MetadataWorkspace GetMetadataWorkspace( DbConnectionOptions effectiveConnectionOptions) { MetadataArtifactLoader artifactLoader = this.GetArtifactLoader(effectiveConnectionOptions); return(this.GetMetadataWorkspace(MetadataCache.CreateMetadataCacheKey((IList <string>)artifactLoader.GetPaths(), effectiveConnectionOptions["provider"]), artifactLoader)); }
//For MetadataArtifactLoader.CreateCompositeFromFilePaths method call but we do not create the file paths in this method public EdmItemCollection(params string[] filePaths) : base(DataSpace.CSpace) { Check.NotNull(filePaths, "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 <XmlReader> readers = null; try { composite = MetadataArtifactLoader.CreateCompositeFromFilePaths(filePaths, XmlConstants.CSpaceSchemaExtension); readers = composite.CreateReaders(DataSpace.CSpace); Init( readers, composite.GetPaths(DataSpace.CSpace), true /*throwOnError*/); } finally { if (readers != null) { Helper.DisposeXmlReaders(readers); } } }
public static MetadataArtifactLoader Create( string path, MetadataArtifactLoader.ExtensionCheck extensionCheck, string validExtension, ICollection <string> uriRegistry) { return(MetadataArtifactLoader.Create(path, extensionCheck, validExtension, uriRegistry, (MetadataArtifactAssemblyResolver) new DefaultAssemblyResolver())); }
internal void LoadStoreCollection(EdmItemCollection edmItemCollection, MetadataArtifactLoader loader) { StoreItemCollection storeItemCollection = null; IEnumerable <XmlReader> sSpaceXmlReaders = loader.CreateReaders(DataSpace.SSpace); try { // Load the store side, however, only do so if we don't already have one storeItemCollection = new StoreItemCollection( sSpaceXmlReaders, loader.GetPaths(DataSpace.SSpace)); } finally { Helper.DisposeXmlReaders(sSpaceXmlReaders); } // If this entry is getting re-used, make sure that the previous query cache manager gets // cleared up if (_queryCacheManager != null) { _queryCacheManager.Clear(); } // Update the query cache manager reference _queryCacheManager = storeItemCollection.QueryCacheManager; // With the store metadata in place, we can then load the mappings, however, only use it // if we don't already have one // StorageMappingItemCollection storageMappingItemCollection = null; IEnumerable <XmlReader> csSpaceXmlReaders = loader.CreateReaders(DataSpace.CSSpace); try { storageMappingItemCollection = new StorageMappingItemCollection( edmItemCollection, storeItemCollection, csSpaceXmlReaders, loader.GetPaths(DataSpace.CSSpace)); } finally { Helper.DisposeXmlReaders(csSpaceXmlReaders); } var permissionPaths = new List <string>(); loader.CollectFilePermissionPaths(permissionPaths, DataSpace.SSpace); loader.CollectFilePermissionPaths(permissionPaths, DataSpace.CSSpace); FileIOPermission filePermissions = null; if (permissionPaths.Count > 0) { filePermissions = new FileIOPermission(FileIOPermissionAccess.Read, permissionPaths.ToArray()); } UpdateMetadataEntry(storageMappingItemCollection, filePermissions); }
/// <summary> /// Initializes a new instance of the <see cref="T:System.Data.Entity.Core.Metadata.Edm.StoreItemCollection" /> class using the specified XMLReader. /// </summary> /// <param name="xmlReaders">The XMLReader used to create metadata.</param> public StoreItemCollection(IEnumerable <XmlReader> xmlReaders) : base(DataSpace.SSpace) { Check.NotNull <IEnumerable <XmlReader> >(xmlReaders, nameof(xmlReaders)); EntityUtil.CheckArgumentEmpty <XmlReader>(ref xmlReaders, new Func <string, string>(Strings.StoreItemCollectionMustHaveOneArtifact), "xmlReader"); MetadataArtifactLoader compositeFromXmlReaders = MetadataArtifactLoader.CreateCompositeFromXmlReaders(xmlReaders); this.Init((IEnumerable <XmlReader>)compositeFromXmlReaders.GetReaders(), (IEnumerable <string>)compositeFromXmlReaders.GetPaths(), true, (IDbDependencyResolver)null, out this._providerManifest, out this._providerFactory, out this._providerInvariantName, out this._providerManifestToken, out this._cachedCTypeFunction); }
/// <summary> /// Initializes a new instance of the <see cref="T:System.Data.Entity.Core.Metadata.Edm.EdmItemCollection" /> class by using the collection of the XMLReader objects where the conceptual schema definition language (CSDL) files exist. /// </summary> /// <param name="xmlReaders">The collection of the XMLReader objects where the conceptual schema definition language (CSDL) files exist.</param> public EdmItemCollection(IEnumerable <XmlReader> xmlReaders) : base(DataSpace.CSpace) { Check.NotNull <IEnumerable <XmlReader> >(xmlReaders, nameof(xmlReaders)); EntityUtil.CheckArgumentContainsNull <XmlReader>(ref xmlReaders, nameof(xmlReaders)); MetadataArtifactLoader compositeFromXmlReaders = MetadataArtifactLoader.CreateCompositeFromXmlReaders(xmlReaders); this.Init((IEnumerable <XmlReader>)compositeFromXmlReaders.GetReaders(), (IEnumerable <string>)compositeFromXmlReaders.GetPaths(), true); }
internal static void CheckArtifactExtension(string path, string validExtension) { string extension = MetadataArtifactLoader.GetExtension(path); if (!extension.Equals(validExtension, StringComparison.OrdinalIgnoreCase)) { throw new MetadataException(Strings.InvalidFileExtension((object)path, (object)extension, (object)validExtension)); } }
public virtual List <string> GetOriginalPaths(DataSpace spaceToGet) { List <string> stringList = new List <string>(); if (MetadataArtifactLoader.IsArtifactOfDataSpace(this.Path, spaceToGet)) { stringList.Add(this.Path); } return(stringList); }
protected static bool IsCSSpaceArtifact(string resource) { string extension = MetadataArtifactLoader.GetExtension(resource); if (!string.IsNullOrEmpty(extension)) { return(string.Compare(extension, ".msl", StringComparison.OrdinalIgnoreCase) == 0); } return(false); }
public override List <string> GetPaths(DataSpace spaceToGet) { List <string> stringList = new List <string>(); if (!this._alreadyLoaded && MetadataArtifactLoader.IsArtifactOfDataSpace(this._path, spaceToGet)) { stringList.Add(this._path); } return(stringList); }
public override List <XmlReader> CreateReaders(DataSpace spaceToGet) { List <XmlReader> xmlReaderList = new List <XmlReader>(); if (MetadataArtifactLoader.IsArtifactOfDataSpace(this.Path, spaceToGet)) { xmlReaderList.Add(this._reader); } return(xmlReaderList); }
public MetadataWorkspace GetMetadataWorkspace( string cacheKey, MetadataArtifactLoader artifactLoader) { return(this._cachedWorkspaces.GetOrAdd(cacheKey, (Func <string, MetadataWorkspace>)(k => { EdmItemCollection edmItemCollection = MetadataCache.LoadEdmItemCollection(artifactLoader); Lazy <StorageMappingItemCollection> mappingLoader = new Lazy <StorageMappingItemCollection>((Func <StorageMappingItemCollection>)(() => MetadataCache.LoadStoreCollection(edmItemCollection, artifactLoader))); return new MetadataWorkspace((Func <EdmItemCollection>)(() => edmItemCollection), (Func <StoreItemCollection>)(() => mappingLoader.Value.StoreItemCollection), (Func <StorageMappingItemCollection>)(() => mappingLoader.Value)); }))); }
public override List <XmlReader> CreateReaders(DataSpace spaceToGet) { List <XmlReader> xmlReaderList = new List <XmlReader>(); if (!this._alreadyLoaded && MetadataArtifactLoader.IsArtifactOfDataSpace(this._path, spaceToGet)) { XmlReader xmlReader = this.CreateXmlReader(); xmlReaderList.Add(xmlReader); } return(xmlReaderList); }
public MetadataArtifactLoader GetArtifactLoader( DbConnectionOptions effectiveConnectionOptions) { string connectionOption = effectiveConnectionOptions["metadata"]; if (string.IsNullOrEmpty(connectionOption)) { return(MetadataArtifactLoader.Create(new List <MetadataArtifactLoader>())); } List <MetadataArtifactLoader> metadataArtifactLoaderList = this._artifactLoaderCache.Evaluate(connectionOption); return(MetadataArtifactLoader.Create(MetadataCache.ShouldRecalculateMetadataArtifactLoader((IEnumerable <MetadataArtifactLoader>)metadataArtifactLoaderList) ? MetadataCache.SplitPaths(connectionOption) : metadataArtifactLoaderList)); }
/// <summary> /// Initializes a new instance of the <see cref="T:System.Data.Entity.Core.Metadata.Edm.EdmItemCollection" /> class by using the collection of the XMLReader objects where the conceptual schema definition language (CSDL) files exist. /// </summary> /// <param name="xmlReaders">The collection of the XMLReader objects where the conceptual schema definition language (CSDL) files exist.</param> public EdmItemCollection(IEnumerable <XmlReader> xmlReaders) : base(DataSpace.CSpace) { Check.NotNull(xmlReaders, "xmlReaders"); EntityUtil.CheckArgumentContainsNull(ref xmlReaders, "xmlReaders"); var composite = MetadataArtifactLoader.CreateCompositeFromXmlReaders(xmlReaders); Init( composite.GetReaders(), composite.GetPaths(), true /*throwOnError*/); }
internal static bool IsValidArtifact(string resource) { string extension = MetadataArtifactLoader.GetExtension(resource); if (string.IsNullOrEmpty(extension)) { return(false); } if (string.Compare(extension, ".csdl", StringComparison.OrdinalIgnoreCase) != 0 && string.Compare(extension, ".ssdl", StringComparison.OrdinalIgnoreCase) != 0) { return(string.Compare(extension, ".msl", StringComparison.OrdinalIgnoreCase) == 0); } return(true); }
private static EdmItemCollection LoadEdmItemCollection( MetadataArtifactLoader loader) { List <XmlReader> readers = loader.CreateReaders(DataSpace.CSpace); try { return(new EdmItemCollection((IEnumerable <XmlReader>)readers, (IEnumerable <string>)loader.GetPaths(DataSpace.CSpace), false)); } finally { Helper.DisposeXmlReaders((IEnumerable <XmlReader>)readers); } }
/// <summary> /// Retrieves an cache entry holding to edm metadata for a given cache key /// </summary> /// <param name="cacheKey"> string containing all the files from which edm metadata is to be retrieved </param> /// <param name="composite"> An instance of the composite MetadataArtifactLoader </param> /// <param name="entryToken"> The metadata entry token for the returned entry </param> /// <returns> Returns the entry containing the edm metadata </returns> internal static EdmItemCollection GetOrCreateEdmItemCollection( string cacheKey, MetadataArtifactLoader loader, out object entryToken) { var entry = GetCacheEntry( _edmLevelCache, cacheKey, _edmLevelLock, new EdmMetadataEntryConstructor(), out entryToken); // Load the edm item collection or if the collection is already loaded, check for security permission LoadItemCollection(new EdmItemCollectionLoader(loader), entry); return(entry.EdmItemCollection); }
/// <summary> /// Constructs a struct from which you can load edm item collection /// </summary> /// <param name="factory"> </param> /// <param name="edmItemCollection"> </param> internal StoreItemCollectionLoader(EdmItemCollection edmItemCollection, MetadataArtifactLoader loader) { DebugCheck.NotNull(edmItemCollection); DebugCheck.NotNull(loader); //StoreItemCollection requires atleast one SSDL path. if ((loader.GetPaths(DataSpace.SSpace) == null) || (loader.GetPaths(DataSpace.SSpace).Count == 0)) { throw new MetadataException(Strings.AtleastOneSSDLNeeded); } _edmItemCollection = edmItemCollection; _loader = loader; }
private static EdmItemCollection LoadEdmItemCollection(MetadataArtifactLoader loader) { DebugCheck.NotNull(loader); var readers = loader.CreateReaders(DataSpace.CSpace); try { return(new EdmItemCollection(readers, loader.GetPaths(DataSpace.CSpace))); } finally { Helper.DisposeXmlReaders(readers); } }
public static MetadataArtifactLoader CreateCompositeFromXmlReaders( IEnumerable <XmlReader> xmlReaders) { List <MetadataArtifactLoader> allCollections = new List <MetadataArtifactLoader>(); foreach (XmlReader xmlReader in xmlReaders) { if (xmlReader == null) { throw new ArgumentException(Strings.ADP_CollectionParameterElementIsNull((object)nameof(xmlReaders))); } allCollections.Add((MetadataArtifactLoader) new MetadataArtifactLoaderXmlReaderWrapper(xmlReader)); } return(MetadataArtifactLoader.Create(allCollections)); }
/// <summary> /// Retrieves an entry holding store metadata for a given cache key /// </summary> /// <param name="cacheKey"> The connection string whose store metadata is to be retrieved </param> /// <param name="composite"> An instance of the composite MetadataArtifactLoader </param> /// <param name="entryToken"> The metadata entry token for the returned entry </param> /// <returns> the entry containing the information on how to load store metadata </returns> internal static StorageMappingItemCollection GetOrCreateStoreAndMappingItemCollections( string cacheKey, MetadataArtifactLoader loader, EdmItemCollection edmItemCollection, out object entryToken) { var entry = GetCacheEntry( _storeLevelCache, cacheKey, _storeLevelLock, new StoreMetadataEntryConstructor(), out entryToken); // Load the store item collection or if the collection is already loaded, check for security permission LoadItemCollection(new StoreItemCollectionLoader(edmItemCollection, loader), entry); return(entry.StorageMappingItemCollection); }
/// <summary> /// Public constructor that loads the metadata files from the specified xmlReaders. /// Throws when encounter errors. /// </summary> /// <param name="xmlReaders"> xmlReaders where the CDM schemas are loaded </param> public StoreItemCollection(IEnumerable <XmlReader> xmlReaders) : base(DataSpace.SSpace) { Check.NotNull(xmlReaders, "xmlReaders"); EntityUtil.CheckArgumentEmpty(ref xmlReaders, Strings.StoreItemCollectionMustHaveOneArtifact, "xmlReader"); var composite = MetadataArtifactLoader.CreateCompositeFromXmlReaders(xmlReaders); Init( composite.GetReaders(), composite.GetPaths(), true, out _providerManifest, out _providerFactory, out _providerManifestToken, out _cachedCTypeFunction); }
protected static bool IsArtifactOfDataSpace(string resource, DataSpace dataSpace) { switch (dataSpace) { case DataSpace.CSpace: return(MetadataArtifactLoader.IsCSpaceArtifact(resource)); case DataSpace.SSpace: return(MetadataArtifactLoader.IsSSpaceArtifact(resource)); case DataSpace.CSSpace: return(MetadataArtifactLoader.IsCSSpaceArtifact(resource)); default: return(false); } }
public MetadataArtifactLoader GetArtifactLoader(DbConnectionOptions effectiveConnectionOptions) { DebugCheck.NotNull(effectiveConnectionOptions); var paths = effectiveConnectionOptions[EntityConnectionStringBuilder.MetadataParameterName]; if (!string.IsNullOrEmpty(paths)) { var loaders = _artifactLoaderCache.Evaluate(paths); return(MetadataArtifactLoader.Create( ShouldRecalculateMetadataArtifactLoader(loaders) ? SplitPaths(paths) : loaders)); } return(MetadataArtifactLoader.Create(new List <MetadataArtifactLoader>())); }
public MetadataWorkspace GetMetadataWorkspace(string cacheKey, MetadataArtifactLoader artifactLoader) { DebugCheck.NotEmpty(cacheKey); DebugCheck.NotNull(artifactLoader); return(_cachedWorkspaces.GetOrAdd( cacheKey, k => { var edmItemCollection = LoadEdmItemCollection(artifactLoader); var mappingLoader = new Lazy <StorageMappingItemCollection>( () => LoadStoreCollection(edmItemCollection, artifactLoader)); return new MetadataWorkspace( () => edmItemCollection, () => mappingLoader.Value.StoreItemCollection, () => mappingLoader.Value); })); }
/// <summary> /// Initializes a new instance of the <see cref="T:System.Data.Entity.Core.Metadata.Edm.EdmItemCollection" /> class by using the paths where the conceptual schema definition language (CSDL) files exist. /// </summary> /// <param name="filePaths">The paths where the conceptual schema definition language (CSDL) files exist.</param> public EdmItemCollection(params string[] filePaths) : base(DataSpace.CSpace) { Check.NotNull <string[]>(filePaths, nameof(filePaths)); List <XmlReader> xmlReaderList = (List <XmlReader>)null; try { MetadataArtifactLoader compositeFromFilePaths = MetadataArtifactLoader.CreateCompositeFromFilePaths((IEnumerable <string>)filePaths, ".csdl"); xmlReaderList = compositeFromFilePaths.CreateReaders(DataSpace.CSpace); this.Init((IEnumerable <XmlReader>)xmlReaderList, (IEnumerable <string>)compositeFromFilePaths.GetPaths(DataSpace.CSpace), true); } finally { if (xmlReaderList != null) { Helper.DisposeXmlReaders((IEnumerable <XmlReader>)xmlReaderList); } } }
private static EdmItemCollection LoadEdmItemCollection(MetadataArtifactLoader loader) { DebugCheck.NotNull(loader); var readers = loader.CreateReaders(DataSpace.CSpace); try { return new EdmItemCollection(readers, loader.GetPaths(DataSpace.CSpace)); } finally { Helper.DisposeXmlReaders(readers); } }
private static StorageMappingItemCollection LoadStoreCollection(EdmItemCollection edmItemCollection, MetadataArtifactLoader loader) { StoreItemCollection storeItemCollection; var sSpaceXmlReaders = loader.CreateReaders(DataSpace.SSpace); try { storeItemCollection = new StoreItemCollection( sSpaceXmlReaders, loader.GetPaths(DataSpace.SSpace)); } finally { Helper.DisposeXmlReaders(sSpaceXmlReaders); } var csSpaceXmlReaders = loader.CreateReaders(DataSpace.CSSpace); try { return new StorageMappingItemCollection( edmItemCollection, storeItemCollection, csSpaceXmlReaders, loader.GetPaths(DataSpace.CSSpace)); } finally { Helper.DisposeXmlReaders(csSpaceXmlReaders); } }
public MetadataWorkspace GetMetadataWorkspace(string cacheKey, MetadataArtifactLoader artifactLoader) { DebugCheck.NotEmpty(cacheKey); DebugCheck.NotNull(artifactLoader); return _cachedWorkspaces.GetOrAdd( cacheKey, k => { var edmItemCollection = LoadEdmItemCollection(artifactLoader); var mappingLoader = new Lazy<StorageMappingItemCollection>( () => LoadStoreCollection(edmItemCollection, artifactLoader)); return new MetadataWorkspace( () => edmItemCollection, () => mappingLoader.Value.StoreItemCollection, () => mappingLoader.Value); }); }
private static void LoadStoreItemCollections( MetadataWorkspace workspace, DbConnection storeConnection, DbConnectionOptions connectionOptions, EdmItemCollection edmItemCollection, MetadataArtifactLoader artifactLoader) { Debug.Assert( workspace.IsItemCollectionAlreadyRegistered(DataSpace.CSpace), "C-Space must be loaded before loading S or C-S space"); // The provider connection string is optional; if it has not been specified, // we pick up the store's connection string. // var providerConnectionString = connectionOptions[EntityConnectionStringBuilder.ProviderConnectionStringParameterName]; if (string.IsNullOrEmpty(providerConnectionString) && (storeConnection != null)) { providerConnectionString = storeConnection.ConnectionString; } // Build a string as the key and look up the MetadataCache for a match var storeCacheKey = CreateMetadataCacheKey( artifactLoader.GetOriginalPaths(), connectionOptions[EntityConnectionStringBuilder.ProviderParameterName], providerConnectionString); // Load store metadata. object entryToken; var mappingCollection = MetadataCache.GetOrCreateStoreAndMappingItemCollections( storeCacheKey, artifactLoader, edmItemCollection, out entryToken); workspace.RegisterItemCollection(mappingCollection.StoreItemCollection); workspace.RegisterItemCollection(mappingCollection); // Adding the store metadata entry token to the workspace workspace.AddMetadataEntryToken(entryToken); }
//For SplitPaths call and we pick the file names from class variable. internal virtual MetadataWorkspace GetMetadataWorkspace(bool initializeAllCollections) { Debug.Assert( _metadataWorkspace != null || _effectiveConnectionOptions != null, "The effective connection options is null, which should never be"); if (_metadataWorkspace == null || (initializeAllCollections && !_metadataWorkspace.IsItemCollectionAlreadyRegistered(DataSpace.SSpace))) { // This lock is to ensure that the connection string and the metadata workspace are in a consistent state, that is, you // don't get a metadata workspace not matching what's described by the connection string lock (_connectionStringLock) { EdmItemCollection edmItemCollection = null; if (_metadataWorkspace == null) { var workspace = new MetadataWorkspace(); var loaders = new List<MetadataArtifactLoader>(); var paths = _effectiveConnectionOptions[EntityConnectionStringBuilder.MetadataParameterName]; if (!string.IsNullOrEmpty(paths)) { loaders = MetadataCache.GetOrCreateMetdataArtifactLoader(paths); if (!ShouldRecalculateMetadataArtifactLoader(loaders)) { _artifactLoader = MetadataArtifactLoader.Create(loaders); } else { // the loaders contains folders that might get updated during runtime, so we have to recalculate the loaders again _artifactLoader = MetadataArtifactLoader.Create(MetadataCache.SplitPaths(paths)); } } else { _artifactLoader = MetadataArtifactLoader.Create(loaders); } edmItemCollection = LoadEdmItemCollection(workspace, _artifactLoader); _metadataWorkspace = workspace; } else { edmItemCollection = (EdmItemCollection)_metadataWorkspace.GetItemCollection(DataSpace.CSpace); } if (initializeAllCollections && !_metadataWorkspace.IsItemCollectionAlreadyRegistered(DataSpace.SSpace)) { LoadStoreItemCollections( _metadataWorkspace, _storeConnection, _effectiveConnectionOptions, edmItemCollection, _artifactLoader); _artifactLoader = null; _initialized = true; } } } return _metadataWorkspace; }
private static EdmItemCollection LoadEdmItemCollection(MetadataWorkspace workspace, MetadataArtifactLoader artifactLoader) { // Build a string as the key and look up the MetadataCache for a match var edmCacheKey = CreateMetadataCacheKey(artifactLoader.GetOriginalPaths(DataSpace.CSpace), null, null); // Check the MetadataCache for an entry with this key object entryToken; var edmItemCollection = MetadataCache.GetOrCreateEdmItemCollection( edmCacheKey, artifactLoader, out entryToken); workspace.RegisterItemCollection(edmItemCollection); // Adding the edm metadata entry token to the workspace, to make sure that this token remains alive till workspace is alive workspace.AddMetadataEntryToken(entryToken); return edmItemCollection; }