public bool TryCreateNuGetProject(EnvDTE.Project dteProject, ProjectSystemProviderContext context, out NuGetProject result)
{
if (dteProject == null)
{
throw new ArgumentNullException(nameof(dteProject));
}
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
ThreadHelper.ThrowIfNotOnUIThread();
result = null;
var project = new EnvDTEProjectAdapter(dteProject);
if (!project.IsLegacyCSProjPackageReferenceProject)
{
return(false);
}
// Lazy load the CPS enabled JoinableTaskFactory for the UI.
NuGetUIThreadHelper.SetJoinableTaskFactoryFromService(ProjectServiceAccessor.Value as ProjectSystem.IProjectServiceAccessor);
result = new LegacyCSProjPackageReferenceProject(
project,
VsHierarchyUtility.GetProjectId(dteProject));
return(true);
}
public static async Task MigrateAsync(LegacyCSProjPackageReferenceProject project, string dteProjectFullName)
{
await NuGetUIThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
var projectJsonFilePath = ProjectJsonPathUtilities.GetProjectConfigPath(Path.GetDirectoryName(project.MSBuildProjectPath),
Path.GetFileNameWithoutExtension(project.MSBuildProjectPath));
if (!File.Exists(projectJsonFilePath))
{
throw new FileNotFoundException(string.Format(Strings.Error_FileNotExists, projectJsonFilePath));
}
var packageSpec = JsonPackageSpecReader.GetPackageSpec(
Path.GetFileNameWithoutExtension(project.MSBuildProjectPath),
projectJsonFilePath);
if (packageSpec == null)
{
throw new InvalidOperationException(
string.Format(Strings.Error_InvalidJson, projectJsonFilePath));
}
await MigrateDependenciesAsync(project, packageSpec);
var buildProject = EnvDTEProjectUtility.AsMicrosoftBuildEvaluationProject(dteProjectFullName);
MigrateRuntimes(packageSpec, buildProject);
RemoveProjectJsonReference(buildProject, projectJsonFilePath);
await CreateBackupAsync(project,
projectJsonFilePath);
}
private static async Task CreateBackupAsync(LegacyCSProjPackageReferenceProject project,
string projectJsonFilePath)
{
try
{
await TaskScheduler.Default;
var backupDirectory = Path.Combine(Path.GetDirectoryName(project.MSBuildProjectPath), "Backup");
Directory.CreateDirectory(backupDirectory);
var backupJsonFile = Path.Combine(backupDirectory, Path.GetFileName(projectJsonFilePath));
FileUtility.Move(projectJsonFilePath, backupJsonFile);
var backupProjectFile = Path.Combine(backupDirectory, Path.GetFileName(project.MSBuildProjectPath));
File.Copy(project.MSBuildProjectPath, backupProjectFile);
}
finally
{
await NuGetUIThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
}
}
private static async Task MigrateDependenciesAsync(LegacyCSProjPackageReferenceProject project, PackageSpec packageSpec)
{
ThreadHelper.ThrowIfNotOnUIThread();
if (packageSpec.TargetFrameworks.Count > 1)
{
throw new InvalidOperationException(
string.Format(
CultureInfo.CurrentCulture,
Strings.Error_MultipleFrameworks,
project.MSBuildProjectPath));
}
var dependencies = new List <LibraryDependency>();
foreach (var targetFramework in packageSpec.TargetFrameworks)
{
dependencies.AddRange(targetFramework.Dependencies);
}
dependencies.AddRange(packageSpec.Dependencies);
foreach (var dependency in dependencies)
{
var includeFlags = dependency.IncludeType;
var privateAssetsFlag = dependency.SuppressParent;
var metadataElements = new List <string>();
var metadataValues = new List <string>();
if (includeFlags != LibraryIncludeFlags.All)
{
metadataElements.Add("IncludeAssets");
metadataValues.Add(LibraryIncludeFlagUtils.GetFlagString(includeFlags).Replace(',', ';'));
}
if (privateAssetsFlag != LibraryIncludeFlagUtils.DefaultSuppressParent)
{
metadataElements.Add("PrivateAssets");
metadataValues.Add(LibraryIncludeFlagUtils.GetFlagString(privateAssetsFlag).Replace(',', ';'));
}
await project.InstallPackageWithMetadataAsync(dependency.Name, dependency.LibraryRange.VersionRange, metadataElements, metadataValues);
}
}
