private static DependencyGraphSpec ReadProjectDependencyGraph(PackageReferenceArgs packageReferenceArgs)
{
DependencyGraphSpec spec = null;
if (File.Exists(packageReferenceArgs.DgFilePath))
{
spec = DependencyGraphSpec.Load(packageReferenceArgs.DgFilePath);
}
return(spec);
}
public Task <int> ExecuteCommand(PackageReferenceArgs packageReferenceArgs, MSBuildAPIUtility msBuild)
{
packageReferenceArgs.Logger.LogInformation(string.Format(CultureInfo.CurrentCulture,
Strings.Info_RemovePkgRemovingReference,
packageReferenceArgs.PackageDependency.Id,
packageReferenceArgs.ProjectPath));
// Remove reference from the project
var result = msBuild.RemovePackageReference(packageReferenceArgs.ProjectPath,
packageReferenceArgs.PackageDependency);
return(Task.FromResult(result));
}
private static void UpdatePackageVersionIfNeeded(RestoreResultPair restorePreviewResult,
PackageReferenceArgs packageReferenceArgs)
{
// If the user did not specify a version then write the exact resolved version
if (packageReferenceArgs.NoVersion)
{
// Get the package version from the graph
var resolvedVersion = GetPackageVersionFromRestoreResult(restorePreviewResult, packageReferenceArgs);
if (resolvedVersion != null)
{
//Update the packagedependency with the new version
packageReferenceArgs.PackageDependency = new PackageDependency(packageReferenceArgs.PackageDependency.Id,
new VersionRange(resolvedVersion));
}
}
}
public static void Register(CommandLineApplication app, Func <ILogger> getLogger,
Func <IPackageReferenceCommandRunner> getCommandRunner)
{
app.Command("remove", removePkg =>
{
removePkg.Description = Strings.RemovePkg_Description;
removePkg.HelpOption(XPlatUtility.HelpOption);
removePkg.Option(
CommandConstants.ForceEnglishOutputOption,
Strings.ForceEnglishOutput_Description,
CommandOptionType.NoValue);
var id = removePkg.Option(
"--package",
Strings.RemovePkg_PackageIdDescription,
CommandOptionType.SingleValue);
var projectPath = removePkg.Option(
"-p|--project",
Strings.RemovePkg_ProjectPathDescription,
CommandOptionType.SingleValue);
var interactive = removePkg.Option(
"--interactive",
Strings.AddPkg_InteractiveDescription,
CommandOptionType.NoValue);
removePkg.OnExecute(() =>
{
ValidateArgument(id, removePkg.Name);
ValidateArgument(projectPath, removePkg.Name);
ValidateProjectPath(projectPath, removePkg.Name);
var logger = getLogger();
var packageRefArgs = new PackageReferenceArgs(projectPath.Value(), logger)
{
Interactive = interactive.HasValue(),
PackageId = id.Value()
};
var msBuild = new MSBuildAPIUtility(logger);
var removePackageRefCommandRunner = getCommandRunner();
return(removePackageRefCommandRunner.ExecuteCommand(packageRefArgs, msBuild));
});
});
}
private static async Task <RestoreResultPair> PreviewAddPackageReference(PackageReferenceArgs packageReferenceArgs,
DependencyGraphSpec dgSpec,
PackageSpec originalPackageSpec)
{
// Set user agent and connection settings.
XPlatUtility.ConfigureProtocol();
var providerCache = new RestoreCommandProvidersCache();
using (var cacheContext = new SourceCacheContext())
{
cacheContext.NoCache = false;
cacheContext.IgnoreFailedSources = false;
// Pre-loaded request provider containing the graph file
var providers = new List <IPreLoadedRestoreRequestProvider>();
// Create a copy to avoid modifying the original spec which may be shared.
var updatedPackageSpec = originalPackageSpec.Clone();
PackageSpecOperations.AddOrUpdateDependency(updatedPackageSpec, packageReferenceArgs.PackageDependency);
providers.Add(new DependencyGraphSpecRequestProvider(providerCache, dgSpec));
var restoreContext = new RestoreArgs()
{
CacheContext = cacheContext,
LockFileVersion = LockFileFormat.Version,
Log = packageReferenceArgs.Logger,
MachineWideSettings = new XPlatMachineWideSetting(),
GlobalPackagesFolder = packageReferenceArgs.PackageDirectory,
PreLoadedRequestProviders = providers,
Sources = packageReferenceArgs.Sources?.ToList()
};
// Generate Restore Requests. There will always be 1 request here since we are restoring for 1 project.
var restoreRequests = await RestoreRunner.GetRequests(restoreContext);
// Run restore without commit. This will always return 1 Result pair since we are restoring for 1 request.
var restoreResult = await RestoreRunner.RunWithoutCommit(restoreRequests, restoreContext);
return(restoreResult.Single());
}
}
public Task <int> ExecuteCommand(PackageReferenceArgs packageReferenceArgs, MSBuildAPIUtility msBuild)
{
packageReferenceArgs.Logger.LogInformation(string.Format(CultureInfo.CurrentCulture,
Strings.Info_RemovePkgRemovingReference,
packageReferenceArgs.PackageDependency.Id,
packageReferenceArgs.ProjectPath));
var libraryDependency = new LibraryDependency
{
LibraryRange = new LibraryRange(
name: packageReferenceArgs.PackageDependency.Id,
versionRange: packageReferenceArgs.PackageDependency.VersionRange,
typeConstraint: LibraryDependencyTarget.Package)
};
// Remove reference from the project
var result = msBuild.RemovePackageReference(packageReferenceArgs.ProjectPath, libraryDependency);
return(Task.FromResult(result));
}
public Task <int> ExecuteCommand(PackageReferenceArgs packageReferenceArgs, MSBuildAPIUtility msBuild)
{
packageReferenceArgs.Logger.LogInformation(string.Format(CultureInfo.CurrentCulture,
Strings.Info_RemovePkgRemovingReference,
packageReferenceArgs.PackageId,
packageReferenceArgs.ProjectPath));
//Setup the Credential Service - This allows the msbuild sdk resolver to auth if needed.
DefaultCredentialServiceUtility.SetupDefaultCredentialService(packageReferenceArgs.Logger, !packageReferenceArgs.Interactive);
var libraryDependency = new LibraryDependency
{
LibraryRange = new LibraryRange(
name: packageReferenceArgs.PackageId,
versionRange: VersionRange.All,
typeConstraint: LibraryDependencyTarget.Package)
};
// Remove reference from the project
var result = msBuild.RemovePackageReference(packageReferenceArgs.ProjectPath, libraryDependency);
return(Task.FromResult(result));
}
private static NuGetVersion GetPackageVersionFromRestoreResult(RestoreResultPair restorePreviewResult,
PackageReferenceArgs packageReferenceArgs,
IEnumerable <NuGetFramework> UserSpecifiedFrameworks)
{
// Get the restore graphs from the restore result
var restoreGraphs = restorePreviewResult
.Result
.RestoreGraphs;
if (packageReferenceArgs.Frameworks?.Any() == true)
{
// If the user specified frameworks then we get the flattened graphs only from the compatible frameworks.
var userSpecifiedFrameworkSet = new HashSet <NuGetFramework>(
UserSpecifiedFrameworks,
new NuGetFrameworkFullComparer());
restoreGraphs = restoreGraphs
.Where(r => userSpecifiedFrameworkSet.Contains(r.Framework));
}
foreach (var restoreGraph in restoreGraphs)
{
var matchingPackageEntries = restoreGraph
.Flattened
.Select(p => p)
.Where(p => p.Key.Name.Equals(packageReferenceArgs.PackageDependency.Id, StringComparison.OrdinalIgnoreCase));
if (matchingPackageEntries.Any())
{
return(matchingPackageEntries
.First()
.Key
.Version);
}
}
return(null);
}
public static void Register(CommandLineApplication app, Func <ILogger> getLogger,
Func <IPackageReferenceCommandRunner> getCommandRunner)
{
app.Command("add", addpkg =>
{
addpkg.Description = Strings.AddPkg_Description;
addpkg.HelpOption(XPlatUtility.HelpOption);
addpkg.Option(
CommandConstants.ForceEnglishOutputOption,
Strings.ForceEnglishOutput_Description,
CommandOptionType.NoValue);
var id = addpkg.Option(
"--package",
Strings.AddPkg_PackageIdDescription,
CommandOptionType.SingleValue);
var version = addpkg.Option(
"--version",
Strings.AddPkg_PackageVersionDescription,
CommandOptionType.SingleValue);
var dgFilePath = addpkg.Option(
"-d|--dg-file",
Strings.AddPkg_DgFileDescription,
CommandOptionType.SingleValue);
var projectPath = addpkg.Option(
"-p|--project",
Strings.AddPkg_ProjectPathDescription,
CommandOptionType.SingleValue);
var frameworks = addpkg.Option(
"-f|--framework",
Strings.AddPkg_FrameworksDescription,
CommandOptionType.MultipleValue);
var noRestore = addpkg.Option(
"-n|--no-restore",
Strings.AddPkg_NoRestoreDescription,
CommandOptionType.NoValue);
var sources = addpkg.Option(
"-s|--source",
Strings.AddPkg_SourcesDescription,
CommandOptionType.MultipleValue);
var packageDirectory = addpkg.Option(
"--package-directory",
Strings.AddPkg_PackageDirectoryDescription,
CommandOptionType.SingleValue);
var interactive = addpkg.Option(
"--interactive",
Strings.AddPkg_InteractiveDescription,
CommandOptionType.NoValue);
var prerelease = addpkg.Option(
"--prerelease",
Strings.AddPkg_PackagePrerelease,
CommandOptionType.NoValue);
addpkg.OnExecute(() =>
{
ValidateArgument(id, addpkg.Name);
ValidateArgument(projectPath, addpkg.Name);
ValidateProjectPath(projectPath, addpkg.Name);
if (!noRestore.HasValue())
{
ValidateArgument(dgFilePath, addpkg.Name);
}
var logger = getLogger();
var noVersion = !version.HasValue();
var packageVersion = version.HasValue() ? version.Value() : null;
ValidatePrerelease(prerelease.HasValue(), noVersion, addpkg.Name);
var packageRefArgs = new PackageReferenceArgs(projectPath.Value(), logger)
{
Frameworks = CommandLineUtility.SplitAndJoinAcrossMultipleValues(frameworks.Values),
Sources = CommandLineUtility.SplitAndJoinAcrossMultipleValues(sources.Values),
PackageDirectory = packageDirectory.Value(),
NoRestore = noRestore.HasValue(),
NoVersion = noVersion,
DgFilePath = dgFilePath.Value(),
Interactive = interactive.HasValue(),
Prerelease = prerelease.HasValue(),
PackageVersion = packageVersion,
PackageId = id.Values[0]
};
var msBuild = new MSBuildAPIUtility(logger);
var addPackageRefCommandRunner = getCommandRunner();
return(addPackageRefCommandRunner.ExecuteCommand(packageRefArgs, msBuild));
});
});
}
private static async Task <RestoreResultPair> PreviewAddPackageReferenceAsync(PackageReferenceArgs packageReferenceArgs,
DependencyGraphSpec dgSpec)
{
// Set user agent and connection settings.
XPlatUtility.ConfigureProtocol();
var providerCache = new RestoreCommandProvidersCache();
using (var cacheContext = new SourceCacheContext())
{
cacheContext.NoCache = false;
cacheContext.IgnoreFailedSources = false;
// Pre-loaded request provider containing the graph file
var providers = new List <IPreLoadedRestoreRequestProvider>
{
new DependencyGraphSpecRequestProvider(providerCache, dgSpec)
};
var restoreContext = new RestoreArgs()
{
CacheContext = cacheContext,
LockFileVersion = LockFileFormat.Version,
Log = packageReferenceArgs.Logger,
MachineWideSettings = new XPlatMachineWideSetting(),
GlobalPackagesFolder = packageReferenceArgs.PackageDirectory,
PreLoadedRequestProviders = providers,
Sources = packageReferenceArgs.Sources?.ToList()
};
// Generate Restore Requests. There will always be 1 request here since we are restoring for 1 project.
var restoreRequests = await RestoreRunner.GetRequests(restoreContext);
//Setup the Credential Service
DefaultCredentialServiceUtility.SetupDefaultCredentialService(restoreContext.Log, !packageReferenceArgs.Interactive);
// Run restore without commit. This will always return 1 Result pair since we are restoring for 1 request.
var restoreResult = await RestoreRunner.RunWithoutCommit(restoreRequests, restoreContext);
return(restoreResult.Single());
}
}
public async Task <int> ExecuteCommand(PackageReferenceArgs packageReferenceArgs, MSBuildAPIUtility msBuild)
{
packageReferenceArgs.Logger.LogInformation(string.Format(CultureInfo.CurrentCulture,
Strings.Info_AddPkgAddingReference,
packageReferenceArgs.PackageDependency.Id,
packageReferenceArgs.ProjectPath));
if (packageReferenceArgs.NoRestore)
{
packageReferenceArgs.Logger.LogWarning(string.Format(CultureInfo.CurrentCulture,
Strings.Warn_AddPkgWithoutRestore));
var libraryDependency = new LibraryDependency
{
LibraryRange = new LibraryRange(
name: packageReferenceArgs.PackageDependency.Id,
versionRange: packageReferenceArgs.PackageDependency.VersionRange,
typeConstraint: LibraryDependencyTarget.Package)
};
msBuild.AddPackageReference(packageReferenceArgs.ProjectPath, libraryDependency);
return(0);
}
// 1. Get project dg file
packageReferenceArgs.Logger.LogDebug("Reading project Dependency Graph");
var dgSpec = ReadProjectDependencyGraph(packageReferenceArgs);
if (dgSpec == null)
{
// Logging non localized error on debug stream.
packageReferenceArgs.Logger.LogDebug(Strings.Error_NoDgSpec);
throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, Strings.Error_NoDgSpec));
}
packageReferenceArgs.Logger.LogDebug("Project Dependency Graph Read");
var projectFullPath = Path.GetFullPath(packageReferenceArgs.ProjectPath);
var matchingPackageSpecs = dgSpec
.Projects
.Where(p => p.RestoreMetadata.ProjectStyle == ProjectStyle.PackageReference &&
PathUtility.GetStringComparerBasedOnOS().Equals(Path.GetFullPath(p.RestoreMetadata.ProjectPath), projectFullPath))
.ToArray();
// This ensures that the DG specs generated in previous steps contain exactly 1 project with the same path as the project requesting add package.
// Throw otherwise since we cannot proceed further.
if (matchingPackageSpecs.Length != 1)
{
throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture,
Strings.Error_UnsupportedProject,
packageReferenceArgs.PackageDependency.Id,
packageReferenceArgs.ProjectPath));
}
// Parse the user specified frameworks once to avoid re-do's
var userSpecifiedFrameworks = Enumerable.Empty <NuGetFramework>();
if (packageReferenceArgs.Frameworks?.Any() == true)
{
userSpecifiedFrameworks = packageReferenceArgs
.Frameworks
.Select(f => NuGetFramework.Parse(f));
}
var originalPackageSpec = matchingPackageSpecs.FirstOrDefault();
// Create a copy to avoid modifying the original spec which may be shared.
var updatedPackageSpec = originalPackageSpec.Clone();
if (packageReferenceArgs.Frameworks?.Any() == true)
{
// If user specified frameworks then just use them to add the dependency
PackageSpecOperations.AddOrUpdateDependency(updatedPackageSpec,
packageReferenceArgs.PackageDependency,
userSpecifiedFrameworks);
}
else
{
// If the user has not specified a framework, then just add it to all frameworks
PackageSpecOperations.AddOrUpdateDependency(updatedPackageSpec, packageReferenceArgs.PackageDependency, updatedPackageSpec.TargetFrameworks.Select(e => e.FrameworkName));
}
var updatedDgSpec = dgSpec.WithReplacedSpec(updatedPackageSpec).WithoutRestores();
updatedDgSpec.AddRestore(updatedPackageSpec.RestoreMetadata.ProjectUniqueName);
// 2. Run Restore Preview
packageReferenceArgs.Logger.LogDebug("Running Restore preview");
var restorePreviewResult = await PreviewAddPackageReferenceAsync(packageReferenceArgs,
updatedDgSpec);
packageReferenceArgs.Logger.LogDebug("Restore Review completed");
// 3. Process Restore Result
var compatibleFrameworks = new HashSet <NuGetFramework>(
restorePreviewResult
.Result
.CompatibilityCheckResults
.Where(t => t.Success)
.Select(t => t.Graph.Framework), new NuGetFrameworkFullComparer());
if (packageReferenceArgs.Frameworks?.Any() == true)
{
// If the user has specified frameworks then we intersect that with the compatible frameworks.
var userSpecifiedFrameworkSet = new HashSet <NuGetFramework>(
userSpecifiedFrameworks,
new NuGetFrameworkFullComparer());
compatibleFrameworks.IntersectWith(userSpecifiedFrameworkSet);
}
// 4. Write to Project
if (compatibleFrameworks.Count == 0)
{
// Package is compatible with none of the project TFMs
// Do not add a package reference, throw appropriate error
packageReferenceArgs.Logger.LogError(string.Format(CultureInfo.CurrentCulture,
Strings.Error_AddPkgIncompatibleWithAllFrameworks,
packageReferenceArgs.PackageDependency.Id,
packageReferenceArgs.Frameworks?.Any() == true ? Strings.AddPkg_UserSpecified : Strings.AddPkg_All,
packageReferenceArgs.ProjectPath));
return(1);
}
// Ignore the graphs with RID
else if (compatibleFrameworks.Count ==
restorePreviewResult.Result.CompatibilityCheckResults.Where(r => string.IsNullOrEmpty(r.Graph.RuntimeIdentifier)).Count())
{
// Package is compatible with all the project TFMs
// Add an unconditional package reference to the project
packageReferenceArgs.Logger.LogInformation(string.Format(CultureInfo.CurrentCulture,
Strings.Info_AddPkgCompatibleWithAllFrameworks,
packageReferenceArgs.PackageDependency.Id,
packageReferenceArgs.ProjectPath));
// generate a library dependency with all the metadata like Include, Exlude and SuppressParent
var libraryDependency = GenerateLibraryDependency(updatedPackageSpec, packageReferenceArgs, restorePreviewResult, userSpecifiedFrameworks);
msBuild.AddPackageReference(packageReferenceArgs.ProjectPath, libraryDependency);
}
else
{
// Package is compatible with some of the project TFMs
// Add conditional package references to the project for the compatible TFMs
packageReferenceArgs.Logger.LogInformation(string.Format(CultureInfo.CurrentCulture,
Strings.Info_AddPkgCompatibleWithSubsetFrameworks,
packageReferenceArgs.PackageDependency.Id,
packageReferenceArgs.ProjectPath));
var compatibleOriginalFrameworks = originalPackageSpec.RestoreMetadata
.OriginalTargetFrameworks
.Where(s => compatibleFrameworks.Contains(NuGetFramework.Parse(s)));
// generate a library dependency with all the metadata like Include, Exlude and SuppressParent
var libraryDependency = GenerateLibraryDependency(updatedPackageSpec, packageReferenceArgs, restorePreviewResult, userSpecifiedFrameworks);
msBuild.AddPackageReferencePerTFM(packageReferenceArgs.ProjectPath,
libraryDependency,
compatibleOriginalFrameworks);
}
// 5. Commit restore result
await RestoreRunner.CommitAsync(restorePreviewResult, CancellationToken.None);
return(0);
}
private static LibraryDependency GenerateLibraryDependency(
PackageSpec project,
PackageReferenceArgs packageReferenceArgs,
RestoreResultPair restorePreviewResult,
IEnumerable <NuGetFramework> UserSpecifiedFrameworks)
{
// get the package resolved version from restore preview result
var resolvedVersion = GetPackageVersionFromRestoreResult(restorePreviewResult, packageReferenceArgs, UserSpecifiedFrameworks);
// calculate correct package version to write in project file
var version = packageReferenceArgs.PackageDependency.VersionRange;
// If the user did not specify a version then write the exact resolved version
if (packageReferenceArgs.NoVersion)
{
version = new VersionRange(resolvedVersion);
}
// update default packages path if user specified custom package directory
var packagesPath = project.RestoreMetadata.PackagesPath;
if (!string.IsNullOrEmpty(packageReferenceArgs.PackageDirectory))
{
packagesPath = packageReferenceArgs.PackageDirectory;
}
// create a path resolver to get nuspec file of the package
var pathResolver = new FallbackPackagePathResolver(
packagesPath,
project.RestoreMetadata.FallbackFolders);
var info = pathResolver.GetPackageInfo(packageReferenceArgs.PackageDependency.Id, resolvedVersion);
var packageDirectory = info?.PathResolver.GetInstallPath(packageReferenceArgs.PackageDependency.Id, resolvedVersion);
var nuspecFile = info?.PathResolver.GetManifestFileName(packageReferenceArgs.PackageDependency.Id, resolvedVersion);
var nuspecFilePath = Path.GetFullPath(Path.Combine(packageDirectory, nuspecFile));
// read development dependency from nuspec file
var developmentDependency = new NuspecReader(nuspecFilePath).GetDevelopmentDependency();
if (developmentDependency)
{
foreach (var frameworkInfo in project.TargetFrameworks
.OrderBy(framework => framework.FrameworkName.ToString(),
StringComparer.Ordinal))
{
var dependency = frameworkInfo.Dependencies.First(
dep => dep.Name.Equals(packageReferenceArgs.PackageDependency.Id, StringComparison.OrdinalIgnoreCase));
// if suppressParent and IncludeType aren't set by user, then only update those as per dev dependency
if (dependency?.SuppressParent == LibraryIncludeFlagUtils.DefaultSuppressParent &&
dependency?.IncludeType == LibraryIncludeFlags.All)
{
dependency.SuppressParent = LibraryIncludeFlags.All;
dependency.IncludeType = LibraryIncludeFlags.All & ~LibraryIncludeFlags.Compile;
}
if (dependency != null)
{
dependency.LibraryRange.VersionRange = version;
return(dependency);
}
}
}
return(new LibraryDependency
{
LibraryRange = new LibraryRange(
name: packageReferenceArgs.PackageDependency.Id,
versionRange: version,
typeConstraint: LibraryDependencyTarget.Package)
});
}
public async Task <int> ExecuteCommand(PackageReferenceArgs packageReferenceArgs, MSBuildAPIUtility msBuild)
{
packageReferenceArgs.Logger.LogInformation(string.Format(CultureInfo.CurrentCulture,
Strings.Info_AddPkgAddingReference,
packageReferenceArgs.PackageDependency.Id,
packageReferenceArgs.ProjectPath));
if (packageReferenceArgs.NoRestore)
{
packageReferenceArgs.Logger.LogWarning(string.Format(CultureInfo.CurrentCulture,
Strings.Warn_AddPkgWithoutRestore));
msBuild.AddPackageReference(packageReferenceArgs.ProjectPath, packageReferenceArgs.PackageDependency);
return(0);
}
// 1. Get project dg file
packageReferenceArgs.Logger.LogDebug("Reading project Dependency Graph");
var dgSpec = ReadProjectDependencyGraph(packageReferenceArgs);
if (dgSpec == null)
{
throw new Exception(Strings.Error_NoDgSpec);
}
packageReferenceArgs.Logger.LogDebug("Project Dependency Graph Read");
var projectName = dgSpec.Restore.FirstOrDefault();
var originalPackageSpec = dgSpec.GetProjectSpec(projectName);
// Create a copy to avoid modifying the original spec which may be shared.
var updatedPackageSpec = originalPackageSpec.Clone();
PackageSpecOperations.AddOrUpdateDependency(updatedPackageSpec, packageReferenceArgs.PackageDependency);
var updatedDgSpec = dgSpec.WithReplacedSpec(updatedPackageSpec).WithoutRestores();
updatedDgSpec.AddRestore(updatedPackageSpec.RestoreMetadata.ProjectUniqueName);
// 2. Run Restore Preview
packageReferenceArgs.Logger.LogDebug("Running Restore preview");
var restorePreviewResult = await PreviewAddPackageReference(packageReferenceArgs,
updatedDgSpec,
updatedPackageSpec);
packageReferenceArgs.Logger.LogDebug("Restore Review completed");
// 3. Process Restore Result
var compatibleFrameworks = new HashSet <NuGetFramework>(
restorePreviewResult
.Result
.CompatibilityCheckResults
.Where(t => t.Success)
.Select(t => t.Graph.Framework));
if (packageReferenceArgs.Frameworks?.Any() == true)
{
// If the user has specified frameworks then we intersect that with the compatible frameworks.
var userSpecifiedFrameworks = new HashSet <NuGetFramework>(
packageReferenceArgs
.Frameworks
.Select(f => NuGetFramework.Parse(f)));
compatibleFrameworks.IntersectWith(userSpecifiedFrameworks);
}
// 4. Write to Project
if (compatibleFrameworks.Count == 0)
{
// Package is compatible with none of the project TFMs
// Do not add a package reference, throw appropriate error
packageReferenceArgs.Logger.LogError(string.Format(CultureInfo.CurrentCulture,
Strings.Error_AddPkgIncompatibleWithAllFrameworks,
packageReferenceArgs.PackageDependency.Id,
packageReferenceArgs.Frameworks?.Any() == true ? Strings.AddPkg_UserSpecified : Strings.AddPkg_All,
packageReferenceArgs.ProjectPath));
return(1);
}
else if (compatibleFrameworks.Count == restorePreviewResult.Result.CompatibilityCheckResults.Count())
{
// Package is compatible with all the project TFMs
// Add an unconditional package reference to the project
packageReferenceArgs.Logger.LogInformation(string.Format(CultureInfo.CurrentCulture,
Strings.Info_AddPkgCompatibleWithAllFrameworks,
packageReferenceArgs.PackageDependency.Id,
packageReferenceArgs.ProjectPath));
// If the user did not specify a version then update the version to resolved version
UpdatePackageVersionIfNeeded(restorePreviewResult, packageReferenceArgs);
msBuild.AddPackageReference(packageReferenceArgs.ProjectPath,
packageReferenceArgs.PackageDependency);
}
else
{
// Package is compatible with some of the project TFMs
// Add conditional package references to the project for the compatible TFMs
packageReferenceArgs.Logger.LogInformation(string.Format(CultureInfo.CurrentCulture,
Strings.Info_AddPkgCompatibleWithSubsetFrameworks,
packageReferenceArgs.PackageDependency.Id,
packageReferenceArgs.ProjectPath));
var compatibleOriginalFrameworks = originalPackageSpec.RestoreMetadata
.OriginalTargetFrameworks
.Where(s => compatibleFrameworks.Contains(NuGetFramework.Parse(s)));
// If the user did not specify a version then update the version to resolved version
UpdatePackageVersionIfNeeded(restorePreviewResult, packageReferenceArgs);
msBuild.AddPackageReferencePerTFM(packageReferenceArgs.ProjectPath,
packageReferenceArgs.PackageDependency,
compatibleOriginalFrameworks);
}
return(0);
}
