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 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 (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 static Task <bool> IsTransitiveDependencyAsync(this ITransitiveDependencyIdentifier identifier, string packageName, IProject project, CancellationToken token)
{
if (identifier is null)
{
throw new ArgumentNullException(nameof(identifier));
}
if (string.IsNullOrEmpty(packageName))
{
throw new ArgumentException($"'{nameof(packageName)}' cannot be null or empty.", nameof(packageName));
}
if (project is null)
{
throw new ArgumentNullException(nameof(project));
}
return(identifier.IsTransitiveDependencyAsync(packageName, project.GetProjectTranstiveDependencies(), project.TargetFrameworks, token));
}
public static Task <bool> IsTransitiveDependencyAsync(this ITransitiveDependencyIdentifier identifier, NuGetReference package, IProject project, CancellationToken token)
{
if (identifier is null)
{
throw new ArgumentNullException(nameof(identifier));
}
if (package is null)
{
throw new ArgumentNullException(nameof(package));
}
if (project is null)
{
throw new ArgumentNullException(nameof(project));
}
return(identifier.IsTransitiveDependencyAsync(package, project.GetProjectTranstiveDependencies(), project.TargetFrameworks, token));
}
private async ValueTask <bool> IsWinRt(IProject project, CancellationToken token)
{
return((await _identifier.IsTransitiveDependencyAsync(WinRTPackage, project, token).ConfigureAwait(false)) ||
(await _identifier.IsTransitiveDependencyAsync(WinAppSDKPackage, project, token).ConfigureAwait(false)));
}