/// <summary>
/// HACK: Ensure NuGet packages can be restored for .NET Core 2.0 projects if
/// a preview version of .NET Core 2.0 is installed by mapping the Microsoft.NETCore.App
/// 2.0 package reference to the installed preview version. When MSBuild supports this
/// with the sdk resolver this code can be removed.
///
/// Also ensure NuGet packages are restored for .NET Standard 2.0 projects correctly.
/// By default the NETStandard.Library version 1.6.1 is used which is taken from the
/// SDK files included with Mono's MSBuild. Now the preview version of the
/// NETStandard.Library is used instead. The version used is taken from the
/// BundledNETStandardPackageVersion property from the Microsoft.NETCoreSdk.BundledVersions.props
/// file. This version is different to the preview version of the Microsoft.NETCore.App
/// package reference.
/// </summary>
static void ModifyImportedPackageReference(ProjectPackageReference packageReference, DotNetProject project)
{
if (packageReference.Include == "Microsoft.NETCore.App")
{
string version = packageReference.Metadata.GetValue("Version");
if (version == "2.0")
{
string previewVersion = DotNetCoreRuntime.PreviewNetCore20AppVersion;
if (previewVersion != null)
{
packageReference.Metadata.SetValue("Version", previewVersion);
}
}
}
else if (project.TargetFramework.IsNetStandard20())
{
if (packageReference.Include == "NETStandard.Library")
{
string version = packageReference.Metadata.GetValue("Version");
if (version != null && version.StartsWith("1.", StringComparison.Ordinal))
{
string previewVersion = DotNetCoreSdk.PreviewNetStandard20LibraryVersion;
if (previewVersion != null)
{
packageReference.Metadata.SetValue("Version", previewVersion);
}
}
}
}
}
public void AddKnownItemAttributes(MSBuildProject project)
{
if (HasSdk)
{
ProjectPackageReference.AddKnownItemAttributes(project);
}
}
public async Task SdkConsoleProject_AddPackageReference_VersionWrittenAsAttribute()
{
string solutionFileName = Util.GetSampleProject("dotnetcore-console", "dotnetcore-sdk-console.sln");
var solution = (Solution)await Services.ProjectService.ReadWorkspaceItem(Util.GetMonitor(), solutionFileName);
var project = solution.GetAllProjects().Single();
string projectFileName = project.FileName;
var packageReference = ProjectPackageReference.Create("Test", "1.2.3");
project.Items.Add(packageReference);
await project.SaveAsync(Util.GetMonitor());
// Reload project.
var doc = new XmlDocument();
doc.Load(projectFileName);
var itemGroupElement = (XmlElement)doc.DocumentElement.ChildNodes[1];
var packageReferenceElement = (XmlElement)itemGroupElement.ChildNodes[1];
Assert.AreEqual("PackageReference", packageReferenceElement.Name);
Assert.AreEqual("Test", packageReferenceElement.GetAttribute("Include"));
Assert.AreEqual("1.2.3", packageReferenceElement.GetAttribute("Version"));
Assert.AreEqual(0, packageReferenceElement.ChildNodes.Count);
Assert.IsTrue(packageReferenceElement.IsEmpty);
}
public void Write_Version_WrittenAsAttribute()
{
var p = new MSBuildProject();
p.LoadXml("<Project ToolsVersion=\"15.0\" />");
ProjectPackageReference.AddKnownItemAttributes(p);
var item = p.AddNewItem("PackageReference", "Test");
var packageReference = new TestableProjectPackageReference("Test", "1.2.3");
packageReference.CallWrite(item);
string xml = p.SaveToString();
var doc = new XmlDocument();
doc.LoadXml(xml);
var itemGroupElement = (XmlElement)doc.DocumentElement.ChildNodes[0];
var packageReferenceElement = (XmlElement)itemGroupElement.ChildNodes[0];
Assert.AreEqual("PackageReference", packageReferenceElement.Name);
Assert.AreEqual("1.2.3", packageReferenceElement.GetAttribute("Version"));
Assert.AreEqual(0, packageReferenceElement.ChildNodes.Count);
Assert.IsTrue(packageReferenceElement.IsEmpty);
}
ProjectPackageReference AddDotNetProjectPackageReference(string packageId, string version)
{
var packageReference = ProjectPackageReference.Create(packageId, version);
dotNetProject.Items.Add(packageReference);
return(packageReference);
}
public async Task GetReferences_ThreeProjectReferencesJsonNet_JsonNetReferenceAvailableToReferencingProjects()
{
string solutionFileName = Util.GetSampleProject("TransitiveProjectReferences", "TransitiveProjectReferences.sln");
RestoreNuGetPackages(solutionFileName);
solution = (Solution)await Services.ProjectService.ReadWorkspaceItem(Util.GetMonitor(), solutionFileName);
var projectLibC = solution.FindProjectByName("LibC") as DotNetProject;
var projectLibB = solution.FindProjectByName("LibB") as DotNetProject;
var projectLibA = solution.FindProjectByName("LibA") as DotNetProject;
var packageReference = ProjectPackageReference.Create("Newtonsoft.Json", "10.0.1");
projectLibA.Items.Add(packageReference);
await projectLibA.SaveAsync(Util.GetMonitor());
RestoreNuGetPackages(solutionFileName);
var referencesLibC = await projectLibC.GetReferences(ConfigurationSelector.Default);
var referencesLibB = await projectLibB.GetReferences(ConfigurationSelector.Default);
var referencesLibA = await projectLibA.GetReferences(ConfigurationSelector.Default);
var jsonNetReferenceLibC = referencesLibC.FirstOrDefault(r => r.FilePath.FileName == "Newtonsoft.Json.dll");
var jsonNetReferenceLibB = referencesLibB.FirstOrDefault(r => r.FilePath.FileName == "Newtonsoft.Json.dll");
var jsonNetReferenceLibA = referencesLibA.FirstOrDefault(r => r.FilePath.FileName == "Newtonsoft.Json.dll");
Assert.IsNotNull(jsonNetReferenceLibA);
Assert.IsNotNull(jsonNetReferenceLibB);
Assert.IsNotNull(jsonNetReferenceLibC);
}
PackageDependencyNode(DependenciesNode dependenciesNode, ProjectPackageReference packageReference)
{
this.dependenciesNode = dependenciesNode;
IsTopLevel = true;
name = packageReference.Include;
version = packageReference.Metadata.GetValue("Version", string.Empty);
}
public void IsAtLeastVersion_Range(string versionRange)
{
var reference = ProjectPackageReference.Create("NUnit", versionRange);
Assert.IsTrue(reference.IsAtLeastVersion(new Version(3, 0)));
Assert.IsTrue(reference.IsAtLeastVersion(new Version(3, 2)));
Assert.IsFalse(reference.IsAtLeastVersion(new Version(3, 2, 1)));
Assert.IsFalse(reference.IsAtLeastVersion(new Version(3, 3)));
}
internal static NUnitVersion?GetNUnitVersion(ProjectPackageReference p)
{
if (p.Include.IndexOf("GuiUnit", StringComparison.OrdinalIgnoreCase) != -1)
{
return(NUnitVersion.NUnit2);
}
if (p.Include.IndexOf("nunit", StringComparison.OrdinalIgnoreCase) != -1)
{
return(p.IsAtLeastVersion(new Version(3, 0)) ? NUnitVersion.NUnit3 : NUnitVersion.NUnit2);
}
return(null);
}
public void IsAtLeastVersion_Simple()
{
var reference = ProjectPackageReference.Create("NUnit", "3.2");
Assert.IsTrue(reference.IsAtLeastVersion(new Version(3, 0)));
Assert.IsTrue(reference.IsAtLeastVersion(new Version(3, 2)));
Assert.IsTrue(reference.IsAtLeastVersion(new Version(3, 0, 0)));
Assert.IsTrue(reference.IsAtLeastVersion(new Version(3, 2, 0)));
Assert.IsTrue(reference.IsAtLeastVersion(new Version(3, 2, 0, 0)));
Assert.IsTrue(reference.IsAtLeastVersion(new Version(3, 0, 0, 0)));
Assert.IsFalse(reference.IsAtLeastVersion(new Version(4, 0)));
Assert.IsFalse(reference.IsAtLeastVersion(new Version(3, 3, 0)));
Assert.IsFalse(reference.IsAtLeastVersion(new Version(3, 2, 1)));
}
public void DisposedProject()
{
var project = Services.ProjectService.CreateDotNetProject("C#");
var projectPackageReference = ProjectPackageReference.Create("Test", "1.2.3");
project.Items.Add(projectPackageReference);
project.Dispose();
var packageReference = projectPackageReference.CreatePackageReference();
Assert.IsNull(project.MSBuildProject);
Assert.AreEqual("Test", packageReference.PackageIdentity.Id);
Assert.AreEqual("1.2.3", packageReference.PackageIdentity.Version.ToString());
}
public override async Task <bool> UninstallPackageAsync(
PackageIdentity packageIdentity,
INuGetProjectContext nuGetProjectContext,
CancellationToken token)
{
return(await Runtime.RunInMainThread(() => {
ProjectPackageReference packageReference = project.FindPackageReference(packageIdentity);
if (packageReference != null)
{
project.PackageReferences.Remove(packageReference);
SaveProject();
}
return true;
}));
}
/// <summary>
/// HACK: Handle implicit package versions defined by .NET Core 2.2 SDK.
/// </summary>
static void ModifyImplicitPackageReference(ProjectPackageReference packageReference, DotNetProject project)
{
bool targetLatestRuntimePatch = project.MSBuildProject.EvaluatedProperties.GetValue("TargetLatestRuntimePatch", false);
string targetFrameworkVersion = project.TargetFramework.Id.Version;
foreach (IMSBuildItemEvaluated item in project.MSBuildProject.EvaluatedItems)
{
if (!IsImplicitPackageReferenceMatch(item, packageReference, targetFrameworkVersion))
{
continue;
}
string versionProperty = targetLatestRuntimePatch ? "LatestVersion" : "DefaultVersion";
string version = item.Metadata.GetValue(versionProperty) ?? string.Empty;
packageReference.Metadata.SetValue("Version", version);
return;
}
}
public override async Task <bool> InstallPackageAsync(
PackageIdentity packageIdentity,
DownloadResourceResult downloadResourceResult,
INuGetProjectContext nuGetProjectContext,
CancellationToken token)
{
return(await Runtime.RunInMainThread(async() => {
// Check if this NuGet package is already installed and should be removed.
ProjectPackageReference existingPackageReference = project.FindPackageReference(packageIdentity);
if (existingPackageReference != null)
{
if (ShouldRemoveExistingPackageReference(existingPackageReference, packageIdentity))
{
project.PackageReferences.Remove(existingPackageReference);
}
else
{
nuGetProjectContext.Log(
MessageLevel.Info,
GettextCatalog.GetString("Package '{0}' already installed.", packageIdentity));
return true;
}
}
bool developmentDependency = false;
if (IsNuGetBuildPackagingPackage(packageIdentity))
{
await GlobalPackagesExtractor.Extract(project.ParentSolution, packageIdentity, downloadResourceResult, token);
developmentDependency = true;
GenerateNuGetBuildPackagingTargets(packageIdentity);
}
var packageReference = ProjectPackageReference.Create(packageIdentity);
if (developmentDependency)
{
packageReference.Metadata.SetValue("PrivateAssets", "All");
}
project.PackageReferences.Add(packageReference);
await SaveProject();
return true;
}));
}
public async Task GetReferences_ThreeProjectReferencesJsonNet_JsonNetReferenceAvailableToReferencingProjects()
{
string solutionFileName = Util.GetSampleProject("TransitiveProjectReferences", "TransitiveProjectReferences.sln");
solution = (Solution)await Services.ProjectService.ReadWorkspaceItem(Util.GetMonitor(), solutionFileName);
var projectLibC = solution.FindProjectByName("LibC") as DotNetProject;
var projectLibB = solution.FindProjectByName("LibB") as DotNetProject;
var projectLibA = solution.FindProjectByName("LibA") as DotNetProject;
//string fileName = GetType ().Assembly.Location;
//var reference = ProjectReference.CreateAssemblyFileReference (fileName);
//projectLibA.Items.Add (reference);
var packageReference = ProjectPackageReference.Create("Newtonsoft.Json", "10.0.1");
projectLibA.Items.Add(packageReference);
await projectLibA.SaveAsync(Util.GetMonitor());
CreateNuGetConfigFile(solution.BaseDirectory);
var process = Process.Start("msbuild", $"/t:Restore /p:RestoreDisableParallel=true \"{solutionFileName}\"");
Assert.IsTrue(process.WaitForExit(120000), "Timeout restoring NuGet packages.");
Assert.AreEqual(0, process.ExitCode);
var referencesLibC = await projectLibC.GetReferences(ConfigurationSelector.Default);
var referencesLibB = await projectLibB.GetReferences(ConfigurationSelector.Default);
var referencesLibA = await projectLibA.GetReferences(ConfigurationSelector.Default);
var jsonNetReferenceLibC = referencesLibC.FirstOrDefault(r => r.FilePath.FileName == "Newtonsoft.Json.dll");
var jsonNetReferenceLibB = referencesLibB.FirstOrDefault(r => r.FilePath.FileName == "Newtonsoft.Json.dll");
var jsonNetReferenceLibA = referencesLibA.FirstOrDefault(r => r.FilePath.FileName == "Newtonsoft.Json.dll");
Assert.IsNotNull(jsonNetReferenceLibA);
Assert.IsNotNull(jsonNetReferenceLibB);
Assert.IsNotNull(jsonNetReferenceLibC);
}
public void CanUpdatePackages_HasPackages_PackageReference()
{
var csharpProject = Services.ProjectService.CreateProject("C#") as DotNetProject;
FilePath directory = Util.TmpDir;
csharpProject.FileName = directory.Combine("CanUpdatePackagesProject.csproj");
// No package references.
bool canUpdate = csharpProject.CanUpdatePackages();
bool hasPackages = csharpProject.HasPackages();
Assert.IsFalse(canUpdate);
Assert.IsFalse(hasPackages);
// One package reference.
var packageReference = ProjectPackageReference.Create("Test", "1.0");
csharpProject.Items.Add(packageReference);
canUpdate = csharpProject.CanUpdatePackages();
hasPackages = csharpProject.HasPackages();
Assert.IsTrue(canUpdate);
Assert.IsTrue(hasPackages);
}
public async Task CanUpdatePackages_HasPackages_PackageReferenceFromDirectoryProps()
{
var csharpProject = Services.ProjectService.CreateProject("C#") as DotNetProject;
FilePath directory = Util.CreateTmpDir("DirectoryPropsTest");
csharpProject.FileName = directory.Combine("TestProject.csproj");
var buildPropsFileName = csharpProject.BaseDirectory.Combine("Build.props");
string xml =
"<Project>\n" +
" <ItemGroup>\n" +
" <PackageReference Include=\"Newtonsoft.Json\" Version=\"8.0.1\" />\n" +
" </ItemGroup>\n" +
"</Project>";
File.WriteAllText(buildPropsFileName, xml);
csharpProject.AddImportIfMissing("Build.props", null);
await csharpProject.SaveAsync(Util.GetMonitor());
await csharpProject.MSBuildProject.EvaluateAsync();
// No package references in project. One imported.
bool canUpdate = csharpProject.CanUpdatePackages();
bool hasPackages = csharpProject.HasPackages();
Assert.IsFalse(canUpdate);
Assert.IsTrue(hasPackages);
// One package reference.
var packageReference = ProjectPackageReference.Create("Test", "1.0");
csharpProject.Items.Add(packageReference);
canUpdate = csharpProject.CanUpdatePackages();
Assert.IsTrue(canUpdate);
}
bool IsMatch(ProjectPackageReference packageReference)
{
return(StringComparer.OrdinalIgnoreCase.Equals(packageReference.Include, name));
}
static bool IsImplicitPackageReferenceMatch(IMSBuildItemEvaluated item, ProjectPackageReference packageReference, string targetFrameworkVersion)
{
return(item.Name == "ImplicitPackageReferenceVersion" &&
StringComparer.OrdinalIgnoreCase.Equals(item.Include, packageReference.Include) &&
targetFrameworkVersion == item.Metadata.GetValue("TargetFrameworkVersion"));
}
void AddPackageToProject(string packageId, string packageVersion)
{
var packageReference = ProjectPackageReference.Create(packageId, packageVersion);
dotNetProject.Items.Add(packageReference);
}
bool IsNuGetBuildPackagingReference(ProjectPackageReference packageReference)
{
return(StringComparer.OrdinalIgnoreCase.Equals(packageReference.Include, "NuGet.Build.Packaging"));
}
bool IsMatch(ProjectPackageReference packageReference, PackageIdentity packageIdentity)
{
return(String.Equals(packageReference.Include, packageIdentity.Id, StringComparison.OrdinalIgnoreCase));
}
/// <summary>
/// If the package version is already installed then there is no need to install the
/// NuGet package.
/// </summary>
bool ShouldRemoveExistingPackageReference(ProjectPackageReference packageReference, PackageIdentity packageIdentity)
{
var existingPackageReference = packageReference.ToNuGetPackageReference();
return(!VersionComparer.Default.Equals(existingPackageReference.PackageIdentity.Version, packageIdentity.Version));
}
internal static PackageReference ToNuGetPackageReference(this ProjectPackageReference packageReference)
{
var nugetPackageReference = packageReference.CreatePackageReference();
return(new PackageReference(nugetPackageReference.PackageIdentity, NuGetFramework.Parse("any")));
}
public static PackageDependencyNode Create(
DependenciesNode dependenciesNode,
ProjectPackageReference packageReference)
{
return(new PackageDependencyNode(dependenciesNode, packageReference));
}
