internal static MetadataArtifactLoader CreateResourceLoader(string path, ExtensionCheck extensionCheck, string validExtension, ICollection <string> uriRegistry, MetadataArtifactAssemblyResolver resolver)
        {
            Debug.Assert(path != null);
            Debug.Assert(MetadataArtifactLoader.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
            //
            bool   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");
            Assembly assembly = ResolveAssemblyName(assemblyName, resolver);

            return(new MetadataArtifactLoaderResource(assembly, resourceName, uriRegistry));
        }
        [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)
        {
            Debug.Assert(path != null);
            Debug.Assert(resolver != null);

            // res:// -based artifacts
            //
            if (MetadataArtifactLoader.PathStartsWithResPrefix(path))
            {
                return(MetadataArtifactLoaderCompositeResource.CreateResourceLoader(path, extensionCheck, validExtension, uriRegistry, resolver));
            }

            // Files and Folders
            //
            string normalizedPath = MetadataArtifactLoader.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 (!MetadataArtifactLoader.IsValidArtifact(normalizedPath))
                    {
                        throw EntityUtil.Metadata(Strings.InvalidMetadataPath);
                    }
                    break;
                }

                return(new MetadataArtifactLoaderFile(normalizedPath, uriRegistry));
            }

            throw EntityUtil.Metadata(Strings.InvalidMetadataPath);
        }