public static Version GetLowestNetCoreVersion(IEnumerable <string> targetFrameworks) { Version targetVersion = null; foreach (string targetFramework in targetFrameworks) { if (TargetFrameworkHelper.IsSupportedFramework(targetFramework, out var frameworkInfo) && frameworkInfo.IsDnx) { Version netCoreVersion; if (frameworkInfo.IsKnownDnx) { netCoreVersion = frameworkInfo.Name == FrameworkInfo.Netstandard ? TargetFrameworkHelper.NetStandardToNetCoreVersionMap[frameworkInfo.Version] : frameworkInfo.Version; } else { // this is a target framework not yet known to the tool, use the latest known netcore version. netCoreVersion = TargetFrameworkHelper.NetStandardToNetCoreVersionMap.Values.LastOrDefault(); } if (targetVersion == null || targetVersion > netCoreVersion) { targetVersion = netCoreVersion; } } } return(targetVersion); }
public async Task <IEnumerable <ProjectDependency> > ResolveProjectReferencesAsync(IEnumerable <ProjectDependency> excludeDependencies, ILogger logger, CancellationToken cancellationToken) { ThrowOnDisposed(); IEnumerable <ProjectDependency> dependencies = null; if (excludeDependencies == null) { excludeDependencies = new List <ProjectDependency>(); } using (var safeLogger = await SafeLogger.WriteStartOperationAsync(logger, "Resolving project references ...").ConfigureAwait(false)) { if (_targetFrameworks.Count == 1 && TargetFrameworkHelper.IsSupportedFramework(this.TargetFramework, out var frameworkInfo) && frameworkInfo.IsDnx) { await this.RestoreAsync(logger, cancellationToken).ConfigureAwait(false); var packageReferences = await ResolvePackageReferencesAsync(logger, cancellationToken).ConfigureAwait(false); var assemblyReferences = await ResolveAssemblyReferencesAsync(logger, cancellationToken).ConfigureAwait(false); dependencies = packageReferences.Union(assemblyReferences).Except(excludeDependencies); } else { await safeLogger.WriteWarningAsync(Shared.Resources.WarningMultiFxOrNoSupportedDnxVersion, logToUI : true).ConfigureAwait(false); dependencies = new List <ProjectDependency>(); } await safeLogger.WriteMessageAsync($"Resolved project reference count: {dependencies.Count()}", logToUI : false).ConfigureAwait(false); } return(dependencies); }
private async Task GenerateProjectAsync(bool keepBootstrapperDir, ILogger logger, CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); var projectFullPath = Path.Combine(this.Options.BootstrapPath.FullName, nameof(SvcutilBootstrapper), SvcutilBootstrapper.ProjectName); if (keepBootstrapperDir) { // creating the directory prevents the bootstrapper project from deleting it as it doesn't own it, files will not be deleted either. Directory.CreateDirectory(Path.GetDirectoryName(projectFullPath)); } // If the target framework was provided, it was validated already when processing params. // Bootstrapping is enabled only for netcoreapp or netstandard TFM, let's check. bool isSupportedTFM = TargetFrameworkHelper.IsSupportedFramework(this.Options.TargetFramework.FullName, out var frameworkInfo); Debug.Assert(frameworkInfo.IsDnx, "The bootstrapper has been enabled for a non-DNX platform!"); ToolConsole.WriteLineIf(ToolConsole.Verbosity >= Verbosity.Verbose, Resource.CreatingProjectMsg); using (await SafeLogger.WriteStartOperationAsync(logger, $"Creating project file: \"{projectFullPath}\"").ConfigureAwait(false)) { var svcutilPkgRef = ProjectDependency.FromAssembly(Path.Combine(Path.GetDirectoryName(Tool.FullPath), Tool.AssemblyName + ".dll")); this.MSBuildProj = await MSBuildProj.DotNetNewAsync(projectFullPath, logger, cancellationToken).ConfigureAwait(false); this.MSBuildProj.AddDependency(svcutilPkgRef); // NOTE: If post v2.0 NetStandard ships a different version from NetCore the table below needs to be updated! var targetFramework = frameworkInfo.FullName; if (isSupportedTFM && frameworkInfo.IsKnownDnx) { if (frameworkInfo.Name == FrameworkInfo.Netstandard) { targetFramework = FrameworkInfo.Netcoreapp + TargetFrameworkHelper.NetStandardToNetCoreVersionMap[frameworkInfo.Version]; } this.MSBuildProj.TargetFramework = targetFramework; } // else // The TFM is unknown: either, it was not provided or it is a version not yet known to the tool, // we will use the default TF from the generated project. } foreach (ProjectDependency dependency in this.Options.References) { this.MSBuildProj.AddDependency(dependency); } if (!string.IsNullOrEmpty(this.Options.RuntimeIdentifier)) { this.MSBuildProj.RuntimeIdentifier = this.Options.RuntimeIdentifier; } // Don't treat warnings as errors so the bootstrapper will succeed as often as possible. this.MSBuildProj.ClearWarningsAsErrors(); await this.MSBuildProj.SaveAsync(logger, cancellationToken).ConfigureAwait(false); }
public static bool ContainsFullFrameworkTarget(IEnumerable <string> targetFrameworks) { foreach (string targetFramework in targetFrameworks) { if (TargetFrameworkHelper.IsSupportedFramework(targetFramework, out var frameworkInfo) && !frameworkInfo.IsDnx) { return(true); } } return(false); }
public static Version GetLowestNetCoreVersion(IEnumerable <string> targetFrameworks) { Version targetVersion = null; foreach (string targetFramework in targetFrameworks) { if (TargetFrameworkHelper.IsSupportedFramework(targetFramework, out var frameworkInfo) && frameworkInfo.IsDnx) { Version netCoreVersion; if (frameworkInfo.IsKnownDnx) { netCoreVersion = frameworkInfo.Name == FrameworkInfo.Netstandard ? TargetFrameworkHelper.NetStandardToNetCoreVersionMap[frameworkInfo.Version] : frameworkInfo.Version; } else { // target framework is not the minumum standard supported netcore version but it is a known shipped netcore version. if (TargetFrameworkHelper.NetCoreVersionReferenceTable.ContainsKey(frameworkInfo.Version)) { netCoreVersion = frameworkInfo.Version; } else { // target framework is not known to the tool, use the latest known netcore version. netCoreVersion = TargetFrameworkHelper.NetCoreVersionReferenceTable.Keys.LastOrDefault(); } } if (targetVersion == null || targetVersion > netCoreVersion) { targetVersion = netCoreVersion; } } } return(targetVersion); }