NuGet libraries usage demo for http://lunarfrog.com/blog

NuGetDemo.cs

    public class NuGetDemo
    {
        private readonly ILogger _logger;

        public NuGetDemo()
        {
            _logger = new NuGetLogger();

        }

        public async Task Install()
        {
            var resourceProviders = new List<Lazy<INuGetResourceProvider>>();
            resourceProviders.AddRange(Repository.Provider.GetCoreV3());

            var repositories = new List<SourceRepository>
            {
                new SourceRepository(new PackageSource("https://api.nuget.org/v3/index.json"), resourceProviders)
            };

            var cache = new SourceCacheContext();
            var walkerContext = new RemoteWalkContext();

            foreach (var sourceRepository in repositories)
            {
                var provider = new SourceRepositoryDependencyProvider(sourceRepository, _logger, cache, true);
                walkerContext.RemoteLibraryProviders.Add(provider);
            }

            walkerContext.ProjectLibraryProviders.Add(new ProjectLibraryProvider());

            var fakeLib = new LibraryRange("FakeLib", VersionRange.Parse("1.0.0"), LibraryDependencyTarget.Project);
            var frameworkVersion = FrameworkConstants.CommonFrameworks.Net461;
            var walker = new RemoteDependencyWalker(walkerContext);

            GraphNode<RemoteResolveResult> result = await walker.WalkAsync(
                fakeLib,
                frameworkVersion,
                frameworkVersion.GetShortFolderName(), RuntimeGraph.Empty, true);

            foreach (var node in result.InnerNodes)
            {
                await InstallPackageDependencies(node);
            }
        }

        HashSet<LibraryRange> _installedPackages = new HashSet<LibraryRange>();

        private async Task InstallPackageDependencies(GraphNode<RemoteResolveResult> node)
        {
            foreach (var innerNode in node.InnerNodes)
            {
                if (!_installedPackages.Contains(innerNode.Key))
                {
                    _installedPackages.Add(innerNode.Key);
                    await InstallPackage(innerNode.Item.Data.Match);
                }

                await InstallPackageDependencies(innerNode);
            }
        }

        private async Task InstallPackage(RemoteMatch match)
        {
            var packageIdentity = new PackageIdentity(match.Library.Name, match.Library.Version);

            var versionFolderPathContext = new VersionFolderPathContext(
                packageIdentity,
                @"D:\Temp\MyApp\",
                _logger,
                PackageSaveMode.Defaultv3,
                XmlDocFileSaveMode.None);

            await PackageExtractor.InstallFromSourceAsync(
                stream => match.Provider.CopyToAsync(
                    match.Library,
                    stream,
                    CancellationToken.None),
                versionFolderPathContext,
                CancellationToken.None);
        }
    }

NuGetLogger.cs

    internal class NuGetLogger : ILogger
    {
        public void LogDebug(string data) => Console.WriteLine(data);

        public void LogVerbose(string data) => Console.WriteLine(data);

        public void LogInformation(string data) => Console.WriteLine(data);

        public void LogMinimal(string data) => Console.WriteLine(data);

        public void LogWarning(string data) => Console.WriteLine(data);

        public void LogError(string data) => Console.WriteLine(data);

        public void LogInformationSummary(string data) => Console.WriteLine(data);

        public void LogErrorSummary(string data) => Console.WriteLine(data);
    }

ProjectLibraryProvider.cs

    public class ProjectLibraryProvider : IProjectDependencyProvider
    {
        public bool SupportsType(LibraryDependencyTarget libraryTypeFlag)
        {
            return libraryTypeFlag == LibraryDependencyTarget.Project;
        }

        public Library GetLibrary(LibraryRange libraryRange, NuGetFramework targetFramework)
        {
            return GetLibrary(libraryRange, targetFramework, null);
        }

        public Library GetLibrary(LibraryRange libraryRange, NuGetFramework targetFramework, string rootPath)
        {
            var dependencies = new List<LibraryDependency>();

            dependencies.AddRange( new []
            {
                new LibraryDependency {LibraryRange = new LibraryRange("NuGet.Protocol.Core.v3", VersionRange.Parse("3.0.0"), LibraryDependencyTarget.Package) },
                new LibraryDependency {LibraryRange = new LibraryRange("NuGet.DependencyResolver", VersionRange.Parse("3.0.0"), LibraryDependencyTarget.Package) },
            });

            return new Library
            {
                LibraryRange = libraryRange,
                Identity = new LibraryIdentity
                {
                    Name = libraryRange.Name,
                    Version = NuGetVersion.Parse("1.0.0"),
                    Type = LibraryType.Project,
                },
                Dependencies = dependencies,
                Resolved = true
            };
        }
    }