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;
}
