internal static MetadataArtifactLoader CreateResourceLoader(
string path, ExtensionCheck extensionCheck, string validExtension, ICollection <string> uriRegistry,
MetadataArtifactAssemblyResolver resolver)
{
DebugCheck.NotNull(path);
Debug.Assert(PathStartsWithResPrefix(path));
// if the supplied path ends with a separator, or contains only one
// segment (i.e., the name of an assembly, or the wildcard character),
// create a composite loader that can extract resources from one or
// more assemblies
//
var createCompositeResLoader = false;
string assemblyName = null;
string resourceName = null;
ParseResourcePath(path, out assemblyName, out resourceName);
createCompositeResLoader = (assemblyName != null) && (resourceName == null || assemblyName.Trim() == wildcard);
ValidateExtension(extensionCheck, validExtension, resourceName);
if (createCompositeResLoader)
{
return(new MetadataArtifactLoaderCompositeResource(path, assemblyName, resourceName, uriRegistry, resolver));
}
Debug.Assert(!string.IsNullOrEmpty(resourceName), "we should not get here is the resourceName is null");
var assembly = ResolveAssemblyName(assemblyName, resolver);
return(new MetadataArtifactLoaderResource(assembly, resourceName, uriRegistry));
}
private static List <MetadataArtifactLoaderResource> LoadResources(
string assemblyName,
string resourceName,
ICollection <string> uriRegistry,
MetadataArtifactAssemblyResolver resolver)
{
List <MetadataArtifactLoaderResource> loaders = new List <MetadataArtifactLoaderResource>();
if (assemblyName == MetadataArtifactLoader.wildcard)
{
foreach (Assembly wildcardAssembly in resolver.GetWildcardAssemblies())
{
if (MetadataArtifactLoaderCompositeResource.AssemblyContainsResource(wildcardAssembly, ref resourceName))
{
MetadataArtifactLoaderCompositeResource.LoadResourcesFromAssembly(wildcardAssembly, resourceName, uriRegistry, loaders);
}
}
}
else
{
MetadataArtifactLoaderCompositeResource.LoadResourcesFromAssembly(MetadataArtifactLoaderCompositeResource.ResolveAssemblyName(assemblyName, resolver), resourceName, uriRegistry, loaders);
}
if (resourceName != null && loaders.Count == 0)
{
throw new System.Data.Entity.Core.MetadataException(Strings.UnableToLoadResource);
}
return(loaders);
}
/// <summary>
/// This constructor expects to get the paths that have potential to turn into multiple
/// artifacts like
///
/// res://*/foo.csdl -- could be multiple assemblies
/// res://MyAssembly/ -- could be multiple artifacts in the one assembly
///
/// </summary>
/// <param name="path">The path to the (collection of) resources</param>
/// <param name="uriRegistry">The global registry of URIs</param>
/// <param name="resolveAssembly"></param>
internal MetadataArtifactLoaderCompositeResource(
string originalPath, string assemblyName, string resourceName, ICollection<string> uriRegistry,
MetadataArtifactAssemblyResolver resolver)
{
Debug.Assert(resolver != null);
_originalPath = originalPath;
_children = LoadResources(assemblyName, resourceName, uriRegistry, resolver).AsReadOnly();
}
// <summary>
// This constructor expects to get the paths that have potential to turn into multiple
// artifacts like
// res://*/xyz.csdl -- could be multiple assemblies
// res://MyAssembly/ -- could be multiple artifacts in the one assembly
// </summary>
// <param name="originalPath"> The path to the (collection of) resources </param>
// <param name="uriRegistry"> The global registry of URIs </param>
internal MetadataArtifactLoaderCompositeResource(
string originalPath, string assemblyName, string resourceName, ICollection <string> uriRegistry,
MetadataArtifactAssemblyResolver resolver)
{
DebugCheck.NotNull(resolver);
_originalPath = originalPath;
_children = new ReadOnlyCollection <MetadataArtifactLoaderResource>(LoadResources(assemblyName, resourceName, uriRegistry, resolver));
}
// <summary>
// This constructor expects to get the paths that have potential to turn into multiple
// artifacts like
// res://*/xyz.csdl -- could be multiple assemblies
// res://MyAssembly/ -- could be multiple artifacts in the one assembly
// </summary>
// <param name="originalPath"> The path to the (collection of) resources </param>
// <param name="uriRegistry"> The global registry of URIs </param>
internal MetadataArtifactLoaderCompositeResource(
string originalPath, string assemblyName, string resourceName, ICollection<string> uriRegistry,
MetadataArtifactAssemblyResolver resolver)
{
DebugCheck.NotNull(resolver);
_originalPath = originalPath;
_children = new ReadOnlyCollection<MetadataArtifactLoaderResource>(LoadResources(assemblyName, resourceName, uriRegistry, resolver));
}
internal MetadataArtifactLoaderCompositeResource(
string originalPath,
string assemblyName,
string resourceName,
ICollection <string> uriRegistry,
MetadataArtifactAssemblyResolver resolver)
{
this._originalPath = originalPath;
this._children = new ReadOnlyCollection <MetadataArtifactLoaderResource>((IList <MetadataArtifactLoaderResource>)MetadataArtifactLoaderCompositeResource.LoadResources(assemblyName, resourceName, uriRegistry, resolver));
}
private static Assembly ResolveAssemblyName(
string assemblyName,
MetadataArtifactAssemblyResolver resolver)
{
AssemblyName refernceName = new AssemblyName(assemblyName);
Assembly assembly;
if (!resolver.TryResolveAssemblyReference(refernceName, out assembly))
{
throw new FileNotFoundException(Strings.UnableToResolveAssembly((object)assemblyName));
}
return(assembly);
}
[ResourceConsumption(ResourceScope.Machine)] //For CheckArtifactExtension method call. But the path is not created in this method.
internal static MetadataArtifactLoader Create(
string path,
ExtensionCheck extensionCheck,
string validExtension,
ICollection <string> uriRegistry,
MetadataArtifactAssemblyResolver resolver)
{
DebugCheck.NotNull(path);
DebugCheck.NotNull(resolver);
// res:// -based artifacts
//
if (PathStartsWithResPrefix(path))
{
return(MetadataArtifactLoaderCompositeResource.CreateResourceLoader(
path, extensionCheck, validExtension, uriRegistry, resolver));
}
// Files and Folders
//
var normalizedPath = NormalizeFilePaths(path);
if (Directory.Exists(normalizedPath))
{
return(new MetadataArtifactLoaderCompositeFile(normalizedPath, uriRegistry));
}
else if (File.Exists(normalizedPath))
{
switch (extensionCheck)
{
case ExtensionCheck.Specific:
CheckArtifactExtension(normalizedPath, validExtension);
break;
case ExtensionCheck.All:
if (!IsValidArtifact(normalizedPath))
{
throw new MetadataException(Strings.InvalidMetadataPath);
}
break;
}
return(new MetadataArtifactLoaderFile(normalizedPath, uriRegistry));
}
throw new MetadataException(Strings.InvalidMetadataPath);
}
[ResourceConsumption(ResourceScope.Machine)] //For CheckArtifactExtension method call. But the path is not created in this method.
internal static MetadataArtifactLoader Create(
string path,
ExtensionCheck extensionCheck,
string validExtension,
ICollection<string> uriRegistry,
MetadataArtifactAssemblyResolver resolver)
{
DebugCheck.NotNull(path);
DebugCheck.NotNull(resolver);
// res:// -based artifacts
//
if (PathStartsWithResPrefix(path))
{
return MetadataArtifactLoaderCompositeResource.CreateResourceLoader(
path, extensionCheck, validExtension, uriRegistry, resolver);
}
// Files and Folders
//
var normalizedPath = NormalizeFilePaths(path);
if (Directory.Exists(normalizedPath))
{
return new MetadataArtifactLoaderCompositeFile(normalizedPath, uriRegistry);
}
else if (File.Exists(normalizedPath))
{
switch (extensionCheck)
{
case ExtensionCheck.Specific:
CheckArtifactExtension(normalizedPath, validExtension);
break;
case ExtensionCheck.All:
if (!IsValidArtifact(normalizedPath))
{
throw new MetadataException(Strings.InvalidMetadataPath);
}
break;
}
return new MetadataArtifactLoaderFile(normalizedPath, uriRegistry);
}
throw new MetadataException(Strings.InvalidMetadataPath);
}
[ResourceConsumption(ResourceScope.Machine)] //For Create method call. But the paths are not created in this method.
internal static MetadataArtifactLoader CreateCompositeFromFilePaths(
IEnumerable <string> filePaths, string validExtension, MetadataArtifactAssemblyResolver resolver)
{
ExtensionCheck extensionCheck;
if (string.IsNullOrEmpty(validExtension))
{
extensionCheck = ExtensionCheck.All;
}
else
{
extensionCheck = ExtensionCheck.Specific;
}
var loaders = new List <MetadataArtifactLoader>();
// The following set is used to remove duplicate paths from the incoming array
var uriRegistry = new HashSet <string>(StringComparer.OrdinalIgnoreCase);
foreach (var path in filePaths)
{
if (string.IsNullOrEmpty(path))
{
throw new MetadataException(
Strings.NotValidInputPath, new ArgumentException(Strings.ADP_CollectionParameterElementIsNullOrEmpty("filePaths")));
}
var trimedPath = path.Trim();
if (trimedPath.Length > 0)
{
loaders.Add(
Create(
trimedPath,
extensionCheck,
validExtension,
uriRegistry,
resolver)
);
}
}
return(Create(loaders));
}
internal static MetadataArtifactLoader CreateResourceLoader(
string path,
MetadataArtifactLoader.ExtensionCheck extensionCheck,
string validExtension,
ICollection <string> uriRegistry,
MetadataArtifactAssemblyResolver resolver)
{
string assemblyName = (string)null;
string resourceName = (string)null;
MetadataArtifactLoaderCompositeResource.ParseResourcePath(path, out assemblyName, out resourceName);
bool flag = assemblyName != null && (resourceName == null || assemblyName.Trim() == MetadataArtifactLoader.wildcard);
MetadataArtifactLoaderCompositeResource.ValidateExtension(extensionCheck, validExtension, resourceName);
if (flag)
{
return((MetadataArtifactLoader) new MetadataArtifactLoaderCompositeResource(path, assemblyName, resourceName, uriRegistry, resolver));
}
return((MetadataArtifactLoader) new MetadataArtifactLoaderResource(MetadataArtifactLoaderCompositeResource.ResolveAssemblyName(assemblyName, resolver), resourceName, uriRegistry));
}
internal static MetadataArtifactLoader CreateCompositeFromFilePaths(
IEnumerable <string> filePaths,
string validExtension,
MetadataArtifactAssemblyResolver resolver)
{
MetadataArtifactLoader.ExtensionCheck extensionCheck = !string.IsNullOrEmpty(validExtension) ? MetadataArtifactLoader.ExtensionCheck.Specific : MetadataArtifactLoader.ExtensionCheck.All;
List <MetadataArtifactLoader> allCollections = new List <MetadataArtifactLoader>();
HashSet <string> stringSet = new HashSet <string>((IEqualityComparer <string>)StringComparer.OrdinalIgnoreCase);
foreach (string filePath in filePaths)
{
if (string.IsNullOrEmpty(filePath))
{
throw new MetadataException(Strings.NotValidInputPath, (Exception) new ArgumentException(Strings.ADP_CollectionParameterElementIsNullOrEmpty((object)nameof(filePaths))));
}
string path = filePath.Trim();
if (path.Length > 0)
{
allCollections.Add(MetadataArtifactLoader.Create(path, extensionCheck, validExtension, (ICollection <string>)stringSet, resolver));
}
}
return(MetadataArtifactLoader.Create(allCollections));
}
internal static MetadataArtifactLoader Create(
string path,
MetadataArtifactLoader.ExtensionCheck extensionCheck,
string validExtension,
ICollection <string> uriRegistry,
MetadataArtifactAssemblyResolver resolver)
{
if (MetadataArtifactLoader.PathStartsWithResPrefix(path))
{
return(MetadataArtifactLoaderCompositeResource.CreateResourceLoader(path, extensionCheck, validExtension, uriRegistry, resolver));
}
string str = MetadataArtifactLoader.NormalizeFilePaths(path);
if (Directory.Exists(str))
{
return((MetadataArtifactLoader) new MetadataArtifactLoaderCompositeFile(str, uriRegistry));
}
if (!File.Exists(str))
{
throw new MetadataException(Strings.InvalidMetadataPath);
}
switch (extensionCheck)
{
case MetadataArtifactLoader.ExtensionCheck.Specific:
MetadataArtifactLoader.CheckArtifactExtension(str, validExtension);
break;
case MetadataArtifactLoader.ExtensionCheck.All:
if (!MetadataArtifactLoader.IsValidArtifact(str))
{
throw new MetadataException(Strings.InvalidMetadataPath);
}
break;
}
return((MetadataArtifactLoader) new MetadataArtifactLoaderFile(str, uriRegistry));
}
internal static MetadataArtifactLoader CreateResourceLoader(
string path, ExtensionCheck extensionCheck, string validExtension, ICollection<string> uriRegistry,
MetadataArtifactAssemblyResolver resolver)
{
Debug.Assert(path != null);
Debug.Assert(PathStartsWithResPrefix(path));
// if the supplied path ends with a separator, or contains only one
// segment (i.e., the name of an assembly, or the wildcard character),
// create a composite loader that can extract resources from one or
// more assemblies
//
var createCompositeResLoader = false;
string assemblyName = null;
string resourceName = null;
ParseResourcePath(path, out assemblyName, out resourceName);
createCompositeResLoader = (assemblyName != null) && (resourceName == null || assemblyName.Trim() == wildcard);
ValidateExtension(extensionCheck, validExtension, resourceName);
if (createCompositeResLoader)
{
return new MetadataArtifactLoaderCompositeResource(path, assemblyName, resourceName, uriRegistry, resolver);
}
Debug.Assert(!string.IsNullOrEmpty(resourceName), "we should not get here is the resourceName is null");
var assembly = ResolveAssemblyName(assemblyName, resolver);
return new MetadataArtifactLoaderResource(assembly, resourceName, uriRegistry);
}
/// <summary>
/// Load all resources from a specific assembly.
/// </summary>
/// <param name="fullName">The full name identifying the assembly to
/// load resources from</param>
/// <param name="uriRegistry">The global registry of URIs</param>
/// <param name="resolveAssembly">delegate for resolve the assembly</param>
private static Assembly ResolveAssemblyName(string assemblyName, MetadataArtifactAssemblyResolver resolver)
{
Debug.Assert(resolver != null);
var referenceName = new AssemblyName(assemblyName);
Assembly assembly;
if (!resolver.TryResolveAssemblyReference(referenceName, out assembly))
{
throw new FileNotFoundException(Strings.UnableToResolveAssembly(assemblyName));
}
return assembly;
}
/// <summary>
/// Load all resources from the assembly/assemblies identified in the resource path.
/// </summary>
/// <param name="uriRegistry">The global registry of URIs</param>
/// <param name="resolveAssembly"></param>
/// <returns></returns>
private static List<MetadataArtifactLoaderResource> LoadResources(
string assemblyName, string resourceName, ICollection<string> uriRegistry, MetadataArtifactAssemblyResolver resolver)
{
Debug.Assert(resolver != null);
var loaders = new List<MetadataArtifactLoaderResource>();
Debug.Assert(!string.IsNullOrEmpty(assemblyName));
if (assemblyName == wildcard)
{
foreach (var assembly in resolver.GetWildcardAssemblies())
{
if (AssemblyContainsResource(assembly, ref resourceName))
{
LoadResourcesFromAssembly(assembly, resourceName, uriRegistry, loaders);
}
}
}
else
{
var assembly = ResolveAssemblyName(assemblyName, resolver);
LoadResourcesFromAssembly(assembly, resourceName, uriRegistry, loaders);
}
if (resourceName != null
&& loaders.Count == 0)
{
// they were asking for a specific resource name, and we didn't find it
throw new MetadataException(Strings.UnableToLoadResource);
}
return loaders;
}
// <summary>
// Load all resources from the assembly/assemblies identified in the resource path.
// </summary>
// <param name="uriRegistry"> The global registry of URIs </param>
private static List <MetadataArtifactLoaderResource> LoadResources(
string assemblyName, string resourceName, ICollection <string> uriRegistry, MetadataArtifactAssemblyResolver resolver)
{
DebugCheck.NotNull(resolver);
var loaders = new List <MetadataArtifactLoaderResource>();
DebugCheck.NotEmpty(assemblyName);
if (assemblyName == wildcard)
{
foreach (var assembly in resolver.GetWildcardAssemblies())
{
if (AssemblyContainsResource(assembly, ref resourceName))
{
LoadResourcesFromAssembly(assembly, resourceName, uriRegistry, loaders);
}
}
}
else
{
var assembly = ResolveAssemblyName(assemblyName, resolver);
LoadResourcesFromAssembly(assembly, resourceName, uriRegistry, loaders);
}
if (resourceName != null &&
loaders.Count == 0)
{
// they were asking for a specific resource name, and we didn't find it
throw new MetadataException(Strings.UnableToLoadResource);
}
return(loaders);
}
[ResourceConsumption(ResourceScope.Machine)] //For Create method call. But the paths are not created in this method.
internal static MetadataArtifactLoader CreateCompositeFromFilePaths(
IEnumerable<string> filePaths, string validExtension, MetadataArtifactAssemblyResolver resolver)
{
ExtensionCheck extensionCheck;
if (string.IsNullOrEmpty(validExtension))
{
extensionCheck = ExtensionCheck.All;
}
else
{
extensionCheck = ExtensionCheck.Specific;
}
var loaders = new List<MetadataArtifactLoader>();
// The following set is used to remove duplicate paths from the incoming array
var uriRegistry = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
foreach (var path in filePaths)
{
if (string.IsNullOrEmpty(path))
{
throw new MetadataException(
Strings.NotValidInputPath, new ArgumentException(Strings.ADP_CollectionParameterElementIsNullOrEmpty("filePaths")));
}
var trimedPath = path.Trim();
if (trimedPath.Length > 0)
{
loaders.Add(
Create(
trimedPath,
extensionCheck,
validExtension,
uriRegistry,
resolver)
);
}
}
return Create(loaders);
}
