public async Task <PackageRestoreResult> RestoreAsync()
        {
            var newlyRequested = _requestedPackageReferences
                                 .Select(r => r.Value)
                                 .Where(r => !_resolvedPackageReferences.ContainsKey(r.PackageName.ToLower(CultureInfo.InvariantCulture)))
                                 .ToArray();

            var errors = new List <string>();

            ResolvingErrorReport ReportError = (ErrorReportType errorType, int code, string message) =>
            {
                errors.Add($"PackageManagement {(errorType.IsError ? "Error" : "Warning")} {code} {message}");
            };

            var result =
                await Task.Run(() => {
                return(Resolve(GetPackageManagerLines(), restoreTfm, ReportError));
            });

            if (!result.Success)
            {
                errors.AddRange(result.StdOut);
                return(new PackageRestoreResult(
                           succeeded: false,
                           requestedPackages: newlyRequested,
                           errors: errors));
            }
            else
            {
                var previouslyResolved = _resolvedPackageReferences.Values.ToArray();

                var resolved = GetResolvedPackageReferences(result.Resolutions.Select(r => new FileInfo(r)),
                                                            result.SourceFiles.Select(s => new FileInfo(s)),
                                                            result.Roots.Select(r => new DirectoryInfo(r)));

                foreach (var reference in resolved)
                {
                    _resolvedPackageReferences.TryAdd(reference.PackageName.ToLower(CultureInfo.InvariantCulture), reference);
                }

                var resolvedReferences = _resolvedPackageReferences
                                         .Values
                                         .Except(previouslyResolved)
                                         .ToList();
                return(new PackageRestoreResult(
                           succeeded: true,
                           requestedPackages: newlyRequested,
                           resolvedReferences: _resolvedPackageReferences
                           .Values
                           .Except(previouslyResolved)
                           .ToList()));
            }
        }
        private IResolveDependenciesResult Resolve(IEnumerable <string> packageManagerTextLines, string executionTfm, ResolvingErrorReport reportError)
        {
            IDependencyManagerProvider iDependencyManager = _dependencies.TryFindDependencyManagerByKey(Enumerable.Empty <string>(), "", reportError, "nuget");

            if (iDependencyManager == null)
            {
                // If this happens it is because of a bug in the Dependency provider. or deployment failed to deploy the nuget provider dll.
                // We guarantee the presence of the nuget provider, by shipping it with the notebook product
                throw new InvalidOperationException("Internal error - unable to locate the nuget package manager, please try to reinstall.");
            }

            return(_dependencies.Resolve(iDependencyManager, ".csx", packageManagerTextLines, reportError, executionTfm));
        }