public override SolutionItemConfiguration CreateConfiguration(string name) { DotNetProjectConfiguration conf = new DotNetProjectConfiguration(name); string dir; if (conf.Platform.Length == 0) { dir = Path.Combine("bin", conf.Name); } else { dir = Path.Combine(Path.Combine("bin", conf.Platform), conf.Name); } conf.OutputDirectory = String.IsNullOrEmpty(BaseDirectory) ? dir : Path.Combine(BaseDirectory, dir); conf.OutputAssembly = Name; if (LanguageBinding != null) { XmlElement xconf = null; if (!string.IsNullOrEmpty(conf.Platform)) { XmlDocument doc = new XmlDocument(); xconf = doc.CreateElement("Options"); xconf.SetAttribute("Platform", conf.Platform); } conf.CompilationParameters = LanguageBinding.CreateCompilationParameters(xconf); } return(conf); }
public void TestConfigurationMergingKeepOldConfig() { string projectFile = Util.GetSampleProject("test-configuration-merging", "TestConfigurationMerging4.csproj"); DotNetProject p = Services.ProjectService.ReadSolutionItem(Util.GetMonitor(), projectFile) as DotNetProject; Assert.IsNotNull(p); DotNetProjectConfiguration conf = p.Configurations ["Debug|x86"] as DotNetProjectConfiguration; Assert.IsNotNull(conf); Assert.IsTrue(conf.DebugMode); CSharpCompilerParameters cparams = (CSharpCompilerParameters)conf.CompilationParameters; Assert.IsTrue(cparams.UnsafeCode); conf = p.Configurations ["Release|x86"] as DotNetProjectConfiguration; Assert.IsNotNull(conf); Assert.IsFalse(conf.DebugMode); conf.DebugMode = true; cparams = (CSharpCompilerParameters)conf.CompilationParameters; Assert.IsFalse(cparams.UnsafeCode); cparams.UnsafeCode = true; p.Save(Util.GetMonitor()); Assert.AreEqual(Util.GetXmlFileInfoset(p.FileName + ".saved"), Util.GetXmlFileInfoset(p.FileName)); }
protected override void DoExecute(IProgressMonitor monitor, ExecutionContext context, ConfigurationSelector configuration) { DotNetProjectConfiguration dotNetProjectConfig = GetConfiguration(configuration) as DotNetProjectConfiguration; monitor.Log.WriteLine(GettextCatalog.GetString("Running {0} ...", dotNetProjectConfig.CompiledOutputName)); IConsole console = dotNetProjectConfig.ExternalConsole ? context.ExternalConsoleFactory.CreateConsole(!dotNetProjectConfig.PauseConsoleOutput) : context.ConsoleFactory.CreateConsole(!dotNetProjectConfig.PauseConsoleOutput); AggregatedOperationMonitor aggregatedOperationMonitor = new AggregatedOperationMonitor(monitor); try { try { ExecutionCommand executionCommand = CreateExecutionCommand(configuration, dotNetProjectConfig); if (!context.ExecutionHandler.CanExecute(executionCommand)) { monitor.ReportError(GettextCatalog.GetString("Can not execute \"{0}\". The selected execution mode is not supported for .NET projects.", dotNetProjectConfig.CompiledOutputName), null); return; } IProcessAsyncOperation asyncOp = context.ExecutionHandler.Execute(executionCommand, console); aggregatedOperationMonitor.AddOperation(asyncOp); asyncOp.WaitForCompleted(); monitor.Log.WriteLine(GettextCatalog.GetString("The application exited with code: {0}", asyncOp.ExitCode)); } finally { console.Dispose(); aggregatedOperationMonitor.Dispose(); } } catch (Exception ex) { monitor.ReportError(GettextCatalog.GetString("Cannot execute \"{0}\"", dotNetProjectConfig.CompiledOutputName), ex); } }
public async Task TestConfigurationMergingKeepOldConfig() { string projectFile = Util.GetSampleProject("test-configuration-merging", "TestConfigurationMerging4.csproj"); DotNetProject p = await Services.ProjectService.ReadSolutionItem(Util.GetMonitor(), projectFile) as DotNetProject; Assert.IsNotNull(p); DotNetProjectConfiguration conf = p.Configurations ["Debug|x86"] as DotNetProjectConfiguration; Assert.IsNotNull(conf); Assert.IsTrue(conf.DebugSymbols); dynamic cparams = conf.CompilationParameters; Assert.IsTrue(cparams.UnsafeCode); conf = p.Configurations ["Release|x86"] as DotNetProjectConfiguration; Assert.IsNotNull(conf); Assert.IsFalse(conf.DebugSymbols); conf.DebugSymbols = true; cparams = conf.CompilationParameters; Assert.IsFalse(cparams.UnsafeCode); cparams.UnsafeCode = true; await p.SaveAsync(Util.GetMonitor()); Assert.AreEqual(Util.ToSystemEndings(File.ReadAllText(p.FileName + ".saved")), File.ReadAllText(p.FileName)); p.Dispose(); }
public static void InitializeProject(string dir, DotNetProject project, string name) { project.DefaultNamespace = name; DotNetProjectConfiguration pcDebug = project.AddNewConfiguration("Debug") as DotNetProjectConfiguration; pcDebug.DebugType = "full"; pcDebug.OutputDirectory = Path.Combine(dir, "bin/Debug"); pcDebug.OutputAssembly = name; pcDebug.DebugSymbols = true; dynamic csparamsDebug = pcDebug.CompilationParameters; csparamsDebug.DefineSymbols = "DEBUG;TRACE"; csparamsDebug.Optimize = false; DotNetProjectConfiguration pcRelease = project.AddNewConfiguration("Release") as DotNetProjectConfiguration; pcRelease.DebugType = "none"; pcRelease.OutputDirectory = Path.Combine(dir, "bin/Release"); pcRelease.OutputAssembly = name; dynamic csparamsRelease = pcRelease.CompilationParameters; csparamsRelease.DefineSymbols = "TRACE"; csparamsRelease.Optimize = true; string pfile = Path.Combine(dir, name); project.FileName = pfile; }
public void CustomCommands() { DotNetProject p = Services.ProjectService.CreateDotNetProject("C#"); p.Name = "SomeProject"; DotNetProjectConfiguration c = (DotNetProjectConfiguration)p.CreateConfiguration("First"); CustomCommand cmd = new CustomCommand(); cmd.Command = "aa bb cc"; Assert.AreEqual("aa", cmd.GetCommandFile(p, c.Selector)); Assert.AreEqual("bb cc", cmd.GetCommandArgs(p, c.Selector)); cmd.Command = "\"aa bb\" cc dd"; Assert.AreEqual("aa bb", cmd.GetCommandFile(p, c.Selector)); Assert.AreEqual("cc dd", cmd.GetCommandArgs(p, c.Selector)); cmd.Command = "\"aa ${ProjectName}\" cc ${ProjectName}"; Assert.AreEqual("aa SomeProject", cmd.GetCommandFile(p, c.Selector)); Assert.AreEqual("cc SomeProject", cmd.GetCommandArgs(p, c.Selector)); cmd.WorkingDir = NormalizePath("/some/${ProjectName}/place"); Assert.AreEqual(Path.GetFullPath(NormalizePath("/some/SomeProject/place")), (string)cmd.GetCommandWorkingDir(p, c.Selector)); p.Dispose(); }
public void NewConfigurationsHaveAnAssemblyName() { DotNetProject p = new DotNetAssemblyProject("C#"); p.Name = "HiThere"; DotNetProjectConfiguration c = (DotNetProjectConfiguration)p.CreateConfiguration("First"); Assert.AreEqual("HiThere", c.OutputAssembly); }
public async Task TestConfigurationMerging() { string solFile = Util.GetSampleProject("test-configuration-merging", "TestConfigurationMerging.sln"); Solution sol = await Services.ProjectService.ReadWorkspaceItem(Util.GetMonitor(), solFile) as Solution; Assert.IsNotNull(sol); Assert.AreEqual(1, sol.Items.Count); DotNetProject p = sol.Items[0] as DotNetProject; Assert.IsNotNull(p); // Debug config DotNetProjectConfiguration conf = p.Configurations["Debug"] as DotNetProjectConfiguration; Assert.IsNotNull(conf); Assert.AreEqual("Debug", conf.Name); Assert.AreEqual(string.Empty, conf.Platform); dynamic pars = conf.CompilationParameters; Assert.IsNotNull(pars); Assert.AreEqual(2, pars.WarningLevel); pars.WarningLevel = 4; // Release config conf = p.Configurations["Release"] as DotNetProjectConfiguration; Assert.IsNotNull(conf); Assert.AreEqual("Release", conf.Name); Assert.AreEqual(string.Empty, conf.Platform); pars = conf.CompilationParameters; Assert.IsNotNull(pars); Assert.AreEqual("ReleaseMod", Path.GetFileName(conf.OutputDirectory)); Assert.AreEqual(3, pars.WarningLevel); pars.WarningLevel = 1; Assert.AreEqual(1, pars.WarningLevel); conf.DebugType = "full"; conf.DebugSymbols = true; await sol.SaveAsync(Util.GetMonitor()); Assert.AreEqual(1, pars.WarningLevel); string savedFile = Path.Combine(p.BaseDirectory, "TestConfigurationMergingSaved.csproj"); Assert.AreEqual(File.ReadAllText(savedFile), File.ReadAllText(p.FileName)); sol.Dispose(); }
protected internal override bool OnGetCanExecute(ExecutionContext context, ConfigurationSelector configuration) { DotNetProjectConfiguration config = (DotNetProjectConfiguration)GetConfiguration(configuration); if (config == null) { return(false); } ExecutionCommand cmd = CreateExecutionCommand(configuration, config); return((compileTarget == CompileTarget.Exe || compileTarget == CompileTarget.WinExe) && context.ExecutionHandler.CanExecute(cmd)); }
public override FilePath GetOutputFileName(ConfigurationSelector configuration) { DotNetProjectConfiguration conf = (DotNetProjectConfiguration)GetConfiguration(configuration); if (conf != null) { return(conf.CompiledOutputName); } else { return(null); } }
public void TestConfigurationMerging() { string solFile = Util.GetSampleProject("test-configuration-merging", "TestConfigurationMerging.sln"); Solution sol = Services.ProjectService.ReadWorkspaceItem(Util.GetMonitor(), solFile) as Solution; Assert.IsNotNull(sol); Assert.AreEqual(1, sol.Items.Count); DotNetProject p = sol.Items [0] as DotNetProject; Assert.IsNotNull(p); // Debug config DotNetProjectConfiguration conf = p.Configurations ["Debug"] as DotNetProjectConfiguration; Assert.IsNotNull(conf); Assert.AreEqual("Debug", conf.Name); Assert.AreEqual(string.Empty, conf.Platform); CSharpCompilerParameters pars = conf.CompilationParameters as CSharpCompilerParameters; Assert.IsNotNull(pars); Assert.AreEqual(2, pars.WarningLevel); pars.WarningLevel = 4; // Release config conf = p.Configurations ["Release"] as DotNetProjectConfiguration; Assert.IsNotNull(conf); Assert.AreEqual("Release", conf.Name); Assert.AreEqual(string.Empty, conf.Platform); pars = conf.CompilationParameters as CSharpCompilerParameters; Assert.IsNotNull(pars); Assert.AreEqual("ReleaseMod", Path.GetFileName(conf.OutputDirectory)); Assert.AreEqual(3, pars.WarningLevel); pars.WarningLevel = 1; Assert.AreEqual(1, pars.WarningLevel); conf.DebugMode = true; sol.Save(Util.GetMonitor()); Assert.AreEqual(1, pars.WarningLevel); string savedFile = Path.Combine(p.BaseDirectory, "TestConfigurationMergingSaved.csproj"); Assert.AreEqual(Util.GetXmlFileInfoset(savedFile), Util.GetXmlFileInfoset(p.FileName)); }
public override void CopyFrom(ItemConfiguration configuration) { base.CopyFrom(configuration); DotNetProjectConfiguration conf = (DotNetProjectConfiguration)configuration; assembly = conf.assembly; sourcePath = conf.sourcePath; if (ParentItem == null) { SetParentItem(conf.ParentItem); } CompilationParameters = conf.compilationParameters != null?conf.compilationParameters.Clone() : null; signAssembly = conf.signAssembly; assemblyKeyFile = conf.assemblyKeyFile; }
protected override void OnCopyFrom(ItemConfiguration configuration, bool isRename) { base.OnCopyFrom(configuration, isRename); DotNetProjectConfiguration conf = (DotNetProjectConfiguration)configuration; assembly = conf.assembly; sourcePath = conf.sourcePath; if (ParentItem == null) { SetParentItem(conf.ParentItem); } CompilationParameters = conf.compilationParameters != null?conf.compilationParameters.Clone() : null; signAssembly = conf.signAssembly; delaySign = conf.delaySign; assemblyKeyFile = conf.assemblyKeyFile; }
public async Task TestConfigurationMergingChangeMergeToParent5() { // Test for VSTS bug 518933 - Serialization issue with ItemProperty and MergeToProject string projectFile = Util.GetSampleProject("test-configuration-merging", "TestConfigurationMerging11.csproj"); DotNetProject p = await Services.ProjectService.ReadSolutionItem(Util.GetMonitor(), projectFile) as DotNetProject; Assert.IsNotNull(p); DotNetProjectConfiguration debugConf = p.Configurations ["Debug|x86"] as DotNetProjectConfiguration; DotNetProjectConfiguration releaseConf = p.Configurations ["Release|x86"] as DotNetProjectConfiguration; Assert.IsNotNull(debugConf); debugConf.Properties.SetValue("AndroidUseSharedRuntime", false, defaultValue: true, mergeToMainGroup: true); releaseConf.Properties.SetValue("AndroidUseSharedRuntime", false, defaultValue: true, mergeToMainGroup: true); // Release config already has SignAssembly=true, so the property should be merged to main group await p.SaveAsync(Util.GetMonitor()); Assert.AreEqual(Util.ToSystemEndings(File.ReadAllText(p.FileName + ".saved")), File.ReadAllText(p.FileName)); debugConf.Properties.SetValue("AndroidUseSharedRuntime", true, defaultValue: true, mergeToMainGroup: true); releaseConf.Properties.SetValue("AndroidUseSharedRuntime", false, defaultValue: true, mergeToMainGroup: true); // Release config still has SignAssembly=true, so the property should be removed from the main group and // assigned to true in Release configuration. await p.SaveAsync(Util.GetMonitor()); Assert.AreEqual(Util.ToSystemEndings(File.ReadAllText(p.FileName + ".saved2")), File.ReadAllText(p.FileName)); debugConf.Properties.SetValue("AndroidUseSharedRuntime", false, defaultValue: true, mergeToMainGroup: true); releaseConf.Properties.SetValue("AndroidUseSharedRuntime", false, defaultValue: true, mergeToMainGroup: true); await p.SaveAsync(Util.GetMonitor()); Assert.AreEqual(Util.ToSystemEndings(File.ReadAllText(p.FileName + ".saved")), File.ReadAllText(p.FileName)); p.Dispose(); }
public void TestConfigurationMergingChangeNoMergeToParent() { string projectFile = Util.GetSampleProject("test-configuration-merging", "TestConfigurationMerging5.csproj"); DotNetProject p = Services.ProjectService.ReadSolutionItem(Util.GetMonitor(), projectFile) as DotNetProject; Assert.IsNotNull(p); DotNetProjectConfiguration conf = p.Configurations ["Debug|x86"] as DotNetProjectConfiguration; Assert.IsNotNull(conf); Assert.IsTrue(conf.SignAssembly); conf = p.Configurations ["Release|x86"] as DotNetProjectConfiguration; Assert.IsNotNull(conf); Assert.IsTrue(conf.SignAssembly); conf.SignAssembly = false; p.Save(Util.GetMonitor()); Assert.AreEqual(Util.GetXmlFileInfoset(p.FileName + ".saved"), Util.GetXmlFileInfoset(p.FileName)); }
public async Task TestConfigurationMergingDefaultValues() { string projectFile = Util.GetSampleProject("test-configuration-merging", "TestConfigurationMerging3.csproj"); DotNetProject p = await Services.ProjectService.ReadSolutionItem(Util.GetMonitor(), projectFile) as DotNetProject; Assert.IsNotNull(p); DotNetProjectConfiguration conf = p.Configurations["Release|x86"] as DotNetProjectConfiguration; Assert.IsNotNull(conf); dynamic cparams = conf.CompilationParameters; Assert.AreEqual(Microsoft.CodeAnalysis.CSharp.LanguageVersion.Default, cparams.LangVersion); cparams.LangVersion = Microsoft.CodeAnalysis.CSharp.LanguageVersion.CSharp5; Assert.IsTrue(cparams.UnsafeCode); cparams.UnsafeCode = false; await p.SaveAsync(Util.GetMonitor()); Assert.AreEqual(Util.ToSystemEndings(File.ReadAllText(p.FileName + ".saved")), File.ReadAllText(p.FileName)); p.Dispose(); }
public async Task TestConfigurationMergingChangeNoMergeToParent() { string projectFile = Util.GetSampleProject("test-configuration-merging", "TestConfigurationMerging5.csproj"); DotNetProject p = await Services.ProjectService.ReadSolutionItem(Util.GetMonitor(), projectFile) as DotNetProject; Assert.IsNotNull(p); DotNetProjectConfiguration conf = p.Configurations["Debug|x86"] as DotNetProjectConfiguration; Assert.IsNotNull(conf); Assert.IsTrue(conf.SignAssembly); conf = p.Configurations["Release|x86"] as DotNetProjectConfiguration; Assert.IsNotNull(conf); Assert.IsTrue(conf.SignAssembly); conf.SignAssembly = false; await p.SaveAsync(Util.GetMonitor()); Assert.AreEqual(Util.ToSystemEndings(File.ReadAllText(p.FileName + ".saved")), File.ReadAllText(p.FileName)); p.Dispose(); }
protected override bool CheckNeedsBuild(ConfigurationSelector configuration) { if (base.CheckNeedsBuild(configuration)) { return(true); } DotNetProjectConfiguration configObj = (DotNetProjectConfiguration)GetConfiguration(configuration); if (GeneratesDebugInfoFile && configObj != null && configObj.DebugMode) { string file = GetOutputFileName(configuration); if (file != null) { file = TargetRuntime.GetAssemblyDebugInfoFile(file); FileInfo finfo = new FileInfo(file); if (!finfo.Exists) { return(true); } else if (finfo.LastWriteTime < GetLastBuildTime(configuration)) { return(true); } } } foreach (ProjectFile file in Files) { if (file.BuildAction == BuildAction.EmbeddedResource && String.Compare(Path.GetExtension(file.FilePath), ".resx", true) == 0 && MD1DotNetProjectHandler.IsResgenRequired(file.FilePath)) { return(true); } } return(false); }
public virtual Microsoft.CodeAnalysis.ParseOptions CreateParseOptions(DotNetProjectConfiguration configuration) { return(null); }
protected virtual ExecutionCommand CreateExecutionCommand(ConfigurationSelector configSel, DotNetProjectConfiguration configuration) { DotNetExecutionCommand cmd = new DotNetExecutionCommand(configuration.CompiledOutputName); cmd.Arguments = configuration.CommandLineParameters; cmd.WorkingDirectory = Path.GetDirectoryName(configuration.CompiledOutputName); cmd.EnvironmentVariables = new Dictionary <string, string> (configuration.EnvironmentVariables); cmd.TargetRuntime = TargetRuntime; cmd.UserAssemblyPaths = GetUserAssemblyPaths(configSel); return(cmd); }
public DotNetProject(string languageName, ProjectCreateInformation projectCreateInfo, XmlElement projectOptions) : this(languageName) { if ((projectOptions != null) && (projectOptions.Attributes["Target"] != null)) { CompileTarget = (CompileTarget)Enum.Parse(typeof(CompileTarget), projectOptions.Attributes["Target"].Value); } else if (IsLibraryBasedProjectType) { CompileTarget = CompileTarget.Library; } if (this.LanguageBinding != null) { LanguageParameters = languageBinding.CreateProjectParameters(projectOptions); bool externalConsole = false; string platform = null; if (projectOptions != null) { projectOptions.SetAttribute("DefineDebug", "True"); if (!projectOptions.HasAttribute("Platform")) { // Clone the element since we are going to change it platform = GetDefaultTargetPlatform(projectCreateInfo); projectOptions = (XmlElement)projectOptions.CloneNode(true); projectOptions.SetAttribute("Platform", platform); } else { platform = projectOptions.GetAttribute("Platform"); } if (projectOptions.GetAttribute("ExternalConsole") == "True") { externalConsole = true; } } string platformSuffix = string.IsNullOrEmpty(platform) ? string.Empty : "|" + platform; DotNetProjectConfiguration configDebug = CreateConfiguration("Debug" + platformSuffix) as DotNetProjectConfiguration; configDebug.CompilationParameters = languageBinding.CreateCompilationParameters(projectOptions); configDebug.DebugMode = true; configDebug.ExternalConsole = externalConsole; configDebug.PauseConsoleOutput = externalConsole; Configurations.Add(configDebug); DotNetProjectConfiguration configRelease = CreateConfiguration("Release" + platformSuffix) as DotNetProjectConfiguration; if (projectOptions != null) { projectOptions.SetAttribute("DefineDebug", "False"); } configRelease.CompilationParameters = languageBinding.CreateCompilationParameters(projectOptions); configRelease.DebugMode = false; configRelease.ExternalConsole = externalConsole; configRelease.PauseConsoleOutput = externalConsole; Configurations.Add(configRelease); } if ((projectOptions != null) && (projectOptions.Attributes["TargetFrameworkVersion"] != null)) { targetFrameworkVersion = projectOptions.Attributes["TargetFrameworkVersion"].Value; } string binPath; if (projectCreateInfo != null) { Name = projectCreateInfo.ProjectName; binPath = projectCreateInfo.BinPath; defaultNamespace = SanitisePotentialNamespace(projectCreateInfo.ProjectName); } else { binPath = "."; } foreach (DotNetProjectConfiguration dotNetProjectConfig in Configurations) { dotNetProjectConfig.OutputDirectory = Path.Combine(binPath, dotNetProjectConfig.Name); if ((projectOptions != null) && (projectOptions.Attributes["PauseConsoleOutput"] != null)) { dotNetProjectConfig.PauseConsoleOutput = Boolean.Parse(projectOptions.Attributes["PauseConsoleOutput"].Value); } if (projectCreateInfo != null) { dotNetProjectConfig.OutputAssembly = projectCreateInfo.ProjectName; } } }
void PopulateSupportFileList(FileCopySet list, ConfigurationSelector configuration, int referenceDistance) { if (referenceDistance < 2) { base.PopulateSupportFileList(list, configuration); } //rename the app.config file FileCopySet.Item appConfig = list.Remove("app.config"); if (appConfig == null) { appConfig = list.Remove("App.config"); } if (appConfig != null) { string output = Path.GetFileName(GetOutputFileName(configuration)); list.Add(appConfig.Src, appConfig.CopyOnlyIfNewer, output + ".config"); } //collect all the "local copy" references and their attendant files foreach (ProjectReference projectReference in References) { if (!projectReference.LocalCopy || ParentSolution == null) { continue; } if (projectReference.ReferenceType == ReferenceType.Project) { DotNetProject p = ParentSolution.FindProjectByName(projectReference.Reference) as DotNetProject; if (p == null) { LoggingService.LogWarning("Project '{0}' referenced from '{1}' could not be found", projectReference.Reference, this.Name); continue; } string refOutput = p.GetOutputFileName(configuration); if (string.IsNullOrEmpty(refOutput)) { LoggingService.LogWarning("Project '{0}' referenced from '{1}' has an empty output filename", p.Name, this.Name); continue; } list.Add(refOutput); //VS COMPAT: recursively copy references's "local copy" files //but only copy the "copy to output" files from the immediate references p.PopulateSupportFileList(list, configuration, referenceDistance + 1); DotNetProjectConfiguration refConfig = p.GetConfiguration(configuration) as DotNetProjectConfiguration; if (refConfig != null && refConfig.DebugMode) { string mdbFile = TargetRuntime.GetAssemblyDebugInfoFile(refOutput); if (File.Exists(mdbFile)) { list.Add(mdbFile); } } } else if (projectReference.ReferenceType == ReferenceType.Assembly) { // VS COMPAT: Copy the assembly, but also all other assemblies referenced by it // that are located in the same folder foreach (string file in GetAssemblyRefsRec(projectReference.Reference, new HashSet <string> ())) { list.Add(file); if (File.Exists(file + ".config")) { list.Add(file + ".config"); } string mdbFile = TargetRuntime.GetAssemblyDebugInfoFile(file); if (File.Exists(mdbFile)) { list.Add(mdbFile); } } } else if (projectReference.ReferenceType == ReferenceType.Custom) { foreach (string refFile in projectReference.GetReferencedFileNames(configuration)) { list.Add(refFile); } } } }
internal protected virtual ExecutionCommand OnCreateExecutionCommand(ConfigurationSelector configSel, DotNetProjectConfiguration configuration) { return(next.OnCreateExecutionCommand(configSel, configuration)); }