public InstallationDialog(SearchResult item) : base(item.PackageId, width: 80, height: 12) { var cancel = new Button(3, 14, "Cancel") { Clicked = () => Application.RequestStop() }; var install = new Button(10, 14, "Install") { Clicked = () => { var resultText = new TextView { Text = "Installing...", ReadOnly = true, Height = 15 }; var resultDialog = new Dialog( "Install package", width: 80, height: 30, new Button("Ok") { Clicked = () => Application.RequestStop() }); resultDialog.Add(resultText); Application.MainLoop.Invoke(async() => { var dotnet = new Dotnet(); var result = await dotnet.AddPackage(item.PackageId, item.Version); resultText.Text = string.Join("\n", result.Output); }); Application.Run(resultDialog); Application.RequestStop(); } }; var details = $"Downloads: {FormatDownloads(item.TotalDownloads)}\n"; details += $"Tags: {string.Join(", ", item.Tags)}\n"; details += $"\n"; details += $"Description:\n"; details += item.Description; var text = new TextView { Text = details, ReadOnly = true, Height = 5 }; AddButton(cancel); AddButton(install); Add(text); }
private void ConfigureDefaultProps(ITaskSession taskSession) { taskSession.SetBuildVersion(new Version(1, 0, 0, 0)); taskSession.SetDotnetExecutable(Dotnet.FindDotnetExecutable()); var isWindows = RuntimeInformation.IsOSPlatform(OSPlatform.Windows); OSPlatform platform; if (!isWindows) { var isLinux = RuntimeInformation.IsOSPlatform(OSPlatform.Linux); platform = isLinux ? OSPlatform.Linux : OSPlatform.OSX; } else { platform = OSPlatform.Windows; } taskSession.SetOSPlatform(platform); taskSession.SetNodeExecutablePath(IOExtensions.GetNodePath()); taskSession.SetProfileFolder(IOExtensions.GetUserProfileFolder()); taskSession.SetNpmPath(IOExtensions.GetNpmPath()); taskSession.SetBuildDir("build"); taskSession.SetOutputDir("output"); taskSession.SetProductRootDir("."); if (isWindows) { // do windows specific tasks } }
protected override async Task StartAsync(AspNetCoreContext ctx, CancellationToken token) { var info = await Dotnet.RunAsync(ctx, token, ctx.Urls); ctx.ProcessId = info.Pid; ctx.Output = info.Output; }
private static ITemplateEngineHost CreateHost(bool emitTimings) { var preferences = new Dictionary <string, string> { { "prefs:language", "C#" } }; try { string versionString = Dotnet.Version().CaptureStdOut().Execute().StdOut; if (!string.IsNullOrWhiteSpace(versionString)) { preferences["dotnet-cli-version"] = versionString.Trim(); } } catch { } DefaultTemplateEngineHost host = new DefaultTemplateEngineHost(HostIdentifier, HostVersion, CultureInfo.CurrentCulture.Name, preferences, new[] { "dotnetcli" }); if (emitTimings) { host.OnLogTiming = (label, duration, depth) => { string indent = string.Join("", Enumerable.Repeat(" ", depth)); Console.WriteLine($"{indent} {label} {duration.TotalMilliseconds}"); }; } return(host); }
private static void AddProjectReference(DotnetProject project, DotnetProject refProject) { Dotnet.AddProjectToProjectReference(project.Path + project.Name, refProject.Path + refProject.Name) .ForwardStdOut() .ForwardStdErr() .Execute(); }
private static void AddProjectsToSolutionReference(DotnetSolution solution, IReadOnlyList <string> projectPaths) { Dotnet.AddProjectsToSolution($"{solution.Path}{solution.Name}.sln", projectPaths) .ForwardStdOut() .ForwardStdErr() .Execute(); }
public async Task <IEnumerable <MetadataReference> > AddPackage(string packageName, string packageVersion) { var package = await _lazyPackage.ValueAsync(); var currentWorkspace = await package.CreateRoslynWorkspaceForRunAsync(new Budget()); var currentRefs = new HashSet <string>( currentWorkspace.CurrentSolution.Projects.First().MetadataReferences .Select(m => m.Display)); var dotnet = new Dotnet(package.Directory); var result = await dotnet.AddPackage(packageName, packageVersion); if (result.ExitCode != 0) { return(Array.Empty <MetadataReference>()); } var newWorkspace = await package.CreateRoslynWorkspaceForRunAsync(new Budget()); var newRefs = new HashSet <MetadataReference>(newWorkspace.CurrentSolution.Projects.First().MetadataReferences); var resultRefs = newRefs.Where(n => !currentRefs.Contains(n.Display)); return(resultRefs); }
private async Task <IPackage> TryInstallAndLocateTool(PackageDescriptor packageDesciptor) { var dotnet = new Dotnet(); var installationResult = await dotnet.ToolInstall( packageDesciptor.Name, _workingDirectory.GetFullyQualifiedRoot(), _addSource?.ToString()); if (installationResult.ExitCode != 0) { Logger <LocalToolInstallingPackageDiscoveryStrategy> .Log.Warning($"Tool not installed: {packageDesciptor.Name}"); return(null); } var tool = PackageTool.TryCreateFromDirectory(packageDesciptor.Name, _workingDirectory); if (tool != null) { return(await CreatePackage(packageDesciptor, tool)); } return(null); }
public async Task Pack_project_blazor_contents() { var asset = await Create.NetstandardWorkspaceCopy(); var packageName = Path.GetFileNameWithoutExtension(asset.Directory.GetFiles("*.csproj").First().Name); var console = new TestConsole(); await PackCommand.Do(new PackOptions(asset.Directory, enableBlazor : true), console); asset.Directory .GetFiles() .Should() .Contain(f => f.Name.Contains("nupkg")); var dotnet = new Dotnet(asset.Directory); var result = await dotnet.ToolInstall(packageName, asset.Directory, asset.Directory); var exe = Path.Combine(asset.Directory.FullName, packageName); var tool = new WorkspaceServer.WorkspaceFeatures.PackageTool(packageName, asset.Directory); await tool.Prepare(); var projectDirectory = await tool.LocateProjects(); var subDirectories = projectDirectory.GetDirectories(); subDirectories.Should().Contain(d => d.Name == "packTarget"); subDirectories.Should().Contain(d => d.Name == $"runner-{packageName}"); }
private async Task <PackageBuilder> TryInstallAndLocateTool(PackageDescriptor packageDesciptor, Budget budget) { var dotnet = new Dotnet(); var installationResult = await dotnet.ToolInstall( packageDesciptor.Name, _workingDirectory, _addSource?.ToString()); if (installationResult.ExitCode != 0) { Logger <LocalToolInstallingPackageDiscoveryStrategy> .Log.Warning($"Tool not installed: {packageDesciptor.Name}"); return(null); } var tool = await _locator.LocatePackageAsync(packageDesciptor.Name, budget); if (tool != null) { return(CreatePackageBuilder(packageDesciptor, tool)); } return(null); }
public async Task <PackageRestoreResult> Restore() { WriteProjectFile(); var dotnet = new Dotnet(Directory); var result = await dotnet.Execute("msbuild -restore /t:WriteNugetAssemblyPaths"); var resolvedReferences = GetResolvedReferences() .Values .ToArray(); if (result.ExitCode != 0) { return(new PackageRestoreResult( succeeded: false, requestedPackages: _packageReferences.Values, errors: result.Output.Concat(result.Error).ToArray())); } else { return(new PackageRestoreResult( succeeded: true, requestedPackages: _packageReferences.Values, resolvedReferences: resolvedReferences)); } }
private void InstallRemotePackages(IEnumerable <Package> packages, IList <string> nuGetSources) { const string packageRef = @" <PackageReference Include=""{0}"" Version=""{1}"" />"; const string projectFile = @"<Project ToolsVersion=""15.0"" Sdk=""Microsoft.NET.Sdk""> <PropertyGroup> <TargetFrameworks>netcoreapp1.0</TargetFrameworks> </PropertyGroup> <ItemGroup> <PackageReference Remove=""Microsoft.NETCore.App"" /> {0} </ItemGroup> </Project>"; _paths.CreateDirectory(_paths.User.ScratchDir); string proj = Path.Combine(_paths.User.ScratchDir, "restore.csproj"); StringBuilder references = new StringBuilder(); foreach (Package pkg in packages) { references.AppendLine(string.Format(packageRef, pkg.Name, pkg.Version)); } string content = string.Format(projectFile, references.ToString()); _paths.WriteAllText(proj, content); _paths.CreateDirectory(_paths.User.Packages); string restored = Path.Combine(_paths.User.ScratchDir, "Packages"); int additionalSlots = nuGetSources?.Count * 2 ?? 0; string[] restoreArgs = new string[3 + additionalSlots]; restoreArgs[0] = proj; restoreArgs[1] = "--packages"; restoreArgs[2] = restored; if (nuGetSources != null) { for (int i = 0; i < nuGetSources.Count; ++i) { restoreArgs[3 + 2 * i] = "--source"; restoreArgs[4 + 2 * i] = nuGetSources[i]; } } Dotnet.Restore(restoreArgs).ForwardStdOut().ForwardStdErr().Execute(); List <string> newLocalPackages = new List <string>(); foreach (string packagePath in _paths.EnumerateFiles(restored, "*.nupkg", SearchOption.AllDirectories)) { string path = Path.Combine(_paths.User.Packages, Path.GetFileName(packagePath)); _paths.Copy(packagePath, path); newLocalPackages.Add(path); } _paths.DeleteDirectory(_paths.User.ScratchDir); InstallLocalPackages(newLocalPackages); }
public async Task Pack_project_blazor_contents() { var asset = await Create.NetstandardWorkspaceCopy(); var packageName = Path.GetFileNameWithoutExtension(asset.Directory.GetFiles("*.csproj").First().Name); var console = new TestConsole(); await PackCommand.Do(new PackOptions(asset.Directory, enableWasm : true), console); asset.Directory .GetFiles() .Should() .Contain(f => f.Name.Contains("nupkg")); var dotnet = new Dotnet(asset.Directory); var result = await dotnet.ToolInstall(packageName, asset.Directory, new PackageSource(asset.Directory.FullName)); var exe = Path.Combine(asset.Directory.FullName, packageName); var tool = WorkspaceServer.WorkspaceFeatures.PackageTool.TryCreateFromDirectory(packageName, new FileSystemDirectoryAccessor(asset.Directory)); await tool.Prepare(); var wasmDirectory = await tool.LocateWasmAsset(); wasmDirectory.Should().NotBeNull(); }
public async Task <PackageRestoreResult> Restore() { WriteProjectFile(); var dotnet = new Dotnet(Directory); var commandLine = "msbuild -restore /t:WriteNugetAssemblyPaths"; #if DEBUG commandLine += " /bl"; #endif var result = await dotnet.Execute(commandLine); if (result.ExitCode != 0) { return(new PackageRestoreResult( succeeded: false, requestedPackages: _requestedPackageReferences.Values, errors: result.Output.Concat(result.Error).ToArray())); } else { ReadResolvedReferencesFromBuildOutput(); return(new PackageRestoreResult( succeeded: true, requestedPackages: _requestedPackageReferences.Values, resolvedReferences: _resolvedPackageReferences.Values.ToList())); } }
public async Task <AddReferenceResult> AddPackage(string packageName, string packageVersion = null) { var package = await _lazyPackage.ValueAsync(); var currentWorkspace = await package.CreateRoslynWorkspaceForRunAsync(new Budget()); var currentRefs = new HashSet <string>( currentWorkspace.CurrentSolution.Projects.First().MetadataReferences .Select(m => m.Display)); var dotnet = new Dotnet(package.Directory); var result = await dotnet.AddPackage(packageName, packageVersion); if (result.ExitCode != 0) { return(new AddReferenceResult(succeeded: false, detailedErrors: result.DetailedErrors)); } var newWorkspace = await package.CreateRoslynWorkspaceForRunAsync(new Budget()); var newRefs = new HashSet <MetadataReference>(newWorkspace.CurrentSolution.Projects.First().MetadataReferences); return(new AddReferenceResult(succeeded: true, newRefs .Where(n => !currentRefs.Contains(n.Display)) .ToArray(), installedVersion: result.InstalledVersion)); }
private async Task MakeBlazorProject(DirectoryInfo directory, Budget budget) { var dotnet = new Dotnet(directory); var root = directory.FullName; AddRootNamespaceAndBlazorLinkerDirective(); DeleteUnusedFilesFromTemplate(root); AddEmbeddedResourceContentToProject(root); UpdateFileText(root, Path.Combine("wwwroot", "index.html"), "/LocalCodeRunner/blazor-console", $"/LocalCodeRunner/{_name}"); foreach (var packageId in _addPackages) { await dotnet.AddPackage(packageId); } await dotnet.AddPackage("System.CommandLine.Experimental", "0.3.0-alpha.19317.1"); var result = await dotnet.Build("-o runtime /bl", budget : budget); var stuff = string.Concat(string.Join("\n", result.Output), (string.Join("\n", result.Error))); result.ThrowOnFailure(stuff); void AddRootNamespaceAndBlazorLinkerDirective() { UpdateFileText(root, "MLS.Blazor.csproj", "</PropertyGroup>", @"</PropertyGroup> <PropertyGroup> <RootNamespace>MLS.Blazor</RootNamespace> </PropertyGroup> <ItemGroup> <BlazorLinkerDescriptor Include=""Linker.xml"" /> </ItemGroup>"); } }
public bool Process(IEngineEnvironmentSettings settings, IPostAction actionConfig, ICreationResult templateCreationResult, string outputBasePath) { if (templateCreationResult.PrimaryOutputs.Count == 0) { settings.Host.LogMessage(LocalizableStrings.NoPrimaryOutputsToRestore); return(true); } bool allSucceeded = true; foreach (ICreationPath output in templateCreationResult.PrimaryOutputs) { string pathToRestore = !string.IsNullOrEmpty(outputBasePath) ? Path.Combine(outputBasePath, output.Path) : output.Path; Dotnet restoreCommand = Dotnet.Restore(pathToRestore); restoreCommand.CaptureStdOut(); restoreCommand.CaptureStdErr(); settings.Host.LogMessage(string.Format(LocalizableStrings.RunningDotnetRestoreOn, pathToRestore)); Dotnet.Result commandResult = restoreCommand.Execute(); if (commandResult.ExitCode != 0) { settings.Host.LogMessage(LocalizableStrings.RestoreFailed); settings.Host.LogMessage(string.Format(LocalizableStrings.CommandOutput, commandResult.StdOut + Environment.NewLine + Environment.NewLine + commandResult.StdErr)); settings.Host.LogMessage(string.Empty); allSucceeded = false; } else { settings.Host.LogMessage(LocalizableStrings.RestoreSucceeded); } } return(allSucceeded); }
private async Task <IPackage> TryInstallAndLocateTool(PackageDescriptor packageDesciptor) { var dotnet = new Dotnet(); var installationResult = await dotnet.ToolInstall( packageDesciptor.Name, _workingDirectory, _addSource, new Budget()); if (installationResult.ExitCode != 0) { Logger <LocalToolInstallingPackageDiscoveryStrategy> .Log.Warning($"Tool not installed: {packageDesciptor.Name}"); return(null); } var tool = new PackageTool(packageDesciptor.Name, _workingDirectory); if (tool.Exists) { return(await CreatePackage(packageDesciptor, tool)); } return(null); }
private static ITemplateEngineHost CreateHost(string hostIdentifier, string hostVersion) { var preferences = new Dictionary <string, string> { { "prefs:language", "C#" } }; try { string versionString = Dotnet.Version().CaptureStdOut().Execute().StdOut; if (!string.IsNullOrWhiteSpace(versionString)) { preferences["dotnet-cli-version"] = versionString.Trim(); } } catch { } var builtIns = new AssemblyComponentCatalog(new[] { typeof(RunnableProjectGenerator).GetTypeInfo().Assembly, // for assembly: Microsoft.TemplateEngine.Orchestrator.RunnableProjects typeof(NupkgInstallUnitDescriptorFactory).GetTypeInfo().Assembly, // for assembly: Microsoft.TemplateEngine.Edge typeof(DotnetRestorePostActionProcessor).GetTypeInfo().Assembly, // for assembly: Microsoft.TemplateEngine.Cli typeof(NupkgUpdater).GetTypeInfo().Assembly // for assembly: Microsoft.TemplateSearch.Common }); return(new DefaultTemplateEngineHost(hostIdentifier, hostVersion, CultureInfo.CurrentCulture.Name, preferences, builtIns, new[] { "dotnetcli" })); }
public async Task When_the_template_is_installed_verify_works() { var baseDirectory = Create.EmptyWorkspace().Directory; var outputDirectory = baseDirectory.CreateSubdirectory("outputTemplate"); await InstallTemplateAndCreateProject(baseDirectory, outputDirectory); var dotnet = new Dotnet(outputDirectory); //The template targets 3.0 hence verify should run against 3.0 and not 2.1.503 used in the solution directory await dotnet.New("global.json", "--sdk-version 3.0.100-preview6-012264"); var console = new TestConsole(); var directoryAccessor = new FileSystemDirectoryAccessor(outputDirectory); var resultCode = await VerifyCommand.Do( new VerifyOptions(outputDirectory), console, () => directoryAccessor, PackageRegistry.CreateForTryMode(outputDirectory)); console.Out .ToString() .EnforceLF() .Trim() .Should() .Match( $"{outputDirectory}{Path.DirectorySeparatorChar}Readme.md*Line *:*{outputDirectory}{Path.DirectorySeparatorChar}Program.cs (in project {outputDirectory}{Path.DirectorySeparatorChar}{outputDirectory.Name}.csproj)*".EnforceLF()); resultCode.Should().Be(0); }
private static ITemplateEngineHost CreateHost() { var preferences = new Dictionary<string, string> { { "prefs:language", "C#" } }; try { string versionString = Dotnet.Version().CaptureStdOut().Execute().StdOut; if (!string.IsNullOrWhiteSpace(versionString)) { preferences["dotnet-cli-version"] = versionString.Trim(); } } catch { } var builtIns = new AssemblyComponentCatalog(new[] { typeof(RunnableProjectGenerator).GetTypeInfo().Assembly, typeof(ConditionalConfig).GetTypeInfo().Assembly, typeof(NupkgInstallUnitDescriptorFactory).GetTypeInfo().Assembly }); return new DefaultTemplateEngineHost(HostIdentifier, HostVersion, CultureInfo.CurrentCulture.Name, preferences, builtIns, new[] { "dotnetcli" }); }
public virtual async Task Initialize( DirectoryInfo directory, Budget budget = null) { budget = budget ?? new Budget(); var dotnet = new Dotnet(directory); // TODO : workaround to make build work, it requires var result = await dotnet.New("globaljson", "--sdk-version 3.1.300"); result.ThrowOnFailure($"Error creating global.json in {directory.FullName}"); var gbFile = directory.GetFiles("global.json").Single(); var gj = JObject.Parse(File.ReadAllText(gbFile.FullName)); gj["sdk"]["rollForward"] = "latestMinor"; File.WriteAllText(gbFile.FullName, gj.ToString(Formatting.Indented)); result = await dotnet .New(Template, args : $"--name \"{ProjectName}\" --language \"{Language}\" --output \"{directory.FullName}\""); result.ThrowOnFailure($"Error initializing in {directory.FullName}"); if (afterCreate != null) { await afterCreate(directory, budget); } }
private static void RestoreSolution(DotnetSolution solution) { Dotnet.Restore($"{solution.Path}{solution.Name}.sln") .ForwardStdOut() .ForwardStdErr() .Execute(); }
static void Main(string[] args) { Console.WriteLine("Hello World!"); OlderTwentyOne oto = new OlderTwentyOne(); Dotnet dn = new Dotnet(); }
public virtual async Task Build() { await WriteAssemblyInformationFile(); await WriteVersionPropsFile(); await(await Dotnet.Tool()).Run("build", SlnFile, "--configuration", this.Configuration); }
public virtual async Task CodeCoverage() { await Build(); await(await Dotnet.Tool()).Run("test", SlnFile, "--no-build", "--collect:Code Coverage" ); }
public async Task <AddNugetResult> AddPackage( string packageName, string packageVersion = null, string restoreSources = null) { var requestedPackage = new NugetPackageReference(packageName, packageVersion, restoreSources); if (!String.IsNullOrEmpty(packageName) && _nugetPackageReferences.TryGetValue(requestedPackage, out var _)) { return(new AddNugetPackageResult(false, requestedPackage)); } _nugetPackageReferences.Add(requestedPackage, null); WriteProjectFile(); var dotnet = new Dotnet(Directory); var result = await dotnet.Execute("msbuild -restore /t:WriteNugetAssemblyPaths"); if (result.ExitCode != 0) { if (string.IsNullOrEmpty(packageName) && string.IsNullOrEmpty(restoreSources)) { return(new AddNugetRestoreSourcesResult( succeeded: false, requestedPackage, errors: result.Output.Concat(result.Error).ToArray())); } else { return(new AddNugetPackageResult( succeeded: false, requestedPackage, errors: result.Output.Concat(result.Error).ToArray())); } } var addedReferences = GetResolvedNugetReferences() .Values .ToArray(); if (string.IsNullOrEmpty(packageName) && !string.IsNullOrEmpty(restoreSources)) { return(new AddNugetRestoreSourcesResult( succeeded: true, requestedPackage: requestedPackage, addedReferences: addedReferences)); } else { return(new AddNugetPackageResult( succeeded: true, requestedPackage: requestedPackage, addedReferences: addedReferences)); } }
public static async Task <FileInfo> CreateExtensionNupkg( DirectoryInfo projectDir, string code, string packageName, string packageVersion, params FileInfo[] filesToEmbed) { var msbuildFragment = GenerateEmbeddedResourceFragment(filesToEmbed); var extensionCode = filesToEmbed?.Length == 0 ? ExtensionCs(code) : FileProviderExtensionCs(code); projectDir.Populate( extensionCode, ("Extension.csproj", $@" <Project Sdk=""Microsoft.NET.Sdk""> <PropertyGroup> <TargetFramework>net5.0</TargetFramework> <IsPackable>true</IsPackable> <PackageId>{packageName}</PackageId> <PackageVersion>{packageVersion}</PackageVersion> <AssemblyName>{packageName}</AssemblyName> </PropertyGroup> <ItemGroup> <None Include=""$(OutputPath)/{packageName}.dll"" Pack=""true"" PackagePath=""interactive-extensions/dotnet"" /> </ItemGroup> {msbuildFragment} <ItemGroup> <Reference Include=""Microsoft.DotNet.Interactive""> <HintPath>{_microsoftDotNetInteractiveDllPath}</HintPath> </Reference> </ItemGroup> </Project> "), ("global.json", @"{ ""sdk"": { ""version"": ""5.0.100"", ""rollForward"": ""latestMinor"" } } ") ); var dotnet = new Dotnet(projectDir); var pack = await dotnet.Pack(projectDir.FullName); pack.ThrowOnFailure(); return(projectDir .GetFiles("*.nupkg", SearchOption.AllDirectories) .Single()); }
public virtual async Task Test() { await Build(); await(await Dotnet.Tool()).Run("test", SlnFile, "--no-build", "--configuration", Configuration ); }
public static async Task <string> Do(PackOptions options, IConsole console) { console.Out.WriteLine($"Creating package-tool from {options.PackTarget.FullName}"); using (var disposableDirectory = DisposableDirectory.Create()) { var temp = disposableDirectory.Directory; var temp_projects = temp.CreateSubdirectory("projects"); var name = options.PackageName; var temp_projects_build = temp_projects.CreateSubdirectory("build"); options.PackTarget.CopyTo(temp_projects_build); if (options.EnableWasm) { string runnerDirectoryName = $"wasm"; var temp_projects_wasm = temp_projects.CreateSubdirectory(runnerDirectoryName); var temp_mlsblazor = temp.CreateSubdirectory("MLS.Blazor"); await AddBlazorProject(temp_mlsblazor, GetProjectFile(temp_projects_build), name, temp_projects_wasm); } var temp_toolproject = temp.CreateSubdirectory("project"); var archivePath = Path.Combine(temp_toolproject.FullName, "package.zip"); ZipFile.CreateFromDirectory(temp_projects.FullName, archivePath, CompressionLevel.Fastest, includeBaseDirectory: false); console.Out.WriteLine(archivePath); var projectFilePath = Path.Combine(temp_toolproject.FullName, "package-tool.csproj"); var contentFilePath = Path.Combine(temp_toolproject.FullName, "program.cs"); await File.WriteAllTextAsync( projectFilePath, typeof(Program).ReadManifestResource("MLS.Agent.MLS.PackageTool.csproj")); await File.WriteAllTextAsync(contentFilePath, typeof(Program).ReadManifestResource("MLS.Agent.Program.cs")); var dotnet = new Dotnet(temp_toolproject); var result = await dotnet.Build(); result.ThrowOnFailure("Failed to build intermediate project."); var versionArg = ""; if (!string.IsNullOrEmpty(options.Version)) { versionArg = $"/p:PackageVersion={options.Version}"; } result = await dotnet.Pack($@"/p:PackageId=""{name}"" /p:ToolCommandName=""{name}"" {versionArg} ""{projectFilePath}"" -o ""{options.OutputDirectory.FullName}"""); result.ThrowOnFailure("Package build failed."); return(name); } }