public async Task <BuildResult> Clean(ProgressMonitor monitor, ConfigurationSelector configuration, OperationContext operationContext = null)
{
if (ParentSolution == null)
{
return(new BuildResult());
}
SolutionConfiguration conf = ParentSolution.GetConfiguration(configuration);
if (conf == null)
{
return(new BuildResult());
}
if (operationContext == null)
{
operationContext = new OperationContext();
}
ReadOnlyCollection <SolutionItem> allProjects;
try {
allProjects = GetAllBuildableEntries(configuration, true, true);
} catch (CyclicDependencyException) {
monitor.ReportError(GettextCatalog.GetString("Cyclic dependencies are not supported."), null);
return(new BuildResult("", 1, 1));
}
monitor.BeginTask(GettextCatalog.GetString("Cleaning Solution: {0} ({1})", Name, configuration.ToString()), allProjects.Count);
bool operationStarted = false;
BuildResult result = null;
try {
operationStarted = ParentSolution != null && await ParentSolution.BeginBuildOperation(monitor, configuration, operationContext);
return(result = await RunParallelBuildOperation(monitor, configuration, allProjects, (ProgressMonitor m, SolutionItem item) => {
return item.Clean(m, configuration, operationContext);
}, false));
}
finally {
if (operationStarted)
{
await ParentSolution.EndBuildOperation(monitor, configuration, operationContext, result);
}
monitor.EndTask();
}
}
protected override BuildResult OnBuild (IProgressMonitor monitor, ConfigurationSelector configuration)
{
// create output directory, if not exists
ProjectConfiguration conf = GetConfiguration (configuration) as ProjectConfiguration;
if (conf == null) {
BuildResult cres = new BuildResult ();
cres.AddError (GettextCatalog.GetString ("Configuration '{0}' not found in project '{1}'", configuration.ToString (), Name));
return cres;
}
string outputDir = conf.OutputDirectory;
try {
DirectoryInfo directoryInfo = new DirectoryInfo (outputDir);
if (!directoryInfo.Exists) {
directoryInfo.Create ();
}
} catch (Exception e) {
throw new ApplicationException ("Can't create project output directory " + outputDir + " original exception:\n" + e.ToString ());
}
//copy references and files marked to "CopyToOutputDirectory"
CopySupportFiles (monitor, configuration);
StringParserService.Properties["Project"] = Name;
monitor.BeginTask (GettextCatalog.GetString ("Performing main compilation..."), 0);
BuildResult res = DoBuild (monitor, configuration);
isDirty = false;
if (res != null) {
string errorString = GettextCatalog.GetPluralString ("{0} error", "{0} errors", res.ErrorCount, res.ErrorCount);
string warningString = GettextCatalog.GetPluralString ("{0} warning", "{0} warnings", res.WarningCount, res.WarningCount);
monitor.Log.WriteLine (GettextCatalog.GetString ("Build complete -- ") + errorString + ", " + warningString);
}
monitor.EndTask ();
return res;
}
protected override BuildResult OnBuild(IProgressMonitor monitor, ConfigurationSelector configuration)
{
ReadOnlyCollection <SolutionItem> allProjects;
try {
allProjects = GetAllBuildableEntries(configuration, true, true);
} catch (CyclicDependencyException) {
monitor.ReportError(GettextCatalog.GetString("Cyclic dependencies are not supported."), null);
return(new BuildResult("", 1, 1));
}
try {
List <SolutionItem> toBuild = new List <SolutionItem> (allProjects);
monitor.BeginTask(GettextCatalog.GetString("Building Solution: {0} ({1})", Name, configuration.ToString()), toBuild.Count);
BuildResult cres = new BuildResult();
cres.BuildCount = 0;
HashSet <SolutionItem> failedItems = new HashSet <SolutionItem> ();
foreach (SolutionItem item in toBuild)
{
if (monitor.IsCancelRequested)
{
break;
}
if (!item.ContainsReferences(failedItems, configuration))
{
BuildResult res = item.Build(monitor, configuration, false);
if (res != null)
{
cres.Append(res);
if (res.ErrorCount > 0)
{
failedItems.Add(item);
}
}
}
else
{
failedItems.Add(item);
}
monitor.Step(1);
}
return(cres);
} finally {
monitor.EndTask();
}
}
protected override BuildResult OnBuild(IProgressMonitor monitor, ConfigurationSelector configuration)
{
// create output directory, if not exists
ProjectConfiguration conf = GetConfiguration(configuration) as ProjectConfiguration;
if (conf == null)
{
BuildResult cres = new BuildResult();
cres.AddError(GettextCatalog.GetString("Configuration '{0}' not found in project '{1}'", configuration.ToString(), Name));
return(cres);
}
StringParserService.Properties["Project"] = Name;
if (UsingMSBuildEngine(configuration))
{
return(DoBuild(monitor, configuration));
}
string outputDir = conf.OutputDirectory;
try {
DirectoryInfo directoryInfo = new DirectoryInfo(outputDir);
if (!directoryInfo.Exists)
{
directoryInfo.Create();
}
} catch (Exception e) {
throw new ApplicationException("Can't create project output directory " + outputDir + " original exception:\n" + e.ToString());
}
//copy references and files marked to "CopyToOutputDirectory"
CopySupportFiles(monitor, configuration);
monitor.Log.WriteLine("Performing main compilation...");
BuildResult res = DoBuild(monitor, configuration);
if (res != null)
{
string errorString = GettextCatalog.GetPluralString("{0} error", "{0} errors", res.ErrorCount, res.ErrorCount);
string warningString = GettextCatalog.GetPluralString("{0} warning", "{0} warnings", res.WarningCount, res.WarningCount);
monitor.Log.WriteLine(GettextCatalog.GetString("Build complete -- ") + errorString + ", " + warningString);
}
return(res);
}
protected override void OnClean(IProgressMonitor monitor, ConfigurationSelector configuration)
{
if (ParentSolution == null)
{
return;
}
SolutionConfiguration conf = ParentSolution.GetConfiguration(configuration);
if (conf == null)
{
return;
}
try {
monitor.BeginTask(GettextCatalog.GetString("Cleaning Solution: {0} ({1})", Name, configuration.ToString()), Items.Count);
foreach (SolutionItem item in Items)
{
if (item is SolutionFolder)
{
item.Clean(monitor, configuration);
}
else if (item is SolutionEntityItem)
{
SolutionEntityItem si = (SolutionEntityItem)item;
// ce can be null if you add items to the root solution folder which
// causes them to be placed in an autogenerated 'Project Items' folder
SolutionConfigurationEntry ce = conf.GetEntryForItem(si);
if (ce != null && ce.Build)
{
si.Clean(monitor, ce.ItemConfigurationSelector);
}
}
else
{
item.Clean(monitor, configuration);
}
monitor.Step(1);
}
}
finally {
monitor.EndTask();
}
}
public async Task <BuildResult> Build(ProgressMonitor monitor, ConfigurationSelector configuration, bool buildReferencedTargets = false, OperationContext operationContext = null)
{
ReadOnlyCollection <SolutionItem> allProjects;
try {
allProjects = GetAllBuildableEntries(configuration, true, true);
} catch (CyclicDependencyException) {
monitor.ReportError(GettextCatalog.GetString("Cyclic dependencies are not supported."), null);
return(new BuildResult("", 1, 1));
}
if (operationContext == null)
{
operationContext = new OperationContext();
}
bool operationStarted = false;
BuildResult result = null;
try {
if (Runtime.Preferences.SkipBuildingUnmodifiedProjects)
{
allProjects = allProjects.Where(si => {
if (si is Project p)
{
return(p.FastCheckNeedsBuild(configuration));
}
return(true); //Don't filter things that don't have FastCheckNeedsBuild
}).ToList().AsReadOnly();
}
monitor.BeginTask(GettextCatalog.GetString("Building Solution: {0} ({1})", Name, configuration.ToString()), allProjects.Count);
operationStarted = ParentSolution != null && await ParentSolution.BeginBuildOperation(monitor, configuration, operationContext);
return(result = await RunParallelBuildOperation(monitor, configuration, allProjects, (ProgressMonitor m, SolutionItem item) => {
return item.Build(m, configuration, false, operationContext);
}, false));
} finally {
if (operationStarted)
{
await ParentSolution.EndBuildOperation(monitor, configuration, operationContext, result);
}
monitor.EndTask();
}
}
/// <summary>
/// Builds the solution item
/// </summary>
/// <param name='monitor'>
/// A progress monitor
/// </param>
/// <param name='configuration'>
/// Configuration to use to build the project
/// </param>
/// <param name='buildReferences'>
/// When set to <c>true</c>, the referenced items will be built before building this item
/// </param>
public BuildResult Build(IProgressMonitor monitor, ConfigurationSelector solutionConfiguration, bool buildReferences)
{
ITimeTracker tt = Counters.BuildProjectTimer.BeginTiming("Building " + Name);
try {
if (!buildReferences)
{
if (!NeedsBuilding(solutionConfiguration))
{
return(new BuildResult(new CompilerResults(null), ""));
}
//SolutionFolder's OnRunTarget handles the begin/end task itself, don't duplicate
if (this is SolutionFolder)
{
return(RunTarget(monitor, ProjectService.BuildTarget, solutionConfiguration));
}
try {
SolutionEntityItem it = this as SolutionEntityItem;
SolutionItemConfiguration iconf = it != null?it.GetConfiguration(solutionConfiguration) : null;
string confName = iconf != null ? iconf.Id : solutionConfiguration.ToString();
monitor.BeginTask(GettextCatalog.GetString("Building: {0} ({1})", Name, confName), 1);
// This will end calling OnBuild ()
return(RunTarget(monitor, ProjectService.BuildTarget, solutionConfiguration));
} finally {
monitor.EndTask();
}
}
// Get a list of all items that need to be built (including this),
// and build them in the correct order
List <SolutionItem> referenced = new List <SolutionItem> ();
Set <SolutionItem> visited = new Set <SolutionItem> ();
GetBuildableReferencedItems(visited, referenced, this, solutionConfiguration);
ReadOnlyCollection <SolutionItem> sortedReferenced = SolutionFolder.TopologicalSort(referenced, solutionConfiguration);
BuildResult cres = new BuildResult();
cres.BuildCount = 0;
HashSet <SolutionItem> failedItems = new HashSet <SolutionItem> ();
monitor.BeginTask(null, sortedReferenced.Count);
foreach (SolutionItem p in sortedReferenced)
{
if (p.NeedsBuilding(solutionConfiguration) && !p.ContainsReferences(failedItems, solutionConfiguration))
{
BuildResult res = p.Build(monitor, solutionConfiguration, false);
cres.Append(res);
if (res.ErrorCount > 0)
{
failedItems.Add(p);
}
}
else
{
failedItems.Add(p);
}
monitor.Step(1);
if (monitor.IsCancelRequested)
{
break;
}
}
monitor.EndTask();
return(cres);
} finally {
tt.End();
}
}
public async Task <BuildResult> Build(ProgressMonitor monitor, ConfigurationSelector configuration, bool buildReferencedTargets = false, OperationContext operationContext = null)
{
ReadOnlyCollection <SolutionItem> allProjects;
try {
allProjects = GetAllBuildableEntries(configuration, true, true);
} catch (CyclicDependencyException) {
monitor.ReportError(GettextCatalog.GetString("Cyclic dependencies are not supported."), null);
return(new BuildResult("", 1, 1));
}
try {
monitor.BeginTask(GettextCatalog.GetString("Building Solution: {0} ({1})", Name, configuration.ToString()), allProjects.Count);
return(await RunParallelBuildOperation(monitor, configuration, allProjects, (ProgressMonitor m, SolutionItem item) => {
return item.Build(m, configuration, false, operationContext);
}, false));
} finally {
monitor.EndTask();
}
}
public Task <BuildResult> Build(ProgressMonitor monitor, ConfigurationSelector configuration, bool buildReferencedTargets = false, OperationContext operationContext = null)
{
var slnConf = ParentSolution?.GetConfiguration(configuration);
if (slnConf == null)
{
return(Task.FromResult(new BuildResult()));
}
//don't collect dependencies, BuildItems will do it
var collected = new HashSet <SolutionItem> ();
CollectBuildableEntries(collected, configuration, slnConf, false);
return(ParentSolution.BuildItems(
monitor, configuration, collected, operationContext,
IsRoot ? GettextCatalog.GetString("Building solution {0} ({1})", Name, configuration.ToString()) : null
));
}
