/// <summary>
/// Starts to run a build inside the SharpDevelop GUI.
/// Only one build can run inside the GUI at one time.
/// </summary>
/// <param name="project">The project/solution to build.</param>
/// <param name="options">The build options.</param>
public static void BuildInGui(IBuildable project, BuildOptions options)
{
if (project == null)
throw new ArgumentNullException("project");
if (options == null)
throw new ArgumentNullException("options");
WorkbenchSingleton.AssertMainThread();
if (guiBuildCancellation != null) {
BuildResults results = new BuildResults();
WorkbenchSingleton.StatusBar.SetMessage(Core.ResourceService.GetString("MainWindow.CompilerMessages.MSBuildAlreadyRunning"));
BuildError error = new BuildError(null, Core.ResourceService.GetString("MainWindow.CompilerMessages.MSBuildAlreadyRunning"));
results.Add(error);
TaskService.Add(new Task(error));
results.Result = BuildResultCode.MSBuildAlreadyRunning;
if (options.Callback != null) {
options.Callback(results);
}
} else {
guiBuildCancellation = new CancellationTokenSource();
IProgressMonitor progressMonitor = WorkbenchSingleton.StatusBar.CreateProgressMonitor(guiBuildCancellation.Token);
guiBuildTrackedFeature = AnalyticsMonitorService.TrackFeature("ICSharpCode.SharpDevelop.Project.BuildEngine.Build");
WorkbenchSingleton.StatusBar.SetMessage(StringParser.Parse("${res:MainWindow.CompilerMessages.BuildVerb}..."));
ProjectService.RaiseEventBuildStarted(new BuildEventArgs(project, options));
StartBuild(project, options,
new MessageViewSink(TaskService.BuildMessageViewCategory, progressMonitor, WorkbenchSingleton.StatusBar));
}
}
public override async void StartBuild()
{
var options = new BuildOptions(BuildTarget.Rebuild);
options.TargetForDependencies = BuildTarget.Build;
options.ProjectAdditionalProperties["RunCodeAnalysis"] = "true";
CallbackMethod(await SD.BuildService.BuildAsync(this.ProjectToBuild, options));
}
public override void StartBuild()
{
BuildOptions options = new BuildOptions(BuildTarget.Rebuild, CallbackMethod);
options.TargetForDependencies = BuildTarget.Build;
options.ProjectAdditionalProperties["RunSourceAnalysis"] = "true";
BuildEngine.BuildInGui(this.ProjectToBuild, options);
}
public override async void StartBuild()
{
var options = new BuildOptions(BuildTarget.Rebuild);
options.TargetForDependencies = BuildTarget.Build;
options.ProjectAdditionalProperties["RunSourceAnalysis"] = "true";
options.ProjectAdditionalProperties["StyleCopFile"] = StyleCopWrapper.FindStyleCopPath() ?? string.Empty;
CallbackMethod(await SD.BuildService.BuildAsync(this.ProjectToBuild, options));
}
public override void StartBuild()
{
BuildOptions options = new BuildOptions(BuildTarget.Rebuild, CallbackMethod);
options.TargetForDependencies = BuildTarget.Build;
options.ProjectAdditionalProperties["RunSourceAnalysis"] = "true";
options.ProjectAdditionalProperties["StyleCopFile"] = StyleCopWrapper.FindStyleCopPath() ?? string.Empty;
BuildEngine.BuildInGui(this.ProjectToBuild, options);
}
public BuildEventArgs(IReadOnlyList<IProject> projects, BuildOptions options, BuildResults results)
{
if (projects == null)
throw new ArgumentNullException("projects");
if (options == null)
throw new ArgumentNullException("options");
this.Projects = projects;
this.Options = options;
this.Results = results;
}
public async Task RunTestsAsync(IEnumerable<ITest> selectedTests, TestExecutionOptions options, CancellationToken cancellationToken)
{
this.cancellationToken = cancellationToken;
GroupTestsByProject(selectedTests);
ClearTasks();
ShowUnitTestsPad();
ShowOutputPad();
ResetTestResults();
saveAllFilesCommand.SaveAllFiles();
// Run the build, if necessary:
var projectsToBuild = testsByProject.Keys.Where(p => p.IsBuildNeededBeforeTestRun).Select(p => p.Project).ToList();
if (projectsToBuild.Count > 0) {
using (cancellationToken.Register(buildService.CancelBuild)) {
var buildOptions = new BuildOptions(BuildTarget.Build);
buildOptions.BuildDetection = BuildOptions.BuildOnExecute;
var buildResults = await buildService.BuildAsync(projectsToBuild, buildOptions);
if (buildResults.Result != BuildResultCode.Success)
return;
}
}
cancellationToken.ThrowIfCancellationRequested();
using (IProgressMonitor progressMonitor = statusBarService.CreateProgressMonitor(cancellationToken)) {
int projectsLeftToRun = testsByProject.Count;
foreach (IGrouping<ITestProject, ITest> g in testsByProject.OrderBy(g => g.Key.DisplayName)) {
currentProjectBeingTested = g.Key;
progressMonitor.TaskName = GetProgressMonitorLabel(currentProjectBeingTested);
progressMonitor.Progress = GetProgress(projectsLeftToRun);
using (testProgressMonitor = progressMonitor.CreateSubTask(1.0 / testsByProject.Count)) {
using (ITestRunner testRunner = currentProjectBeingTested.CreateTestRunner(options)) {
testRunner.TestFinished += testRunner_TestFinished;
var writer = new MessageViewCategoryTextWriter(testService.UnitTestMessageView);
await testRunner.RunAsync(g, testProgressMonitor, writer, testProgressMonitor.CancellationToken);
}
}
projectsLeftToRun--;
progressMonitor.CancellationToken.ThrowIfCancellationRequested();
}
}
ShowErrorList();
}
/// <summary>
/// Starts to run a build.
/// </summary>
/// <param name="project">The project/solution to build</param>
/// <param name="options">The build options that should be used</param>
/// <param name="buildFeedbackSink">The build feedback sink that receives the build output.
/// The output is nearly sent "as it comes in": sometimes output must wait because the BuildEngine
/// will ensure that output from two projects building in parallel isn't interleaved.</param>
/// <param name="progressMonitor">The progress monitor that receives build progress. The monitor will be disposed
/// when the build completes.</param>
public static Task<BuildResults> BuildAsync(IBuildable project, BuildOptions options, IBuildFeedbackSink buildFeedbackSink, IProgressMonitor progressMonitor)
{
if (project == null)
throw new ArgumentNullException("project");
if (options == null)
throw new ArgumentNullException("options");
BuildEngine engine = new BuildEngine(options, project);
engine.buildStart = DateTime.Now;
engine.combinedBuildFeedbackSink = buildFeedbackSink;
engine.progressMonitor = progressMonitor;
try {
engine.rootNode = engine.CreateBuildGraph(project);
} catch (CyclicDependencyException ex) {
BuildError error;
if (ex.Project1 != null && ex.Project2 != null)
error = new BuildError(null, "Cyclic dependency between " + ex.Project1.Name + " and " + ex.Project2.Name);
else
error = new BuildError(null, "Cyclic dependency");
engine.results.Add(error);
if (engine.combinedBuildFeedbackSink != null) {
engine.combinedBuildFeedbackSink.ReportError(error);
engine.combinedBuildFeedbackSink.ReportMessage(error.ToRichText());
}
engine.results.Result = BuildResultCode.BuildFileError;
engine.ReportDone();
return engine.tcs.Task;
}
engine.workersToStart = options.ParallelProjectCount;
if (engine.workersToStart < 1)
engine.workersToStart = 1;
engine.cancellationRegistration = engine.progressMonitor.CancellationToken.Register(engine.BuildCancelled);
engine.ReportMessageLine("${res:MainWindow.CompilerMessages.BuildStarted}");
engine.StartBuildProjects();
engine.UpdateProgressTaskName();
return engine.tcs.Task;
}
/// <summary>
/// Starts to run a build inside the SharpDevelop GUI.
/// Only one build can run inside the GUI at one time.
/// </summary>
/// <param name="project">The project/solution to build.</param>
/// <param name="options">The build options.</param>
public static void BuildInGui(IBuildable project, BuildOptions options)
{
if (project == null)
throw new ArgumentNullException("project");
if (options == null)
throw new ArgumentNullException("options");
WorkbenchSingleton.AssertMainThread();
if (guiBuildProgressMonitor != null) {
BuildResults results = new BuildResults();
results.Add(new BuildError(null, Core.ResourceService.GetString("MainWindow.CompilerMessages.MSBuildAlreadyRunning")));
results.Result = BuildResultCode.MSBuildAlreadyRunning;
if (options.Callback != null) {
options.Callback(results);
}
} else {
guiBuildProgressMonitor = new CancellableProgressMonitor(StatusBarService.CreateProgressMonitor());
Gui.WorkbenchSingleton.Workbench.GetPad(typeof(Gui.CompilerMessageView)).BringPadToFront();
GuiBuildStarted.RaiseEvent(null, new BuildEventArgs(project, options));
StartBuild(project, options,
new MessageViewSink(TaskService.BuildMessageViewCategory),
guiBuildProgressMonitor);
}
}
internal static void RunMSBuild(Solution solution, IProject project,
string configuration, string platform, BuildOptions options)
{
WorkbenchSingleton.Workbench.GetPad(typeof(CompilerMessageView)).BringPadToFront();
MSBuildEngine engine = new MSBuildEngine();
engine.Configuration = configuration;
engine.Platform = platform;
engine.MessageView = TaskService.BuildMessageViewCategory;
engine.Run(solution, project, options);
}
public override void StartBuild(BuildOptions options)
{
RunMSBuild(this.ParentSolution, this,
this.ActiveConfiguration, this.ActivePlatform, options);
}
public ProjectBuildOptions CreateProjectBuildOptions(BuildOptions options, bool isRootBuildable)
{
return(null);
}
public BuildRun(Solution solution, IProject project, BuildOptions options, MSBuildEngine parentEngine)
{
this.solution = solution;
this.project = project;
this.options = options;
this.parentEngine = parentEngine;
}
public static ProjectBuildOptions CreateProjectBuildOptions(this IBuildable buildable, BuildOptions options, bool isRootBuildable)
{
IBuildable2 buildable2 = buildable as IBuildable2;
if (buildable2 != null) {
return buildable2.CreateProjectBuildOptions(options, isRootBuildable);
}
// start of default implementation
var configMatchings = buildable.ParentSolution.GetActiveConfigurationsAndPlatformsForProjects(options.SolutionConfiguration, options.SolutionPlatform);
ProjectBuildOptions projectOptions = new ProjectBuildOptions(isRootBuildable ? options.ProjectTarget : options.TargetForDependencies);
// Find the project configuration, and build an XML string containing all configurations from the solution
StringWriter solutionConfigurationXml = new StringWriter();
using (XmlTextWriter solutionConfigurationWriter = new XmlTextWriter(solutionConfigurationXml)) {
solutionConfigurationWriter.WriteStartElement("SolutionConfiguration", "");
foreach (var matching in configMatchings) {
if (matching.Project == buildable) {
projectOptions.Configuration = matching.Configuration;
projectOptions.Platform = matching.Platform;
}
solutionConfigurationWriter.WriteStartElement("ProjectConfiguration");
solutionConfigurationWriter.WriteAttributeString("Project", matching.Project.IdGuid);
solutionConfigurationWriter.WriteValue(matching.Configuration + "|" + MSBuildInternals.FixPlatformNameForProject(matching.Platform));
solutionConfigurationWriter.WriteEndElement();
}
solutionConfigurationWriter.WriteEndElement();
}
// fall back to solution config if we don't find any entries for the project
if (string.IsNullOrEmpty(projectOptions.Configuration))
projectOptions.Configuration = options.SolutionConfiguration;
if (string.IsNullOrEmpty(projectOptions.Platform))
projectOptions.Platform = options.SolutionPlatform;
// copy properties to project options
options.GlobalAdditionalProperties.ForEach(projectOptions.Properties.Add);
if (isRootBuildable) {
foreach (var pair in options.ProjectAdditionalProperties) {
projectOptions.Properties[pair.Key] = pair.Value;
}
}
// Set property for solution configuration. This allows MSBuild to know the correct configuration for project references,
// which is necessary to resolve the referenced project's OutputPath.
projectOptions.Properties["CurrentSolutionConfigurationContents"] = solutionConfigurationXml.ToString();
return projectOptions;
}
/// <summary>
/// Starts to run a build.
/// </summary>
/// <param name="project">The project/solution to build</param>
/// <param name="options">The build options that should be used</param>
/// <param name="realtimeBuildFeedbackSink">The build feedback sink that receives the build output.
/// The output is nearly sent "as it comes in": sometimes output must wait because the BuildEngine
/// will ensure that output from two projects building in parallel isn't interleaved.</param>
/// <param name="progressMonitor">The progress monitor that receives build progress. The monitor will be disposed
/// when the build completes.</param>
public static void StartBuild(IBuildable project, BuildOptions options, IBuildFeedbackSink realtimeBuildFeedbackSink)
{
if (project == null)
throw new ArgumentNullException("solution");
if (options == null)
throw new ArgumentNullException("options");
Solution solution = project.ParentSolution;
if (solution == null)
throw new ArgumentException("project.ParentSolution must not be null", "project");
if (string.IsNullOrEmpty(options.SolutionConfiguration))
options.SolutionConfiguration = solution.Preferences.ActiveConfiguration;
if (string.IsNullOrEmpty(options.SolutionPlatform))
options.SolutionPlatform = solution.Preferences.ActivePlatform;
BuildEngine engine = new BuildEngine(options, project);
engine.buildStart = DateTime.Now;
engine.combinedBuildFeedbackSink = realtimeBuildFeedbackSink;
engine.progressMonitor = realtimeBuildFeedbackSink.ProgressMonitor;
try {
engine.rootNode = engine.CreateBuildGraph(project);
} catch (CyclicDependencyException ex) {
if (ex.Project1 != null && ex.Project2 != null)
engine.results.Add(new BuildError(null, "Cyclic dependency between " + ex.Project1.Name + " and " + ex.Project2.Name));
else
engine.results.Add(new BuildError(null, "Cyclic dependency"));
engine.results.Result = BuildResultCode.BuildFileError;
engine.ReportDone();
return;
}
engine.workersToStart = options.ParallelProjectCount;
if (engine.workersToStart < 1)
engine.workersToStart = 1;
engine.cancellationRegistration = engine.progressMonitor.CancellationToken.Register(engine.BuildCancelled);
engine.ReportMessageLine("${res:MainWindow.CompilerMessages.BuildStarted}");
engine.StartBuildProjects();
engine.UpdateProgressTaskName();
}
public virtual void StartBuild(BuildOptions options)
{
}
public ProjectBuildOptions CreateProjectBuildOptions(BuildOptions options, bool isRootBuildable)
{
return null;
}
public async Task<BuildResults> BuildAsync(IEnumerable<IProject> projects, BuildOptions options)
{
if (projects == null)
throw new ArgumentNullException("projects");
if (options == null)
throw new ArgumentNullException("options");
SD.MainThread.VerifyAccess();
if (guiBuildCancellation != null) {
BuildResults results = new BuildResults();
SD.StatusBar.SetMessage(ResourceService.GetString("MainWindow.CompilerMessages.MSBuildAlreadyRunning"));
BuildError error = new BuildError(null, ResourceService.GetString("MainWindow.CompilerMessages.MSBuildAlreadyRunning"));
results.Add(error);
TaskService.Add(new SDTask(error));
results.Result = BuildResultCode.MSBuildAlreadyRunning;
return results;
}
var projectsList = projects.ToList();
guiBuildCancellation = new CancellationTokenSource();
try {
using (var progressMonitor = SD.StatusBar.CreateProgressMonitor(guiBuildCancellation.Token)) {
if (BuildStarted != null)
BuildStarted(this, new BuildEventArgs(projectsList, options));
var trackedFeature = SD.AnalyticsMonitor.TrackFeature("ICSharpCode.SharpDevelop.Project.BuildEngine.Build");
SD.StatusBar.SetMessage(StringParser.Parse("${res:MainWindow.CompilerMessages.BuildVerb}..."));
IBuildable buildable;
if (projectsList.Count == 1)
buildable = projectsList[0];
else
buildable = new MultipleProjectBuildable(projectsList);
buildable = buildModifiedProjectsOnly.WrapBuildable(buildable, options.BuildDetection);
var sink = new UIBuildFeedbackSink(SD.OutputPad.BuildCategory, SD.StatusBar);
// Actually run the build:
var results = await BuildEngine.BuildAsync(buildable, options, sink, progressMonitor);
string message;
if (results.Result == BuildResultCode.Cancelled) {
message = "${res:MainWindow.CompilerMessages.BuildCancelled}";
} else {
if (results.Result == BuildResultCode.Success)
message = "${res:MainWindow.CompilerMessages.BuildFinished}";
else
message = "${res:MainWindow.CompilerMessages.BuildFailed}";
if (results.ErrorCount > 0)
message += " " + results.ErrorCount + " error(s)";
if (results.WarningCount > 0)
message += " " + results.WarningCount + " warning(s)";
}
SD.StatusBar.SetMessage(message);
trackedFeature.EndTracking();
if (BuildFinished != null)
BuildFinished(this, new BuildEventArgs(projectsList, options, results));
return results;
}
} finally {
guiBuildCancellation = null;
}
}
/// <summary>
/// Starts to run a build.
/// </summary>
/// <param name="project">The project/solution to build</param>
/// <param name="options">The build options that should be used</param>
/// <param name="realtimeBuildFeedbackSink">The build feedback sink that receives the build output.
/// The output is nearly sent "as it comes in": sometimes output must wait because the BuildEngine
/// will ensure that output from two projects building in parallel isn't interleaved.</param>
/// <param name="progressMonitor">The progress monitor that receives build progress.</param>
public static void StartBuild(IBuildable project, BuildOptions options, IBuildFeedbackSink realtimeBuildFeedbackSink, IProgressMonitor progressMonitor)
{
if (project == null)
{
throw new ArgumentNullException("solution");
}
if (options == null)
{
throw new ArgumentNullException("options");
}
Solution solution = project.ParentSolution;
if (solution == null)
{
throw new ArgumentException("project.ParentSolution must not be null", "project");
}
if (string.IsNullOrEmpty(options.SolutionConfiguration))
{
options.SolutionConfiguration = solution.Preferences.ActiveConfiguration;
}
if (string.IsNullOrEmpty(options.SolutionPlatform))
{
options.SolutionPlatform = solution.Preferences.ActivePlatform;
}
BuildEngine engine = new BuildEngine(options, project);
engine.buildStart = DateTime.Now;
engine.combinedBuildFeedbackSink = realtimeBuildFeedbackSink;
engine.progressMonitor = progressMonitor;
try {
engine.rootNode = engine.CreateBuildGraph(project);
} catch (CyclicDependencyException ex) {
if (ex.Project1 != null && ex.Project2 != null)
{
engine.results.Add(new BuildError(null, "Cyclic dependency between " + ex.Project1.Name + " and " + ex.Project2.Name));
}
else
{
engine.results.Add(new BuildError(null, "Cyclic dependency"));
}
engine.results.Result = BuildResultCode.BuildFileError;
engine.ReportDone();
return;
}
engine.workersToStart = options.ParallelProjectCount;
if (engine.workersToStart < 1)
{
engine.workersToStart = 1;
}
if (progressMonitor != null)
{
progressMonitor.Cancelled += engine.BuildCancelled;
progressMonitor.BeginTask("", engine.nodeDict.Count, true);
}
engine.ReportMessageInternal("${res:MainWindow.CompilerMessages.BuildStarted}");
engine.StartBuildProjects();
engine.UpdateProgressTaskName();
}
public Task<BuildResults> BuildInBackgroundAsync(IBuildable buildable, BuildOptions options, IBuildFeedbackSink buildFeedbackSink, IProgressMonitor progressMonitor)
{
return BuildEngine.BuildAsync(buildable, options, buildFeedbackSink, progressMonitor);
}
public Task<BuildResults> BuildAsync(ISolution solution, BuildOptions options)
{
if (solution != null) {
var solutionConfiguration = new ConfigurationAndPlatform(options.SolutionConfiguration ?? solution.ActiveConfiguration.Configuration,
options.SolutionPlatform ?? solution.ActiveConfiguration.Platform);
return BuildAsync(solution.Projects.Where(p => p.ConfigurationMapping.IsBuildEnabled(solutionConfiguration)), options);
} else {
return Task.FromResult(new BuildResults { Result = BuildResultCode.Error });
}
}
public Task<BuildResults> BuildAsync(IProject project, BuildOptions options)
{
if (project != null)
return BuildAsync(new[] { project }, options);
else
return Task.FromResult(new BuildResults { Result = BuildResultCode.Error });
}
public virtual ProjectBuildOptions CreateProjectBuildOptions(BuildOptions options, bool isRootBuildable)
{
if (options == null)
throw new ArgumentNullException("options");
// start of default implementation
var configMatchings = this.ParentSolution.GetActiveConfigurationsAndPlatformsForProjects(options.SolutionConfiguration, options.SolutionPlatform);
ProjectBuildOptions projectOptions = new ProjectBuildOptions(isRootBuildable ? options.ProjectTarget : options.TargetForDependencies);
projectOptions.BuildOutputVerbosity = options.BuildOutputVerbosity;
// find the project configuration
foreach (var matching in configMatchings) {
if (matching.Project == this) {
projectOptions.Configuration = matching.Configuration;
projectOptions.Platform = matching.Platform;
}
}
// fall back to solution config if we don't find any entries for the project
if (string.IsNullOrEmpty(projectOptions.Configuration))
projectOptions.Configuration = options.SolutionConfiguration;
if (string.IsNullOrEmpty(projectOptions.Platform))
projectOptions.Platform = options.SolutionPlatform;
// copy global properties to project options
foreach (var pair in options.GlobalAdditionalProperties)
projectOptions.Properties[pair.Key] = pair.Value;
if (isRootBuildable) {
// copy properties for root project to project options
foreach (var pair in options.ProjectAdditionalProperties) {
projectOptions.Properties[pair.Key] = pair.Value;
}
}
return projectOptions;
}
public BuildEventArgs(IBuildable buildable, BuildOptions options)
: this(buildable, options, null)
{
}
public ProjectBuildOptions CreateProjectBuildOptions(BuildOptions options, bool isRootBuildable)
{
return(wrapped.CreateProjectBuildOptions(options, isRootBuildable));
}
public BuildEventArgs(IReadOnlyList <IProject> projects, BuildOptions options)
: this(projects, options, null)
{
}
public void Done(IBuildable buildable, BuildOptions options, BuildResults results)
{
WorkbenchSingleton.SafeThreadAsyncCall(
delegate {
guiBuildCancellation = null;
if (guiBuildTrackedFeature != null) {
guiBuildTrackedFeature.EndTracking();
guiBuildTrackedFeature = null;
}
string message;
if (results.Result == BuildResultCode.Cancelled) {
message = "${res:MainWindow.CompilerMessages.BuildCancelled}";
} else {
if (results.Result == BuildResultCode.Success)
message = "${res:MainWindow.CompilerMessages.BuildFinished}";
else
message = "${res:MainWindow.CompilerMessages.BuildFailed}";
if (results.ErrorCount > 0)
message += " " + results.ErrorCount + " error(s)";
if (results.WarningCount > 0)
message += " " + results.WarningCount + " warning(s)";
}
statusBarService.SetMessage(message);
ProjectService.RaiseEventBuildFinished(new BuildEventArgs(buildable, options, results));
});
}
public ProjectBuildOptions CreateProjectBuildOptions(BuildOptions options, bool isRootBuildable)
{
throw new NotImplementedException();
}
private BuildEngine(BuildOptions options, IBuildable rootProject)
{
this.options = options;
this.rootProject = rootProject;
}
public void Done(IBuildable buildable, BuildOptions options, BuildResults results)
{
WorkbenchSingleton.SafeThreadAsyncCall(
delegate {
guiBuildProgressMonitor = null;
GuiBuildFinished.RaiseEvent(null, new BuildEventArgs(buildable, options, results));
});
}
public ProjectBuildOptions CreateProjectBuildOptions(BuildOptions options, bool isRootBuildable)
{
return wrapped.CreateProjectBuildOptions(options, isRootBuildable);
}
private BuildEngine(BuildOptions options, IBuildable rootProject)
{
this.options = options;
this.rootProject = rootProject;
}
public override ProjectBuildOptions CreateProjectBuildOptions(BuildOptions options, bool isRootBuildable)
{
ProjectBuildOptions projectOptions = base.CreateProjectBuildOptions(options, isRootBuildable);
Solution solution = this.ParentSolution;
var configMatchings = solution.GetActiveConfigurationsAndPlatformsForProjects(options.SolutionConfiguration, options.SolutionPlatform);
// Find the project configuration, and build an XML string containing all configurations from the solution
StringWriter solutionConfigurationXml = new StringWriter();
using (XmlTextWriter solutionConfigurationWriter = new XmlTextWriter(solutionConfigurationXml)) {
solutionConfigurationWriter.WriteStartElement("SolutionConfiguration");
foreach (var matching in configMatchings) {
solutionConfigurationWriter.WriteStartElement("ProjectConfiguration");
solutionConfigurationWriter.WriteAttributeString("Project", matching.Project.IdGuid);
solutionConfigurationWriter.WriteValue(matching.Configuration + "|" + MSBuildInternals.FixPlatformNameForProject(matching.Platform));
solutionConfigurationWriter.WriteEndElement();
}
solutionConfigurationWriter.WriteEndElement();
}
// Set property for solution configuration. This allows MSBuild to know the correct configuration for project references,
// which is necessary to resolve the referenced project's OutputPath.
projectOptions.Properties["CurrentSolutionConfigurationContents"] = solutionConfigurationXml.ToString();
solution.AddMSBuildSolutionProperties(projectOptions.Properties);
return projectOptions;
}
public void StartBuild(BuildOptions options)
{
MSBuildBasedProject.RunMSBuild(this, null,
this.Preferences.ActiveConfiguration,
this.Preferences.ActivePlatform,
options);
}
public BuildEventArgs(IBuildable buildable, BuildOptions options, BuildResults results)
{
if (buildable == null)
throw new ArgumentNullException("buildable");
if (options == null)
throw new ArgumentNullException("options");
this.Buildable = buildable;
this.Options = options;
this.Results = results;
}
public virtual void StartBuild(BuildOptions options)
{
}
