public override Task <bool> InstallPackageAsync(PackageIdentity packageIdentity, Stream packageStream,
                                                        INuGetProjectContext nuGetProjectContext, CancellationToken token)
        {
            if (packageIdentity == null)
            {
                throw new ArgumentNullException("packageIdentity");
            }

            if (nuGetProjectContext == null)
            {
                throw new ArgumentNullException("nuGetProjectContext");
            }

            var newPackageReference = new PackageReference(packageIdentity, TargetFramework);
            List <PackageReference> installedPackagesList = GetInstalledPackagesList();
            var packageReferenceWithSameId = installedPackagesList.Where(p => p.PackageIdentity.Id.Equals(packageIdentity.Id, StringComparison.OrdinalIgnoreCase)).FirstOrDefault();

            if (packageReferenceWithSameId != null)
            {
                if (packageReferenceWithSameId.PackageIdentity.Equals(packageIdentity))
                {
                    nuGetProjectContext.Log(MessageLevel.Warning, Strings.PackageAlreadyExistsInPackagesConfig, packageIdentity, Path.GetFileName(FullPath));
                    return(Task.FromResult(false));
                }
                else
                {
                    // Higher version of an installed package is being installed. Remove old and add new
                    installedPackagesList.Remove(packageReferenceWithSameId);
                    installedPackagesList.Add(newPackageReference);
                }
            }
            else
            {
                installedPackagesList.Add(newPackageReference);
            }

            // Create new file or overwrite existing file
            using (var stream = FileSystemUtility.CreateFile(FullPath, nuGetProjectContext))
            {
                var writer = new PackagesConfigWriter(stream);
                foreach (var pr in installedPackagesList)
                {
                    writer.WritePackageEntry(pr);
                }
                writer.Close();
            }
            nuGetProjectContext.Log(MessageLevel.Info, Strings.AddedPackageToPackagesConfig, packageIdentity, Path.GetFileName(FullPath));
            return(Task.FromResult(true));
        }
        public override Task <bool> UninstallPackageAsync(PackageIdentity packageIdentity, INuGetProjectContext nuGetProjectContext, CancellationToken token)
        {
            if (packageIdentity == null)
            {
                throw new ArgumentNullException("packageIdentity");
            }

            if (nuGetProjectContext == null)
            {
                throw new ArgumentNullException("nuGetProjectContext");
            }

            List <PackageReference> installedPackagesList = GetInstalledPackagesList();
            var packageReference = installedPackagesList.Where(p => p.PackageIdentity.Equals(packageIdentity)).FirstOrDefault();

            if (packageReference == null)
            {
                nuGetProjectContext.Log(MessageLevel.Warning, Strings.PackageDoesNotExisttInPackagesConfig, packageIdentity, Path.GetFileName(FullPath));
                return(Task.FromResult(false));
            }

            installedPackagesList.Remove(packageReference);
            if (installedPackagesList.Count > 0)
            {
                // Create new file or overwrite existing file
                using (var stream = FileSystemUtility.CreateFile(FullPath, nuGetProjectContext))
                {
                    var writer = new PackagesConfigWriter(stream);
                    foreach (var pr in installedPackagesList)
                    {
                        writer.WritePackageEntry(pr);
                    }
                    writer.Close();
                }
            }
            else
            {
                FileSystemUtility.DeleteFile(FullPath, nuGetProjectContext);
            }
            nuGetProjectContext.Log(MessageLevel.Info, Strings.RemovedPackageFromPackagesConfig, packageIdentity, Path.GetFileName(FullPath));
            return(Task.FromResult(true));
        }
        private void UpdatePackagesConfig(Project project, string packageName, string packageVersion)
        {
            var packagesFilePath = Path.Combine(project.DirectoryPath, "packages.config");

            IEnumerable <PackageReference> entries = new List <PackageReference>();

            if (File.Exists(packagesFilePath))
            {
                using (var stream = new FileStream(packagesFilePath, FileMode.OpenOrCreate, FileAccess.Read))
                {
                    var reader = new PackagesConfigReader(stream, true);
                    entries = reader.GetPackages();

                    stream.Close();
                }
            }

            File.Delete(packagesFilePath);

            using (var stream = new FileStream(packagesFilePath, FileMode.Create, FileAccess.Write))
            {
                using (var writer = new PackagesConfigWriter(stream))
                {
                    entries.ToList().ForEach(writer.WritePackageEntry);

                    try
                    {
                        writer.WritePackageEntry(packageName, NuGetVersion.Parse(packageVersion), NuGetFramework.AnyFramework);
                    }
                    catch (PackagingException)
                    {
                        _traceWriter.Output("packages.config already contains references");
                    }

                    writer.Close();
                }

                stream.Close();
            }
        }