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);
}
}
//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);
}
}
}
/// <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);
}
}
}
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);
}
}
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);
}
}
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);
}
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);
}
}
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);
}
}
/// <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);
}
}
}
//For MetadataArtifactLoader.CreateCompositeFromFilePaths method call but we do not create the file paths in this method
public StoreItemCollection(params string[] filePaths)
: base(DataSpace.SSpace)
{
Check.NotNull(filePaths, "filePaths");
IEnumerable <string> enumerableFilePaths = 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 <XmlReader> readers = null;
try
{
composite = MetadataArtifactLoader.CreateCompositeFromFilePaths(enumerableFilePaths, XmlConstants.SSpaceSchemaExtension);
readers = composite.CreateReaders(DataSpace.SSpace);
var ieReaders = readers.AsEnumerable();
EntityUtil.CheckArgumentEmpty(ref ieReaders, Strings.StoreItemCollectionMustHaveOneArtifact, "filePaths");
Init(
readers,
composite.GetPaths(DataSpace.SSpace), /* throwOnError */ true, /* resolver */ null,
out _providerManifest,
out _providerFactory,
out _providerInvariantName,
out _providerManifestToken,
out _cachedCTypeFunction);
}
finally
{
if (readers != null)
{
Helper.DisposeXmlReaders(readers);
}
}
}
