public bool TryResolveAssemblyPaths(CompilationLibrary library, List <string>?assemblies)
        {
            ThrowHelper.ThrowIfNull(library);

            if (_nugetPackageDirectories == null || _nugetPackageDirectories.Length == 0 ||
                !string.Equals(library.Type, "package", StringComparison.OrdinalIgnoreCase))
            {
                return(false);
            }

            foreach (string directory in _nugetPackageDirectories)
            {
                string packagePath;

                if (ResolverUtils.TryResolvePackagePath(_fileSystem, library, directory, out packagePath))
                {
                    if (TryResolveFromPackagePath(_fileSystem, library, packagePath, out IEnumerable <string>?fullPathsFromPackage))
                    {
                        assemblies?.AddRange(fullPathsFromPackage);
                        return(true);
                    }
                }
            }
            return(false);
        }
        public bool TryResolveAssemblyPaths(CompilationLibrary library, List <string> assemblies)
        {
            if (!string.Equals(library.Type, "package", StringComparison.OrdinalIgnoreCase))
            {
                return(false);
            }

            if (!string.IsNullOrEmpty(_packageCacheDirectory))
            {
                var hashSplitterPos = library.Hash.IndexOf('-');
                if (hashSplitterPos <= 0 || hashSplitterPos == library.Hash.Length - 1)
                {
                    throw new InvalidOperationException($"Invalid hash entry '{library.Hash}' for package '{library.Name}'");
                }

                string packagePath;
                if (ResolverUtils.TryResolvePackagePath(library, _packageCacheDirectory, out packagePath))
                {
                    var hashAlgorithm = library.Hash.Substring(0, hashSplitterPos);
                    var cacheHashPath = Path.Combine(packagePath, $"{library.Name}.{library.Version}.nupkg.{hashAlgorithm}");

                    if (File.Exists(cacheHashPath) &&
                        File.ReadAllText(cacheHashPath) == library.Hash.Substring(hashSplitterPos + 1))
                    {
                        assemblies.AddRange(ResolverUtils.ResolveFromPackagePath(library, packagePath));
                        return(true);
                    }
                }
            }
            return(false);
        }
Esempio n. 3
0
        public bool TryResolveAssemblyPaths(CompilationLibrary library, List <string> assemblies)
        {
            if (string.IsNullOrEmpty(_nugetPackageDirectory) ||
                !string.Equals(library.Type, "package", StringComparison.OrdinalIgnoreCase))
            {
                return(false);
            }

            string packagePath;

            if (ResolverUtils.TryResolvePackagePath(_fileSystem, library, _nugetPackageDirectory, out packagePath))
            {
                assemblies.AddRange(ResolverUtils.ResolveFromPackagePath(_fileSystem, library, packagePath));
                return(true);
            }
            return(false);
        }
        public bool TryResolveAssemblyPaths(CompilationLibrary library, List <string> assemblies)
        {
            if (_nugetPackageDirectories == null || _nugetPackageDirectories.Length == 0 ||
                !string.Equals(library.Type, "package", StringComparison.OrdinalIgnoreCase))
            {
                return(false);
            }

            foreach (var directory in _nugetPackageDirectories)
            {
                string packagePath;

                if (ResolverUtils.TryResolvePackagePath(_fileSystem, library, directory, out packagePath))
                {
                    assemblies.AddRange(ResolverUtils.ResolveFromPackagePath(_fileSystem, library, packagePath));
                    return(true);
                }
            }
            return(false);
        }