public static async Task <DependencyGraphSpec> GetDependencyGraphSpec(DotNetProject project, ConfigurationSelector configuration, ILogger logger)
{
if (logger == null)
{
logger = NullLogger.Instance;
}
logger.Log(LogLevel.Information, GettextCatalog.GetString("Getting restore information for project {0}", project.FileName));
using (var resultsPath = new TempFile(".output.dg")) {
var context = new TargetEvaluationContext();
context.GlobalProperties.SetValue("RestoreGraphOutputPath", resultsPath);
using (var monitor = CreateProgressMonitor()) {
var result = await project.RunTarget(monitor, "GenerateRestoreGraphFile", configuration, context);
if (result != null)
{
foreach (BuildError error in result.BuildResult.Errors)
{
if (error.IsWarning)
{
logger.LogWarning(error.ToString());
}
else
{
logger.LogError(error.ToString());
}
}
}
}
return(GetDependencyGraph(resultsPath));
}
}
protected override Task <TargetEvaluationResult> OnRunTarget(
ProgressMonitor monitor,
string target,
ConfigurationSelector configuration,
TargetEvaluationContext context)
{
if (ProjectSystemService.IsEnabled)
{
return(OnMonitorRunTarget(monitor, target, configuration, context));
}
return(base.OnRunTarget(monitor, target, configuration, context));
}
async Task <TargetEvaluationResult> OnMonitorRunTarget(
ProgressMonitor monitor,
string target,
ConfigurationSelector configuration,
TargetEvaluationContext context)
{
using (var buildMonitor = new MSBuildTargetMonitor(Project, target, configuration, context)) {
try {
ProgressMonitor modifiedMonitor = buildMonitor.GetProgressMonitor(monitor);
TargetEvaluationResult result = await base.OnRunTarget(modifiedMonitor, target, configuration, context);
buildMonitor.OnResult(result);
return(result);
} catch (Exception ex) {
buildMonitor.OnException(ex);
throw;
}
}
}
bool IsCoreCompileDependsOn(string target, TargetEvaluationContext context)
{
if (!context.ItemsToEvaluate.Contains("Compile"))
{
return(false);
}
// The following is based on Project.GetCompileItemsFromCoreCompileDependenciesAsync
// and determines whether the CoreCompileDependsOn is being run.
var coreCompileDependsOn = Project.MSBuildProject.EvaluatedProperties.GetValue <string> ("CoreCompileDependsOn");
if (string.IsNullOrEmpty(coreCompileDependsOn))
{
return(false);
}
var dependsList = string.Join(";", coreCompileDependsOn.Split(new [] { ";" }, StringSplitOptions.RemoveEmptyEntries).Select(s => s.Trim()).Where(s => s.Length > 0));
return(target == dependsList);
}
public MSBuildTargetMonitor(
Project project,
string target,
ConfigurationSelector configuration,
TargetEvaluationContext context)
{
// Ensure log verbosity is set for non-build targets.
this.context = context;
context.LogVerbosity = Runtime.Preferences.MSBuildVerbosity.Value;
buildTarget = new MSBuildTarget {
ProjectName = project.Name,
ProjectFileName = project.FileName,
Targets = target ?? string.Empty,
BuildType = MSBuildTarget.GetBuildType(target),
Dimensions = project.GetDimensions(configuration)
};
buildTarget.Start();
ProjectSystemService.OnTargetStarted(buildTarget);
}
protected override Task <TargetEvaluationResult> OnRunTarget(ProgressMonitor monitor, string target, ConfigurationSelector configuration, TargetEvaluationContext context)
{
if (Project is DotNetProject dotNetProject && IsCoreCompileDependsOn(target, context))
{
if (DotNetCoreNuGetProject.CanCreate(dotNetProject))
{
return(OnRunDotNetCoreProjectTarget(monitor, target, configuration, context));
}
else if (PackageReferenceNuGetProject.CanCreate(dotNetProject))
{
return(OnRunPackageReferenceProjectTarget(monitor, target, configuration, context));
}
}
return(base.OnRunTarget(monitor, target, configuration, context));
}
/// <summary>
/// Ensures any NuGet package content files are included when CoreCompileDependsOn is evaluated.
/// Visual Studio 2017 does not run the ResolveNuGetPackageAssets target directly but seems to
/// run the Compile target for the project which indirectly runs ResolveNuGetPackageAssets.
/// </summary>
Task <TargetEvaluationResult> OnRunPackageReferenceProjectTarget(ProgressMonitor monitor, string target, ConfigurationSelector configuration, TargetEvaluationContext context)
{
target += ";ResolveNuGetPackageAssets";
context.GlobalProperties.SetValue("ResolveNuGetPackages", true);
return(base.OnRunTarget(monitor, target, configuration, context));
}
/// <summary>
/// Ensures any NuGet package content files are included when CoreCompileDependsOn is evaluated.
/// Visual Studio 2017 does not run the RunProductContentAssets target directly but runs a set of
/// targets which indirectly run RunProductContentAssets.
/// </summary>
Task <TargetEvaluationResult> OnRunDotNetCoreProjectTarget(ProgressMonitor monitor, string target, ConfigurationSelector configuration, TargetEvaluationContext context)
{
target += ";RunProduceContentAssets";
return(base.OnRunTarget(monitor, target, configuration, context));
}
void OverrideMSBuildExtensionsPathToFixBuild(TargetEvaluationContext context)
{
string path = Path.GetFullPath(Path.Combine(sdkPaths.MSBuildSDKsPath, ".."));
context.GlobalProperties.SetValue("MSBuildExtensionsPath", path);
}
internal protected override TargetEvaluationContext OnConfigureTargetEvaluationContext(string target, ConfigurationSelector configuration, TargetEvaluationContext context)
{
var c = base.OnConfigureTargetEvaluationContext(target, configuration, context);
context.GlobalProperties.SetValue("Foo", ControlValue);
return(c);
}
public override DeployFileCollection GetProjectDeployFiles(DeployContext ctx, Project project, ConfigurationSelector configuration)
{
var deployFiles = new DeployFileCollection();
base.GetProjectDeployFiles(ctx, project, configuration);
// Add the compiled output files
var pconf = (ProjectConfiguration)project.GetConfiguration(configuration);
var evalCtx = new TargetEvaluationContext();
evalCtx.ItemsToEvaluate.Add("AllPublishItemsFullPathWithTargetPath");
if (project.MSBuildProject.UseMSBuildEngine)
{
var result = project.RunTarget(new ProgressMonitor(), "GetCopyToPublishDirectoryItems", configuration, evalCtx).Result;
foreach (var item in result.Items)
{
if (item.Name == "AllPublishItemsFullPathWithTargetPath")
{
var fromPath = MSBuildProjectService.FromMSBuildPath(project.ItemDirectory, item.Include);
var toPath = item.Metadata.GetPathValue("TargetPath", relativeToPath: pconf.OutputDirectory);
deployFiles.Add(new DeployFile(project, fromPath, toPath, TargetDirectory.ProgramFiles));
}
}
}
else
{
#pragma warning disable 618 //obsolete
FilePath outDir = pconf.OutputDirectory;
foreach (FilePath file in project.GetOutputFiles(configuration))
{
deployFiles.Add(new DeployFile(project, file, file.ToRelative(outDir), TargetDirectory.ProgramFiles));
}
foreach (FileCopySet.Item item in project.GetSupportFileList(configuration))
{
deployFiles.Add(new DeployFile(project, item.Src, item.Target, TargetDirectory.ProgramFiles));
}
#pragma warning restore 618
}
// Collect deployable files
foreach (ProjectFile file in project.Files)
{
// skip CopyToOutputDirectory files when it's just a project build, because
// MonoDevelop.Project.Projects already copies these files using more subtle overwriting
// semantics
if (file.CopyToOutputDirectory != FileCopyMode.None)
{
continue;
}
var props = new DeployProperties(file);
if (props.ShouldDeploy)
{
var dp = new DeployFile(file);
deployFiles.Add(dp);
}
}
return(deployFiles);
}
protected override bool OnFastCheckNeedsBuild(ConfigurationSelector configuration, TargetEvaluationContext context)
{
CheckPropertyValue = context.GlobalProperties.GetValue <bool> ("IsBuildingForExecution");
return(true);
}
protected override bool OnFastCheckNeedsBuild(ConfigurationSelector configuration, TargetEvaluationContext context)
{
return(!IsBuildUpToDate);
}
protected override Task <TargetEvaluationResult> OnRunTarget(ProgressMonitor monitor, string target, ConfigurationSelector configuration, TargetEvaluationContext context)
{
if (target == ProjectService.BuildTarget)
{
target = "all";
}
else if (target == ProjectService.CleanTarget)
{
target = "clean";
}
DotNetProjectConfiguration conf = (DotNetProjectConfiguration)Project.GetConfiguration(configuration);
return(Task <TargetEvaluationResult> .Factory.StartNew(delegate {
using (var output = new StringWriter()) {
using (var tw = new LogTextWriter()) {
tw.ChainWriter(output);
tw.ChainWriter(monitor.Log);
using (ProcessWrapper proc = Runtime.ProcessService.StartProcess("make", "PROFILE=" + conf.Id + " " + target, conf.OutputDirectory, monitor.Log, tw, null))
proc.WaitForOutput();
tw.UnchainWriter(output);
tw.UnchainWriter(monitor.Log);
CompilerResults cr = new CompilerResults(null);
string[] lines = output.ToString().Split('\n');
foreach (string line in lines)
{
CompilerError err = CreateErrorFromString(line);
if (err != null)
{
cr.Errors.Add(err);
}
}
return new TargetEvaluationResult(new BuildResult(cr, output.ToString()));
}
}
}));
}
protected async override Task <TargetEvaluationResult> OnRunTarget(ProgressMonitor monitor, string target, ConfigurationSelector configuration, TargetEvaluationContext context)
{
if (target == ProjectService.BuildTarget)
{
var config = GetConfiguration(configuration) as DotNetProjectConfiguration;
using (var builder = new DnxProjectBuilder(this, monitor)) {
BuildResult result = await builder.BuildAsnc(config);
LastBuildTime = DateTime.Now;
return(new TargetEvaluationResult(result));
}
}
return(new TargetEvaluationResult(BuildResult.CreateSuccess()));
}
protected override System.Threading.Tasks.Task <TargetEvaluationResult> OnRunTarget(MonoDevelop.Core.ProgressMonitor monitor, string target, ConfigurationSelector configuration, TargetEvaluationContext context)
{
DotNetProjectConfiguration conf = (DotNetProjectConfiguration)Project.GetConfiguration(configuration);
MonoDevelop.Core.LoggingService.LogInfo("ProjectExtensionAddIn - Configuration: " + conf.Name);
MonoDevelop.Core.LoggingService.LogInfo("ProjectExtensionAddIn - Platform: " + conf.Platform);
MonoDevelop.Core.LoggingService.LogInfo("ProjectExtensionAddIn - conf.TargetFramework.Name: " + conf.TargetFramework.Name);
MonoDevelop.Core.LoggingService.LogInfo("ProjectExtensionAddIn - conf.TargetRuntime.DisplayName: " + conf.TargetRuntime.DisplayName);
MonoDevelop.Core.LoggingService.LogInfo("ProjectExtensionAddIn - Project.Name: " + Project.Name);
MonoDevelop.Core.LoggingService.LogInfo("ProjectExtensionAddIn - Target: " + target);
// Update project version if not the same as solution version
if (target.Equals("Build"))
{
if (Project.Version.Equals(Project.ParentSolution.Version) == false)
{
Project.Version = Project.ParentSolution.Version;
}
// load version propfile
if (Project.TargetFramework.Id.Identifier.Equals("MonoAndroid"))
{
// update Android Manifest
// update AssemblyInfo
}
if (Project.TargetFramework.Id.Identifier.Equals("Xamarin.iOS"))
{
// update Info.plist
// update AssemblyInfo
}
if (Project.TargetFramework.Id.Identifier.Equals(".NETPortable"))
{
// update AssemblyInfo
}
}
return(base.OnRunTarget(monitor, target, configuration, context));
}
protected override System.Threading.Tasks.Task <TargetEvaluationResult> OnRunTarget(ProgressMonitor monitor, string target, ConfigurationSelector configuration, TargetEvaluationContext context)
{
return(base.OnRunTarget(monitor, target, configuration, context));
}
// HACK: The FSharp.NET.Core.Sdk.targets defines the path to dotnet using:
// <_DotNetHostExecutableDirectory>$(MSBuildExtensionsPath)/../..</_DotNetHostExecutableDirectory>
// MSBuildExtensionsPath points to MSBuild supplied with Mono so building FSharp
// projects fails using this path since dotnet does not ship with Mono. The
// _DotNetHostExecutableDirectory cannot be overridden so as a workaround for
// F# projects the MSBuildExtensionsPath is redefined to point to the .NET Core
// SDK folder.
protected override Task <TargetEvaluationResult> OnRunTarget(ProgressMonitor monitor, string target, ConfigurationSelector configuration, TargetEvaluationContext context)
{
if (target == ProjectService.BuildTarget)
{
if (IsFSharpSdkProject())
{
OverrideMSBuildExtensionsPathToFixBuild(context);
}
}
return(base.OnRunTarget(monitor, target, configuration, context));
}
