public async Task <PackageAnalysisState> AnalyzeAsync(IProject project, PackageAnalysisState state, CancellationToken token)
{
if (state is null)
{
throw new ArgumentNullException(nameof(state));
}
var packageReferences = project.Required().PackageReferences.Where(r => !state.PackagesToRemove.Contains(r));
if (project != null && (project.Components & ProjectComponents.Web) == ProjectComponents.Web
// If the web project doesn't include a reference to the Newtonsoft package, mark it for addition
&& !packageReferences.Any(r => NewtonsoftPackageName.Equals(r.Name, StringComparison.OrdinalIgnoreCase)))
{
var analyzerPackage = await _packageLoader.GetLatestVersionAsync(NewtonsoftPackageName, false, null, token).ConfigureAwait(false);
if (analyzerPackage is not null)
{
_logger.LogInformation("Reference to Newtonsoft package ({NewtonsoftPackageName}, version {NewtonsoftPackageVersion}) needs added", NewtonsoftPackageName, analyzerPackage.Version);
state.PackagesToAdd.Add(analyzerPackage);
}
else
{
_logger.LogWarning("Newtonsoft NuGet package reference cannot be added because the package cannot be found");
}
}
else
{
_logger.LogDebug("Reference to Newtonsoft package ({NewtonsoftPackageName}) already exists", NewtonsoftPackageName);
}
return(state);
}
private async Task AddNetCoreReferences(NuGetPackageMap packageMap, PackageAnalysisState state, IProject project, CancellationToken token)
{
var references = await project.GetNuGetReferencesAsync(token).ConfigureAwait(false);
foreach (var newPackage in packageMap.NetCorePackages)
{
var packageToAdd = newPackage;
if (packageToAdd.HasWildcardVersion)
{
var reference = await _packageLoader.GetLatestVersionAsync(packageToAdd.Name, false, null, token).ConfigureAwait(false);
if (reference is not null)
{
packageToAdd = reference;
}
}
if (!state.PackagesToAdd.Contains(packageToAdd) && !references.PackageReferences.Contains(packageToAdd))
{
_logger.LogInformation("Adding package {PackageName} based on package mapping configuration {PackageMapSet}", packageToAdd.Name, packageMap.PackageSetName);
state.PackagesToAdd.Add(packageToAdd);
}
}
foreach (var frameworkReference in packageMap.NetCoreFrameworkReferences)
{
if (!state.FrameworkReferencesToAdd.Contains(frameworkReference) && !project.FrameworkReferences.Contains(frameworkReference))
{
_logger.LogInformation("Adding framework reference {FrameworkReference} based on package mapping configuration {PackageMapSet}", frameworkReference.Name, packageMap.PackageSetName);
state.FrameworkReferencesToAdd.Add(frameworkReference);
}
}
}
public async Task <PackageAnalysisState> AnalyzeAsync(IProject project, PackageAnalysisState state, CancellationToken token)
{
if (state is null)
{
throw new ArgumentNullException(nameof(state));
}
var references = await project.Required().GetNuGetReferencesAsync(token).ConfigureAwait(false);
var packageReferences = references.PackageReferences.Where(r => !state.PackagesToRemove.Contains(r));
// If the project doesn't include a reference to the analyzer package, mark it for addition
if (!packageReferences.Any(r => AnalyzerPackageName.Equals(r.Name, StringComparison.OrdinalIgnoreCase)))
{
var analyzerPackage = await _packageLoader.GetLatestVersionAsync(AnalyzerPackageName, true, null, token).ConfigureAwait(false);
if (analyzerPackage is not null)
{
_logger.LogInformation("Reference to .NET Upgrade Assistant analyzer package ({AnalyzerPackageName}, version {AnalyzerPackageVersion}) needs added", AnalyzerPackageName, analyzerPackage.Version);
state.PackagesToAdd.Add(analyzerPackage with {
PrivateAssets = "all"
});
}
else
{
_logger.LogWarning(".NET Upgrade Assistant analyzer NuGet package reference cannot be added because the package cannot be found");
}
}
else
{
_logger.LogDebug("Reference to .NET Upgrade Assistant analyzer package ({AnalyzerPackageName}) already exists", AnalyzerPackageName);
}
return(state);
}
public async Task AnalyzeAsync(IProject project, IDependencyAnalysisState state, CancellationToken token)
{
if (project is null)
{
throw new ArgumentNullException(nameof(project));
}
if (state is null)
{
throw new ArgumentNullException(nameof(state));
}
// If the project doesn't include a reference to the analyzer package, mark it for addition
if (!state.Packages.Any(r => AnalyzerPackageName.Equals(r.Name, StringComparison.OrdinalIgnoreCase)))
{
var analyzerPackage = await _packageLoader.GetLatestVersionAsync(AnalyzerPackageName, state.TargetFrameworks, new() { Prerelease = true }, token).ConfigureAwait(false);
if (analyzerPackage is not null)
{
_logger.LogInformation("Reference to .NET Upgrade Assistant analyzer package ({AnalyzerPackageName}, version {AnalyzerPackageVersion}) needs to be added", AnalyzerPackageName, analyzerPackage.Version);
state.Packages.Add(analyzerPackage with {
PrivateAssets = "all"
}, new OperationDetails());
}
else
{
_logger.LogWarning(".NET Upgrade Assistant analyzer NuGet package reference cannot be added because the package cannot be found");
}
}
else
{
_logger.LogDebug("Reference to .NET Upgrade Assistant analyzer package ({AnalyzerPackageName}) already exists", AnalyzerPackageName);
}
}
public async Task AnalyzeAsync(IProject project, IDependencyAnalysisState state, CancellationToken token)
{
if (project is null)
{
throw new ArgumentNullException(nameof(project));
}
if (state is null)
{
throw new ArgumentNullException(nameof(state));
}
if (!project.TargetFrameworks.Any(tfm => tfm.IsNetCore))
{
_logger.LogDebug("None of the tfms match packages from {PackageName}", SystemConfigurationPackageName);
return;
}
if (!project.IsVbClassLibrary())
{
_logger.LogDebug("{Project} is not a VB class library", project.FileInfo);
return;
}
if (await _transitiveIdentifier.IsTransitiveDependencyAsync(SystemConfigurationPackageName, project.NuGetReferences.PackageReferences, project.TargetFrameworks, token).ConfigureAwait(false))
{
_logger.LogDebug("{PackageName} already referenced transitively", SystemConfigurationPackageName);
return;
}
if (!state.Packages.Any(r => SystemConfigurationPackageName.Equals(r.Name, StringComparison.OrdinalIgnoreCase)))
{
var systemConfigurationPackage = await _packageLoader.GetLatestVersionAsync(SystemConfigurationPackageName, state.TargetFrameworks, new(), token).ConfigureAwait(false);
if (systemConfigurationPackage is not null)
{
// Note: Not expecting to see this package added explicitly. This resolves the error but the package is also included in the WindowCompatabilityPack which would make this reference transitively available.
// 1>C:\{ProjectDir}\My Project\Settings.Designer.vb(21,18): error BC30002: Type 'Global.System.Configuration.ApplicationSettingsBase' is not defined.
// 1>C:\{ProjectDir}\My Project\Settings.Designer.vb(57,10): error BC30002: Type 'Global.System.Configuration.UserScopedSettingAttribute' is not defined.
// 1>C:\{ProjectDir}\My Project\Settings.Designer.vb(59,10): error BC30002: Type 'Global.System.Configuration.DefaultSettingValueAttribute' is not defined.
var logMessage = SR.Format("Reference to configuration package ({0}, version {1}) needs to be added in order to resolve compile errors from Settings.Designer.vb", SystemConfigurationPackageName, systemConfigurationPackage.Version);
_logger.LogInformation(logMessage);
state.Packages.Add(systemConfigurationPackage, new OperationDetails {
Details = new[] { logMessage }
});
}
else
{
_logger.LogWarning($"{SystemConfigurationPackageName} NuGet package reference cannot be added because the package cannot be found");
}
}
else
{
_logger.LogDebug("Reference to configuration package ({SystemConfigurationPackageName}) already exists", SystemConfigurationPackageName);
}
}
public async Task <PackageAnalysisState> AnalyzeAsync(IProject project, PackageAnalysisState state, CancellationToken token)
{
if (project is null)
{
throw new ArgumentNullException(nameof(project));
}
if (state is null)
{
throw new ArgumentNullException(nameof(state));
}
var components = await project.GetComponentsAsync(token).ConfigureAwait(false);
// This reference only needs added to ASP.NET Core exes
if (!(components.HasFlag(ProjectComponents.AspNetCore) &&
project.OutputType == ProjectOutputType.Exe &&
!project.TargetFrameworks.Any(tfm => _tfmComparer.Compare(tfm, TargetFrameworkMoniker.NetCoreApp30) < 0)))
{
return(state);
}
var references = await project.GetNuGetReferencesAsync(token).ConfigureAwait(false);
if (references.IsTransitivelyAvailable(NewtonsoftPackageName))
{
_logger.LogDebug("{PackageName} already referenced transitively", NewtonsoftPackageName);
return(state);
}
var packageReferences = references.PackageReferences.Where(r => !state.PackagesToRemove.Contains(r));
if (!packageReferences.Any(r => NewtonsoftPackageName.Equals(r.Name, StringComparison.OrdinalIgnoreCase)))
{
var newtonsoftPackage = await _packageLoader.GetLatestVersionAsync(NewtonsoftPackageName, false, null, token).ConfigureAwait(false);
if (newtonsoftPackage is not null)
{
_logger.LogInformation("Reference to Newtonsoft package ({NewtonsoftPackageName}, version {NewtonsoftPackageVersion}) needs added", NewtonsoftPackageName, newtonsoftPackage.Version);
state.PackagesToAdd.Add(newtonsoftPackage);
}
else
{
_logger.LogWarning("Newtonsoft NuGet package reference cannot be added because the package cannot be found");
}
}
else
{
_logger.LogDebug("Reference to Newtonsoft package ({NewtonsoftPackageName}) already exists", NewtonsoftPackageName);
}
return(state);
}
public async Task AnalyzeAsync(IProject project, IDependencyAnalysisState state, CancellationToken token)
{
if (project is null)
{
throw new ArgumentNullException(nameof(project));
}
if (state is null)
{
throw new ArgumentNullException(nameof(state));
}
var components = await project.GetComponentsAsync(token).ConfigureAwait(false);
// This reference only needs added to ASP.NET Core exes
if (!(components.HasFlag(ProjectComponents.AspNetCore) &&
project.OutputType == ProjectOutputType.Exe &&
!state.TargetFrameworks.Any(tfm => _tfmComparer.Compare(tfm, TargetFrameworkMoniker.NetCoreApp30) < 0)))
{
return;
}
if (await _transitiveIdentifier.IsTransitiveDependencyAsync(NewtonsoftPackageName, project, token).ConfigureAwait(false))
{
_logger.LogDebug("{PackageName} already referenced transitively", NewtonsoftPackageName);
return;
}
if (!state.Packages.Any(r => NewtonsoftPackageName.Equals(r.Name, StringComparison.OrdinalIgnoreCase)))
{
var newtonsoftPackage = await _packageLoader.GetLatestVersionAsync(NewtonsoftPackageName, state.TargetFrameworks, new(), token).ConfigureAwait(false);
if (newtonsoftPackage is not null)
{
var logMessage = SR.Format("Reference to Newtonsoft package ({0}, version {1}) needs to be added", NewtonsoftPackageName, newtonsoftPackage.Version);
_logger.LogInformation(logMessage);
state.Packages.Add(newtonsoftPackage, new OperationDetails {
Risk = BuildBreakRisk.None, Details = new[] { logMessage }
});
}
else
{
_logger.LogWarning("Newtonsoft NuGet package reference cannot be added because the package cannot be found");
}
}
else
{
_logger.LogDebug("Reference to Newtonsoft package ({NewtonsoftPackageName}) already exists", NewtonsoftPackageName);
}
}
public async Task AnalyzeAsync(IProject project, IDependencyAnalysisState state, CancellationToken token)
{
if (!(await project.IsWinUIProjectAsync(token).ConfigureAwait(false)))
{
return;
}
if (project.AllProjectReferences().Any(id => id.Contains(".vcxproj")))
{
var newPackage = new NuGetReference(CsWinRTPackageName, CsWinRTVersion);
state.Packages.Add(newPackage,
new OperationDetails()
{
Risk = BuildBreakRisk.Medium, Details = ImmutableList.Create <string>(newPackage.Name)
});
}
foreach (var package in state.Packages)
{
if (package.Name.StartsWith("Microsoft.Toolkit", StringComparison.Ordinal))
{
var newPackageName = package.Name == "Microsoft.Toolkit" ? "CommunityToolkit.Common"
: package.Name.Replace("Microsoft.Toolkit.Uwp", "CommunityToolkit.WinUI")
.Replace("Microsoft.Toolkit", "CommunityToolkit");
var newPackage = new NuGetReference(newPackageName, package.Version);
if (!await _packageLoader.DoesPackageSupportTargetFrameworksAsync(newPackage, project.TargetFrameworks, token).ConfigureAwait(true))
{
newPackage = await _packageLoader.GetLatestVersionAsync(newPackage.Name, project.TargetFrameworks,
new PackageSearchOptions { LatestMinorAndBuildOnly = false, Prerelease = false, Unlisted = false }, token).ConfigureAwait(true);
if (newPackage == null)
{
_logger.LogWarning($"Unable to find a supported WinUI nuget package for {package.Name}. Skipping this package.");
continue;
}
}
_logger.LogInformation($"UWP Package not supported. Replacing {package.Name} v{package.Version} with {newPackage.Name} v{newPackage.Version}");
state.Packages.Add(newPackage, new OperationDetails()
{
Risk = BuildBreakRisk.Medium, Details = ImmutableList.Create <string>(newPackage.Name)
});
state.Packages.Remove(package, new OperationDetails()
{
Risk = BuildBreakRisk.Medium, Details = ImmutableList.Create <string>(package.Name)
});
}
}
}
public async Task AnalyzeAsync(IProject project, IDependencyAnalysisState state, CancellationToken token)
{
if (project is null)
{
throw new ArgumentNullException(nameof(project));
}
if (state is null)
{
throw new ArgumentNullException(nameof(state));
}
if (!state.TargetFrameworks.Any(tfm => tfm.IsWindows))
{
return;
}
if (await _transitiveIdentifier.IsTransitiveDependencyAsync(PackageName, project, token).ConfigureAwait(false))
{
_logger.LogDebug("{PackageName} already referenced transitively", PackageName);
return;
}
var latestVersion = await _loader.GetLatestVersionAsync(PackageName, state.TargetFrameworks, new(), token).ConfigureAwait(false);
if (latestVersion is null)
{
_logger.LogWarning("Could not find {PackageName}", latestVersion);
return;
}
if (project.NuGetReferences.TryGetPackageByName(PackageName, out var existing))
{
if (_comparer.Compare(existing.Version, latestVersion.Version) >= 0)
{
return;
}
state.Packages.Remove(existing, new OperationDetails());
}
var logMessage = SR.Format("Adding {0} {1} helps with speeding up the upgrade process for Windows-based APIs", PackageName, latestVersion.Version);
_logger.LogInformation(logMessage);
state.Packages.Add(new NuGetReference(PackageName, latestVersion.Version), new OperationDetails {
Details = new[] { logMessage }
});
}
public async Task <PackageAnalysisState> AnalyzeAsync(IProject project, PackageAnalysisState state, CancellationToken token)
{
if (project is null)
{
throw new ArgumentNullException(nameof(project));
}
if (state is null)
{
throw new ArgumentNullException(nameof(state));
}
if (!project.TargetFrameworks.Any(tfm => tfm.IsWindows))
{
return(state);
}
var references = await project.GetNuGetReferencesAsync(token).ConfigureAwait(false);
if (references.IsTransitivelyAvailable(PackageName))
{
_logger.LogDebug("{PackageName} already referenced transitively", PackageName);
return(state);
}
var latestVersion = await _loader.GetLatestVersionAsync(PackageName, false, null, token).ConfigureAwait(false);
if (latestVersion is null)
{
_logger.LogWarning("Could not find {PackageName}", latestVersion);
return(state);
}
if (references.TryGetPackageByName(PackageName, out var existing))
{
if (_comparer.Compare(existing.Version, latestVersion.Version) >= 0)
{
return(state);
}
state.PackagesToRemove.Add(existing);
}
_logger.LogInformation("Adding {PackageName} {Version}", PackageName, latestVersion.Version);
state.PackagesToAdd.Add(new NuGetReference(PackageName, latestVersion.Version));
return(state);
}
public async Task <NuGetReference?> GetLatestVersionAsync(string packageName, IEnumerable <TargetFrameworkMoniker> tfms, PackageSearchOptions options, CancellationToken token)
{
if (_packages.TryGetValue(packageName, out var known))
{
return(known);
}
var latest = await _other.GetLatestVersionAsync(packageName, tfms, options, token).ConfigureAwait(false);
if (latest is not null)
{
_unknownPackages[packageName] = latest.Version;
_logger.LogError("Unexpected version: {Name}, {Version}", latest.Name, latest.Version);
}
return(latest);
}
public async Task <NuGetReference?> GetLatestVersionAsync(string packageName, bool includePreRelease, string[]?packageSources, CancellationToken token)
{
if (_packages.TryGetValue(packageName, out var known))
{
return(known);
}
var latest = await _other.GetLatestVersionAsync(packageName, includePreRelease, packageSources, token).ConfigureAwait(false);
if (latest is not null)
{
_unknownPackages[packageName] = latest.Version;
_logger.LogError("Unexpected version: {Name}, {Version}", latest.Name, latest.Version);
}
return(latest);
}
public async Task <PackageAnalysisState> AnalyzeAsync(IProject project, PackageAnalysisState state, CancellationToken token)
{
if (!project.Required().TFM.IsWindows)
{
return(state);
}
if (state is null)
{
throw new ArgumentNullException(nameof(state));
}
if (project.IsTransitivelyAvailable(PackageName))
{
_logger.LogDebug("{PackageName} already referenced transitively", PackageName);
return(state);
}
var latestVersion = await _loader.GetLatestVersionAsync(PackageName, false, null, token).ConfigureAwait(false);
if (latestVersion is null)
{
_logger.LogWarning("Could not find {PackageName}", latestVersion);
return(state);
}
if (project.TryGetPackageByName(PackageName, out var existing))
{
var version = existing.GetNuGetVersion();
if (version >= latestVersion.GetNuGetVersion())
{
return(state);
}
state.PackagesToRemove.Add(existing);
}
_logger.LogInformation("Adding {PackageName} {Version}", PackageName, latestVersion.Version);
state.PackagesToAdd.Add(new NuGetReference(PackageName, latestVersion.Version));
return(state);
}