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