private static async Task <CompatibilityLevel> GetProjectCompatibilityAsync(UnconfiguredProject project, VersionCompatibilityData compatData)
{
if (project.Capabilities.AppliesTo($"{ProjectCapability.DotNet} & {ProjectCapability.PackageReferences}"))
{
IProjectProperties properties = project.Services.ActiveConfiguredProjectProvider.ActiveConfiguredProject.Services.ProjectPropertiesProvider.GetCommonProperties();
string tfm = await properties.GetEvaluatedPropertyValueAsync("TargetFrameworkMoniker");
if (!string.IsNullOrEmpty(tfm))
{
var fw = new FrameworkName(tfm);
if (fw.Identifier.Equals(".NETCoreApp", StringComparison.OrdinalIgnoreCase))
{
return(GetCompatibilityLevelFromVersion(fw.Version, compatData));
}
else if (fw.Identifier.Equals(".NETFramework", StringComparison.OrdinalIgnoreCase))
{
// The interesting case here is Asp.Net Core on full framework
IImmutableSet <IUnresolvedPackageReference> pkgReferences = await project.Services.ActiveConfiguredProjectProvider.ActiveConfiguredProject.Services.PackageReferences.GetUnresolvedReferencesAsync();
// Look through the package references
foreach (IUnresolvedPackageReference pkgRef in pkgReferences)
{
if (string.Equals(pkgRef.EvaluatedInclude, "Microsoft.AspNetCore.All", StringComparison.OrdinalIgnoreCase) ||
string.Equals(pkgRef.EvaluatedInclude, "Microsoft.AspNetCore", StringComparison.OrdinalIgnoreCase))
{
string verString = await pkgRef.Metadata.GetEvaluatedPropertyValueAsync("Version");
if (!string.IsNullOrWhiteSpace(verString))
{
// This is a semantic version string. We only care about the non-semantic version part
int index = verString.IndexOfAny(Delimiter.PlusAndMinus);
if (index != -1)
{
verString = verString.Substring(0, index);
}
if (Version.TryParse(verString, out Version aspnetVersion))
{
return(GetCompatibilityLevelFromVersion(aspnetVersion, compatData));
}
}
}
}
}
}
}
return(CompatibilityLevel.Recommended);
}
/// <summary>
/// Gets the application manifest kind property
/// </summary>
/// <remarks>
/// The Application Manifest kind's value is one of three possibilities:
/// - It's the value "CustomManifest" which means the user will supply the path to a custom manifest file.
/// - It's the value "NoManifest" which means the application doesn't have a manifest.
/// - It's the value "DefaultManifest" which means that the application will have a default manifest.
///
/// These three values map to two MSBuild properties - ApplicationManifest (for the first case) or NoWin32Manifest
/// which is true for the second case and false or non-existent for the third. If those two properties aren't set
/// then we'll use the stored value (if any) or default to DefaultManifest.
/// </remarks>
public override async Task <string> OnGetEvaluatedPropertyValueAsync(string propertyName, string evaluatedPropertyValue, IProjectProperties defaultProperties)
{
if (!string.IsNullOrEmpty(await defaultProperties.GetEvaluatedPropertyValueAsync(ApplicationManifestMSBuildProperty)))
{
return(CustomManifestValue);
}
string noManifestPropertyValue = await defaultProperties.GetEvaluatedPropertyValueAsync(NoManifestMSBuildProperty);
if (StringComparers.PropertyLiteralValues.Equals(noManifestPropertyValue, "true"))
{
return(NoManifestValue);
}
string?storedValue = _temporaryPropertyStorage.GetPropertyValue(ApplicationManifestKindProperty);
if (!Strings.IsNullOrEmpty(storedValue))
{
return(storedValue);
}
// It doesn't matter if it is set to false or the value is not present. We default to "DefaultManifest" scenario.
return(DefaultManifestValue);
}
public override async Task <string?> OnSetPropertyValueAsync(string propertyName, string unevaluatedPropertyValue, IProjectProperties defaultProperties, IReadOnlyDictionary <string, string>?dimensionalConditions = null)
{
bool isEmptyValue = string.IsNullOrEmpty(unevaluatedPropertyValue);
string relativePath = !isEmptyValue?PathHelper.MakeRelative(_unconfiguredProject, unevaluatedPropertyValue) : string.Empty;
string existingPropertyValue = await defaultProperties.GetEvaluatedPropertyValueAsync(_propertyName);
IProjectItem?existingItem = await GetExistingNoneItemAsync(existingPropertyValue);
// This default was string.Empty but caused issues for files already part of the project via globbing in the AddAsync call. It would not add the necessary
// <PackagePath></PackagePath> node, which causes the value during pack to default to "content;contentFiles" which is not the intended directory.
// See discussion here for more details: https://github.com/dotnet/project-system/issues/7642
string packagePath = @"\";
if (existingItem != null)
{
packagePath = await existingItem.Metadata.GetEvaluatedPropertyValueAsync(PackagePathMetadataName);
// The new filepath is the same as the current. No item changes are required.
if (relativePath.Equals(existingItem.EvaluatedInclude, StringComparisons.Paths))
{
return(CreatePropertyValue(existingItem.EvaluatedInclude, packagePath));
}
}
// None items outside of the project file cannot be updated.
if (existingItem?.PropertiesContext.IsProjectFile ?? false)
{
if (!isEmptyValue)
{
await existingItem.SetUnevaluatedIncludeAsync(relativePath);
}
else
{
await existingItem.RemoveAsync();
}
}
else
{
await _sourceItemsProvider.AddAsync(None.SchemaName, relativePath, new Dictionary <string, string>
{
{ PackMetadataName, bool.TrueString },
{ PackagePathMetadataName, packagePath }
});
}
return(!isEmptyValue?CreatePropertyValue(relativePath, packagePath) : string.Empty);
}
public override async Task <string> OnGetEvaluatedPropertyValueAsync(string propertyName, string evaluatedPropertyValue, IProjectProperties defaultProperties)
{
if (!string.IsNullOrEmpty(evaluatedPropertyValue))
{
return(evaluatedPropertyValue);
}
string noManifestPropertyValue = await defaultProperties.GetEvaluatedPropertyValueAsync(NoManifestMSBuildProperty);
if (noManifestPropertyValue?.Equals("true", StringComparison.InvariantCultureIgnoreCase) == true)
{
return(NoManifestValue);
}
// It doesn't matter if it is set to false or the value is not present. We default to "DefaultManifest" scenario.
return(DefaultManifestValue);
}
public async override Task <string> OnGetEvaluatedPropertyValueAsync(string evaluatedPropertyValue, IProjectProperties defaultProperties)
{
// We do the same check as in the debugger command, so empty string for the local debugger properties means we should perform
// the interception.
var debugCommand = await defaultProperties.GetEvaluatedPropertyValueAsync(WindowsLocalDebugger.LocalDebuggerCommandProperty).ConfigureAwait(false);
var commandArgs = evaluatedPropertyValue;
if (debugCommand == LocalDebuggerCommandValueProvider.DefaultCommand)
{
// Get the path of the executable, and plug it into "exec path original_args"
var executable = await GetExecutablePath().ConfigureAwait(false);
commandArgs = $"exec {executable} {commandArgs}";
}
return(commandArgs);
}
private async Task <Result <string> > GetMacroValueAsync(string name, List <string> evaluationChain)
{
if (_macroCache.TryGetValue(name, out var value))
{
return(value);
}
if (evaluationChain.Contains(name))
{
var chain = string.Join(" -> ", evaluationChain.Append(name).Select(n => "$(" + n + ")"));
return(new Error($"$({evaluationChain[0]}) contains a cycle: {chain}"));
}
evaluationChain.Add(name);
string unevaluated = null;
foreach (var macro in _profileOptions.Macros)
{
if (macro.Name == name)
{
unevaluated = macro.Value;
break;
}
}
if (unevaluated != null)
{
var evalResult = await EvaluateAsync(unevaluated, evaluationChain);
if (!evalResult.TryGetResult(out value, out var error))
{
return(error);
}
}
else
{
value = await _projectProperties.GetEvaluatedPropertyValueAsync(name);
}
_macroCache.Add(name, value);
return(value);
}
private async Task <string> GetTargetCommandAsync(
IProjectProperties properties,
bool validateSettings)
{
// First try "RunCommand" property
string?runCommand = await GetRunCommandAsync(properties);
if (Strings.IsNullOrEmpty(runCommand))
{
// If we're launching for debug purposes, prevent someone F5'ing a class library
if (validateSettings && await IsClassLibraryAsync())
{
throw new ProjectNotRunnableDirectlyException();
}
// Otherwise, fall back to "TargetPath"
runCommand = await properties.GetEvaluatedPropertyValueAsync(ConfigurationGeneral.TargetPathProperty);
}
return(runCommand);
}
public virtual Task <string> GetEvaluatedPropertyValueAsync(string propertyName) => DelegatedProperties.GetEvaluatedPropertyValueAsync(propertyName);
public override Task <string> OnGetEvaluatedPropertyValueAsync(string propertyName, string evaluatedPropertyValue, IProjectProperties defaultProperties)
{
return(defaultProperties.GetEvaluatedPropertyValueAsync(ApplicationManifestMSBuildProperty));
}
public async Task <string> GetApplicationAsync()
{
var application = await userProperties.GetEvaluatedPropertyValueAsync(
ProjectPropertyName.GgpApplication);
return(application);
}
private async Task <string> OnGetPropertyValueAsync(IProjectProperties projectProperties)
{
string warningLevelValue = await projectProperties.GetEvaluatedPropertyValueAsync(WarningLevelPropertyName);
return(warningLevelValue == "0" ? "true" : "false");
}
public override async Task <string> OnGetEvaluatedPropertyValueAsync(string propertyName, string evaluatedPropertyValue, IProjectProperties defaultProperties)
{
string win32Resource = await defaultProperties.GetEvaluatedPropertyValueAsync(Win32ResourceMSBuildProperty);
return(ComputeValue(win32Resource));
}
private async Task <ImmutableSortedSet <int> > GetWarningsAsErrorsIdsAsync(IProjectProperties projectProperties)
{
string warningsAsErrorsValue = await projectProperties.GetEvaluatedPropertyValueAsync(WarningsAsErrorsPropertyName);
return(ParseIdList(warningsAsErrorsValue));
}
private async Task <ImmutableSortedSet <int> > GetNoWarnIdsAsync(IProjectProperties projectProperties)
{
string noWarnValue = await projectProperties.GetEvaluatedPropertyValueAsync(NoWarnPropertyName);
return(ParseIdList(noWarnValue));
}
