| private AddNewTask ( string taskName ) : Microsoft.Build.BuildEngine.BuildTask | ||
| taskName | string | |
| return | Microsoft.Build.BuildEngine.BuildTask | |
private void AddContentBuildTask(string intermediateDirectory, string outputDirectory, string rootDirectory, string targetPlatform)
{
BuildTask contentTask = m_contentTarget.AddNewTask("CreateItem");
contentTask.SetParameterValue("Include", "@(Content)");
contentTask.Condition = "'%(Content.Importer)' != 'XactImporter'";
contentTask.AddOutputItem("Include", "XNAContent");
BuildTask bt = m_xnaTarget.AddNewTask("BuildContent");
bt.SetParameterValue("SourceAssets", "@(XNAContent)");
bt.SetParameterValue("PipelineAssemblies", "@(PipelineAssembly)");
bt.SetParameterValue("IntermediateDirectory", intermediateDirectory);
bt.SetParameterValue("OutputDirectory", outputDirectory);
bt.SetParameterValue("RootDirectory", rootDirectory);
bt.SetParameterValue("TargetPlatform", targetPlatform);
}
/// <summary>
/// Adds tasks that create a temporary VC project file with pre-resolved project references (that is,
/// replaced with file references)
/// </summary>
/// <param name="solution"></param>
/// <param name="target"></param>
/// <param name="proj"></param>
/// <param name="solutionConfiguration"></param>
/// <param name="subTargetName"></param>
/// <param name="projectConfigurationName"></param>
/// <returns>The path to the temporary project file</returns>
/// <owner>LukaszG</owner>
static private string AddCreateTemporaryVCProjectTasks
(
SolutionParser solution,
Project msbuildProject,
Target target,
ProjectInSolution proj,
ConfigurationInSolution solutionConfiguration,
string subTargetName,
string projectConfigurationName
)
{
StringBuilder referenceItemName = new StringBuilder(GenerateSafePropertyName(proj, "References"));
if (!string.IsNullOrEmpty(subTargetName))
{
referenceItemName.Append('_');
referenceItemName.Append(subTargetName);
}
StringBuilder importLibraryItemName = new StringBuilder(GenerateSafePropertyName(proj, "ImportLibraries"));
if (!string.IsNullOrEmpty(subTargetName))
{
importLibraryItemName.Append('_');
importLibraryItemName.Append(subTargetName);
}
string referenceGuidsToRemove = null;
AddResolveProjectReferenceTasks(solution, msbuildProject, target, proj, solutionConfiguration,
referenceItemName.ToString(), importLibraryItemName.ToString(), out referenceGuidsToRemove);
if (string.IsNullOrEmpty(referenceGuidsToRemove))
referenceGuidsToRemove = string.Empty;
string fullProjectPath = null;
string tmpExtension = null;
string projectPath = null;
try
{
fullProjectPath = proj.AbsolutePath;
tmpExtension = string.Format(CultureInfo.InvariantCulture, ".tmp_{0}_{1}.vcproj", solutionConfiguration.ConfigurationName, solutionConfiguration.PlatformName);
projectPath = Path.ChangeExtension(fullProjectPath, tmpExtension);
}
catch (Exception e)
{
if (ExceptionHandling.NotExpectedException(e))
throw;
ProjectFileErrorUtilities.VerifyThrowInvalidProjectFile(false,
"SubCategoryForSolutionParsingErrors",
new BuildEventFileInfo(solution.SolutionFile),
"SolutionParseInvalidProjectFileName",
proj.RelativePath, e.Message);
}
// Create the temporary VC project
BuildTask createVCProjectTask = target.AddNewTask("CreateTemporaryVCProject");
createVCProjectTask.SetParameterValue("ProjectFile", fullProjectPath, true /* treat as literal */);
createVCProjectTask.SetParameterValue("Configuration", projectConfigurationName, true /* treat as literal */);
createVCProjectTask.SetParameterValue("OutputProjectFile", projectPath, true /* treat as literal */);
createVCProjectTask.SetParameterValue("ReferenceGuids", referenceGuidsToRemove, false /* Contains semicolon-separated list. DO NOT treat as literal */);
createVCProjectTask.SetParameterValue("ReferenceAssemblies",
string.Format(CultureInfo.InvariantCulture, "@({0})", referenceItemName.ToString()), false /* DO NOT treat as literal */);
createVCProjectTask.SetParameterValue("ReferenceImportLibraries",
string.Format(CultureInfo.InvariantCulture, "@({0})", importLibraryItemName.ToString()), false /* DO NOT treat as literal */);
createVCProjectTask.Condition = GetConditionStringForConfiguration(solutionConfiguration);
return projectPath;
}
/// <summary>
/// Adds MSBuild and ResolveVCProjectOutput tasks to a project target to pre-resolve its project references
/// </summary>
/// <param name="solution"></param>
/// <param name="target"></param>
/// <param name="proj"></param>
/// <param name="solutionConfiguration"></param>
/// <param name="outputReferenceItemName"></param>
/// <param name="outputImportLibraryItemName"></param>
/// <param name="addedReferenceGuids"></param>
/// <owner>LukaszG</owner>
static private void AddResolveProjectReferenceTasks
(
SolutionParser solution,
Project msbuildProject,
Target target,
ProjectInSolution proj,
ConfigurationInSolution solutionConfiguration,
string outputReferenceItemName,
string outputImportLibraryItemName,
out string addedReferenceGuids
)
{
StringBuilder referenceGuids = new StringBuilder();
string message = null;
// Suffix for the reference item name. Since we need to attach additional (different) metadata to every
// reference item, we need to have helper item lists each with only one item
int outputReferenceItemNameSuffix = 0;
// Pre-resolve the MSBuild/VC project references
foreach (string projectReferenceGuid in proj.ProjectReferences)
{
ProjectInSolution referencedProject = (ProjectInSolution)solution.ProjectsByGuid[projectReferenceGuid];
ProjectConfigurationInSolution referencedProjectConfiguration = null;
if ((referencedProject != null) &&
(referencedProject.ProjectConfigurations.TryGetValue(solutionConfiguration.FullName, out referencedProjectConfiguration)) &&
(referencedProjectConfiguration != null))
{
string outputReferenceItemNameWithSuffix = string.Format(CultureInfo.InvariantCulture, "{0}_{1}",
outputReferenceItemName, outputReferenceItemNameSuffix);
bool addCreateItem = false;
if ((referencedProject.ProjectType == SolutionProjectType.ManagedProject) ||
((referencedProject.ProjectType == SolutionProjectType.Unknown) && (referencedProject.CanBeMSBuildProjectFile(out message))))
{
string condition = GetConditionStringForConfiguration(solutionConfiguration);
bool specifyProjectToolsVersion =
String.Equals(msbuildProject.ToolsVersion, "2.0", StringComparison.OrdinalIgnoreCase) ? false : true;
BuildTask msbuildTask = AddMSBuildTaskElement(target, referencedProject.RelativePath, "GetTargetPath",
referencedProjectConfiguration.ConfigurationName, referencedProjectConfiguration.PlatformName, specifyProjectToolsVersion);
msbuildTask.Condition = condition;
msbuildTask.AddOutputItem("TargetOutputs", outputReferenceItemNameWithSuffix);
if (referenceGuids.Length > 0)
{
referenceGuids.Append(';');
}
referenceGuids.Append(projectReferenceGuid);
addCreateItem = true;
}
else if (referencedProject.ProjectType == SolutionProjectType.VCProject)
{
BuildTask vcbuildTask = null;
try
{
vcbuildTask = AddResolveVCProjectOutputTaskElement(target, Path.Combine(solution.SolutionFileDirectory, Path.GetFileName(solution.SolutionFile)),
referencedProject.AbsolutePath, referencedProjectConfiguration.FullName);
}
catch (Exception e)
{
if (ExceptionHandling.NotExpectedException(e))
throw;
ProjectFileErrorUtilities.VerifyThrowInvalidProjectFile(false,
"SubCategoryForSolutionParsingErrors",
new BuildEventFileInfo(solution.SolutionFile),
"SolutionParseInvalidProjectFileName",
referencedProject.RelativePath, e.Message);
}
vcbuildTask.Condition = GetConditionStringForConfiguration(solutionConfiguration);
vcbuildTask.AddOutputItem("ResolvedOutputPaths", outputReferenceItemNameWithSuffix);
if (outputImportLibraryItemName != null)
{
vcbuildTask.AddOutputItem("ResolvedImportLibraryPaths", outputImportLibraryItemName);
}
if (referenceGuids.Length > 0)
{
referenceGuids.Append(';');
}
referenceGuids.Append(projectReferenceGuid);
addCreateItem = true;
}
// Add create item if either of the conditions above was true.
// This merges the one-item item list into the main list, adding the appropriate guid metadata
if (addCreateItem)
{
BuildTask createItemTask = target.AddNewTask("CreateItem");
createItemTask.SetParameterValue("Include", "@(" + outputReferenceItemNameWithSuffix + ")", false /* do not treat as literal */);
createItemTask.SetParameterValue("AdditionalMetadata", "Guid=" + projectReferenceGuid, false /* do not treat as literal */);
createItemTask.AddOutputItem("Include", outputReferenceItemName);
}
outputReferenceItemNameSuffix++;
}
}
addedReferenceGuids = referenceGuids.ToString();
}
/// <summary>
/// Adds a new ResolveVCProjectOutput task element to the specified target
/// </summary>
/// <param name="target"></param>
/// <param name="solutionPath"></param>
/// <param name="projectPath"></param>
/// <param name="fullConfigurationName"></param>
/// <returns></returns>
/// <owner>LukaszG</owner>
static private BuildTask AddResolveVCProjectOutputTaskElement
(
Target target,
string solutionPath,
string projectPath,
string fullConfigurationName
)
{
BuildTask newTask = target.AddNewTask("ResolveVCProjectOutput");
newTask.SetParameterValue("ProjectReferences", projectPath, true /* treat as literal */);
newTask.SetParameterValue("Configuration", fullConfigurationName, true /* treat as literal */);
newTask.SetParameterValue("SolutionFile", solutionPath, true /* treat as literal */);
// If the user passed in an override stylesheet for this .VCPROJ (by specifying a global
// property called VCBuildOverride), we need to use it to resolve the output path. Override
// stylesheets can be used to change the directory that VC projects get built to.
newTask.SetParameterValue("Override", "$(VCBuildOverride)");
return newTask;
}
/// <summary>
/// Adds an MSBuild task to the specified target
/// </summary>
/// <param name="target"></param>
/// <param name="projectPath"></param>
/// <param name="msbuildTargetName"></param>
/// <param name="configurationName"></param>
/// <param name="platformName"></param>
/// <returns></returns>
/// <owner>RGoel, LukaszG</owner>
static private BuildTask AddMSBuildTaskElement
(
Target target,
string projectPath,
string msbuildTargetName,
string configurationName,
string platformName,
bool specifyProjectToolsVersion
)
{
BuildTask newTask = target.AddNewTask("MSBuild");
newTask.SetParameterValue("Projects", projectPath, true /* treat as literal */);
if (msbuildTargetName != null && msbuildTargetName.Length > 0)
{
newTask.SetParameterValue("Targets", msbuildTargetName);
}
string additionalProperties = string.Format(
CultureInfo.InvariantCulture,
"Configuration={0}; Platform={1}; BuildingSolutionFile=true; CurrentSolutionConfigurationContents=$(CurrentSolutionConfigurationContents); SolutionDir=$(SolutionDir); SolutionExt=$(SolutionExt); SolutionFileName=$(SolutionFileName); SolutionName=$(SolutionName); SolutionPath=$(SolutionPath)",
EscapingUtilities.Escape(configurationName),
EscapingUtilities.Escape(platformName)
);
newTask.SetParameterValue("Properties", additionalProperties);
if (specifyProjectToolsVersion)
{
newTask.SetParameterValue("ToolsVersion", "$(ProjectToolsVersion)");
newTask.SetParameterValue("UnloadProjectsOnCompletion", "$(UnloadProjectsOnCompletion)");
newTask.SetParameterValue("UseResultsCache", "$(UseResultsCache)");
}
return newTask;
}
/// <summary>
/// Add a new error/warning/message tag into the given target
/// </summary>
/// <param name="target">Destination target for the tag</param>
/// <param name="elementType">Element type to add (Error, Warning, Message)</param>
/// <param name="treatAsLiteral">Whether to treat the Text as a literal string or one that contains embedded properties, etc.</param>
/// <param name="textResourceName">Resource string name to use in the tag text</param>
/// <param name="args">Additional parameters to pass to FormatString</param>
/// <owner>LukaszG</owner>
static internal BuildTask AddErrorWarningMessageElement(Target target, string elementType,
bool treatAsLiteral, string textResourceName, params object[] args)
{
string code = null;
string helpKeyword = null;
string text = ResourceUtilities.FormatResourceString(out code, out helpKeyword, textResourceName, args);
BuildTask task = target.AddNewTask(elementType);
task.SetParameterValue("Text", text, treatAsLiteral);
if ((elementType != XMakeElements.message) && (code != null))
{
task.SetParameterValue("Code", code, true /* treat as literal */);
}
if ((elementType != XMakeElements.message) && (helpKeyword != null))
{
task.SetParameterValue("HelpKeyword", helpKeyword, true /* treat as literal */);
}
return task;
}
/// <summary>
/// This code handles the *.REFRESH files that are in the "bin" subdirectory of
/// a web project. These .REFRESH files are just text files that contain absolute or
/// relative paths to the referenced assemblies. The goal of these tasks is to
/// search all *.REFRESH files and extract fully-qualified absolute paths for
/// each of the references.
/// </summary>
/// <param name="target"></param>
/// <param name="proj"></param>
/// <param name="referenceItemName"></param>
/// <owner>RGoel</owner>
static private void AddTasksToResolveAutoRefreshFileReferences
(
Target target,
ProjectInSolution proj,
string referenceItemName
)
{
string webRoot = "$(" + GenerateSafePropertyName(proj, "AspNetPhysicalPath") + ")";
// Create an item list containing each of the .REFRESH files.
BuildTask createItemTask = target.AddNewTask("CreateItem");
createItemTask.SetParameterValue("Include", webRoot + @"\Bin\*.refresh");
createItemTask.AddOutputItem("Include", referenceItemName + "_RefreshFile");
// Read the lines out of each .REFRESH file; they should be paths to .DLLs. Put these paths
// into an item list.
BuildTask readLinesTask = target.AddNewTask("ReadLinesFromFile");
readLinesTask.SetParameterValue("File",
String.Format(CultureInfo.InvariantCulture, @"%({0}_RefreshFile.Identity)", referenceItemName));
readLinesTask.Condition = String.Format(CultureInfo.InvariantCulture, @" '%({0}_RefreshFile.Identity)' != '' ", referenceItemName);
readLinesTask.AddOutputItem("Lines", referenceItemName + "_ReferenceRelPath");
// Take those paths and combine them with the root of the web project to form either
// an absolute path or a path relative to the .SLN file. These paths can be passed
// directly to RAR later.
BuildTask combinePathTask = target.AddNewTask("CombinePath");
combinePathTask.SetParameterValue("BasePath", webRoot);
combinePathTask.SetParameterValue("Paths",
String.Format(CultureInfo.InvariantCulture, @"@({0}_ReferenceRelPath)", referenceItemName));
combinePathTask.AddOutputItem("CombinedPaths", referenceItemName);
}
/// <summary>
/// Add a call to the ResolveAssemblyReference task to crack the pre-resolved referenced
/// assemblies for the complete list of dependencies, PDBs, satellites, etc. The invoke
/// the Copy task to copy all these files (or at least the ones that RAR determined should
/// be copied local) into the web project's bin directory.
/// </summary>
/// <param name="target"></param>
/// <param name="proj"></param>
/// <param name="referenceItemName"></param>
/// <param name="conditionDescribingValidConfigurations"></param>
/// <owner>RGoel</owner>
static private void AddTasksToCopyAllDependenciesIntoBinDir
(
Target target,
ProjectInSolution proj,
string referenceItemName,
string conditionDescribingValidConfigurations
)
{
string copyLocalFilesItemName = referenceItemName + "_CopyLocalFiles";
string destinationFolder = String.Format(CultureInfo.InvariantCulture,
@"$({0})\Bin\", GenerateSafePropertyName(proj, "AspNetPhysicalPath"));
// This is a bit of a hack. We're actually calling the "Copy" task on all of
// the *non-existent* files. Why? Because we want to emit a warning in the
// log for each non-existent file, and the Copy task does that nicely for us.
// I would have used the <Warning> task except for the fact that we are in
// string-resource lockdown.
BuildTask copyNonExistentReferencesTask = target.AddNewTask("Copy");
copyNonExistentReferencesTask.SetParameterValue("SourceFiles", "@(" + referenceItemName + "->'%(FullPath)')", false /* Do not treat as literal */);
copyNonExistentReferencesTask.SetParameterValue("DestinationFolder", destinationFolder);
copyNonExistentReferencesTask.Condition = String.Format(CultureInfo.InvariantCulture, "!Exists('%({0}.Identity)')", referenceItemName);
copyNonExistentReferencesTask.ContinueOnError = true;
// Call ResolveAssemblyReference on each of the .DLL files that were found on
// disk from the .REFRESH files as well as the P2P references. RAR will crack
// the dependencies, find PDBs, satellite assemblies, etc., and determine which
// files need to be copy-localed.
BuildTask rarTask = target.AddNewTask("ResolveAssemblyReference");
rarTask.SetParameterValue("Assemblies", "@(" + referenceItemName + "->'%(FullPath)')", false /* Do not treat as literal */);
rarTask.SetParameterValue("TargetFrameworkDirectories", "@(_CombinedTargetFrameworkDirectoriesItem)", false /* Do not treat as literal */);
rarTask.SetParameterValue("InstalledAssemblyTables", "@(InstalledAssemblyTables)", false /* Do not treat as literal */);
rarTask.SetParameterValue("SearchPaths", "{RawFileName};{TargetFrameworkDirectory};{GAC}");
rarTask.SetParameterValue("FindDependencies", "true");
rarTask.SetParameterValue("FindSatellites", "true");
rarTask.SetParameterValue("FindSerializationAssemblies", "true");
rarTask.SetParameterValue("FindRelatedFiles", "true");
rarTask.Condition = String.Format(CultureInfo.InvariantCulture, "Exists('%({0}.Identity)')", referenceItemName);
rarTask.AddOutputItem("CopyLocalFiles", copyLocalFilesItemName);
// Copy all the copy-local files (reported by RAR) to the web project's "bin"
// directory.
BuildTask copyTask = target.AddNewTask("Copy");
copyTask.SetParameterValue("SourceFiles", "@(" + copyLocalFilesItemName + ")", false /* DO NOT treat as literal */);
copyTask.SetParameterValue("DestinationFiles", String.Format(CultureInfo.InvariantCulture,
@"@({0}->'{1}%(DestinationSubDirectory)%(Filename)%(Extension)')",
copyLocalFilesItemName, destinationFolder), false /* DO NOT treat as literal */);
copyTask.Condition = conditionDescribingValidConfigurations;
}
/// <summary>
/// Helper method to add a call to the AspNetCompiler task into the given target.
/// </summary>
/// <param name="target"></param>
/// <param name="proj"></param>
/// <param name="conditionDescribingValidConfigurations"></param>
/// <owner>RGoel</owner>
static private void AddTaskForAspNetCompiler
(
Target target,
ProjectInSolution proj,
string conditionDescribingValidConfigurations
)
{
// Add a call to the AspNetCompiler task, conditioned on having a valid Configuration.
BuildTask newTask = target.AddNewTask("AspNetCompiler");
newTask.SetParameterValue("VirtualPath", "$(" + GenerateSafePropertyName(proj, "AspNetVirtualPath") + ")");
newTask.SetParameterValue("PhysicalPath", "$(" + GenerateSafePropertyName(proj, "AspNetPhysicalPath") + ")");
newTask.SetParameterValue("TargetPath", "$(" + GenerateSafePropertyName(proj, "AspNetTargetPath") + ")");
newTask.SetParameterValue("Force", "$(" + GenerateSafePropertyName(proj, "AspNetForce") + ")");
newTask.SetParameterValue("Updateable", "$(" + GenerateSafePropertyName(proj, "AspNetUpdateable") + ")");
newTask.SetParameterValue("Debug", "$(" + GenerateSafePropertyName(proj, "AspNetDebug") + ")");
newTask.SetParameterValue("KeyFile", "$(" + GenerateSafePropertyName(proj, "AspNetKeyFile") + ")");
newTask.SetParameterValue("KeyContainer", "$(" + GenerateSafePropertyName(proj, "AspNetKeyContainer") + ")");
newTask.SetParameterValue("DelaySign", "$(" + GenerateSafePropertyName(proj, "AspNetDelaySign") + ")");
newTask.SetParameterValue("AllowPartiallyTrustedCallers", "$(" + GenerateSafePropertyName(proj, "AspNetAPTCA") + ")");
newTask.SetParameterValue("FixedNames", "$(" + GenerateSafePropertyName(proj, "AspNetFixedNames") + ")");
newTask.Condition = conditionDescribingValidConfigurations;
}
/// <summary>
/// Adds a new VCBuild task element to the specified target
/// </summary>
/// <param name="target">The target to add the VCBuild task to</param>
/// <param name="solutionPath">Path to the solution if any</param>
/// <param name="projectPath">Path to the solution if any</param>
/// <param name="vcbuildTargetName">The VCBuild target name</param>
/// <param name="platformName">The platform parameter to VCBuild</param>
/// <param name="fullConfigurationName">Configuration property value</param>
/// <returns></returns>
static internal BuildTask AddVCBuildTaskElement
(
Project msbuildProject,
Target target,
string solutionPath,
string projectPath,
string vcbuildTargetName,
string platformName,
string fullConfigurationName
)
{
// The VCBuild task (which we already shipped) has a bug - it cannot
// find vcbuild.exe when running in MSBuild 64 bit unless it's on the path.
// So, pass it here, unless some explicit path was passed.
// Note, we have to do this even if we're in a 32 bit MSBuild, because we save the .sln.cache
// file, and the next build of the solution could be a 64 bit MSBuild.
if (VCBuildLocationHint != null) // Should only be null if vcbuild truly isn't installed; in that case, let the task log its error
{
BuildTask createProperty = target.AddNewTask("CreateProperty");
createProperty.SetParameterValue("Value", VCBuildLocationHint);
createProperty.Condition = "'$(VCBuildToolPath)' == ''";
createProperty.AddOutputProperty("Value", "VCBuildToolPath");
}
BuildTask newTask = target.AddNewTask("VCBuild");
newTask.SetParameterValue("Projects", projectPath, true /* treat as literal */);
// Add the toolpath so that the user can override if necessary
newTask.SetParameterValue("ToolPath", "$(VCBuildToolPath)");
newTask.SetParameterValue("Configuration", fullConfigurationName);
if (!string.IsNullOrEmpty(platformName))
{
newTask.SetParameterValue("Platform", platformName);
}
newTask.SetParameterValue("SolutionFile", solutionPath);
if ((vcbuildTargetName != null) && (vcbuildTargetName.Length > 0))
{
newTask.SetParameterValue(vcbuildTargetName, "true");
}
// Add the override switch so that the user can supply one if necessary
newTask.SetParameterValue("Override", "$(VCBuildOverride)");
// Add any additional lib paths
newTask.SetParameterValue("AdditionalLibPaths", "$(VCBuildAdditionalLibPaths)");
// Only use new properties if we're not emitting a 2.0 project
if (!String.Equals(msbuildProject.ToolsVersion, "2.0", StringComparison.OrdinalIgnoreCase))
{
// Add any additional link library paths
newTask.SetParameterValue("AdditionalLinkLibraryPaths", "$(VCBuildAdditionalLinkLibraryPaths)");
// Add the useenv switch so that the user can supply one if necessary
// Note: "VCBuildUserEnvironment" is included for backwards-compatibility; the correct
// property name is "VCBuildUseEnvironment" to match the task parameter. When the old name is
// used the task will emit a warning.
newTask.SetParameterValue("UseEnvironment", "$(VCBuildUseEnvironment)");
}
newTask.SetParameterValue("UserEnvironment", "$(VCBuildUserEnvironment)");
// Add the additional options switches
newTask.SetParameterValue("AdditionalOptions", "$(VCBuildAdditionalOptions)");
return newTask;
}
/// <summary>
/// Adds a new VCBuild task element to the specified target
/// </summary>
/// <param name="target">The target to add the VCBuild task to</param>
/// <param name="solutionPath">Path to the solution if any</param>
/// <param name="projectPath">Path to the solution if any</param>
/// <param name="vcbuildTargetName">The VCBuild target name</param>
/// <param name="platformName">The platform parameter to VCBuild</param>
/// <param name="fullConfigurationName">Configuration property value</param>
/// <returns></returns>
static internal BuildTask AddVCBuildTaskElement
(
Project msbuildProject,
Target target,
string solutionPath,
string projectPath,
string vcbuildTargetName,
string platformName,
string fullConfigurationName
)
{
// The VCBuild task (which we already shipped) has a bug - it cannot
// find vcbuild.exe when running in MSBuild 64 bit unless it's on the path.
// So, pass it here, unless some explicit path was passed.
// Note, we have to do this even if we're in a 32 bit MSBuild, because we save the .sln.cache
// file, and the next build of the solution could be a 64 bit MSBuild.
if (VCBuildLocationHint != null) // Should only be null if vcbuild truly isn't installed; in that case, let the task log its error
{
BuildTask createProperty = target.AddNewTask("CreateProperty");
createProperty.SetParameterValue("Value", VCBuildLocationHint);
createProperty.Condition = "'$(VCBuildToolPath)' == ''";
createProperty.AddOutputProperty("Value", "VCBuildToolPath");
}
BuildTask newTask = target.AddNewTask("VCBuild");
newTask.SetParameterValue("Projects", projectPath, true /* treat as literal */);
// Add the toolpath so that the user can override if necessary
newTask.SetParameterValue("ToolPath", "$(VCBuildToolPath)");
newTask.SetParameterValue("Configuration", fullConfigurationName);
if (!string.IsNullOrEmpty(platformName))
{
newTask.SetParameterValue("Platform", platformName);
}
newTask.SetParameterValue("SolutionFile", solutionPath);
if ((vcbuildTargetName != null) && (vcbuildTargetName.Length > 0))
{
newTask.SetParameterValue(vcbuildTargetName, "true");
}
// Add the override switch so that the user can supply one if necessary
newTask.SetParameterValue("Override", "$(VCBuildOverride)");
// Add any additional lib paths
newTask.SetParameterValue("AdditionalLibPaths", "$(VCBuildAdditionalLibPaths)");
// Only use new properties if we're not emitting a 2.0 project
if (!String.Equals(msbuildProject.ToolsVersion, "2.0", StringComparison.OrdinalIgnoreCase))
{
// Add any additional link library paths
newTask.SetParameterValue("AdditionalLinkLibraryPaths", "$(VCBuildAdditionalLinkLibraryPaths)");
// Add the useenv switch so that the user can supply one if necessary
// Note: "VCBuildUserEnvironment" is included for backwards-compatibility; the correct
// property name is "VCBuildUseEnvironment" to match the task parameter. When the old name is
// used the task will emit a warning.
newTask.SetParameterValue("UseEnvironment", "$(VCBuildUseEnvironment)");
}
newTask.SetParameterValue("UserEnvironment", "$(VCBuildUserEnvironment)");
// Add the additional options switches
newTask.SetParameterValue("AdditionalOptions", "$(VCBuildAdditionalOptions)");
return(newTask);
}
/*/// <summary>
/// Gets or sets the default source parameter identifier.
/// </summary>
/// <value>The default source parameter identifier.</value>
public string DefaultSourceParameterIdentifier
{
get
{
return this.defaultSourceParameterIdentifier;
}
set
{
this.defaultSourceParameterIdentifier = value;
}
}*/
/// <summary>
/// Creates and Adds a new task on a build target.
/// </summary>
/// <param name="target">The build target.</param>
/// <param name="sourceParameterIdentifier">The source parameter identifier used to name the
/// ItemGroup with source files.</param>
/// <param name="sourceParameter">The source parameter.</param>
/// <returns>
/// A new task ready to use.
/// </returns>
public BuildTask CreateNewTaskOnTarget(
Target target,
string sourceParameterIdentifier,
string sourceParameter)
{
if (target == null)
{
throw new ArgumentNullException("target");
}
// Compose the new task.
var batask = target.AddNewTask(this.taskType.FullName);
// Set the main source parameter on the build task.
//batask.SetParameterValue(sourceParameter, this.DefaultSourceParameterIdentifier);
var spi = @"@(" + sourceParameterIdentifier + ")";
batask.SetParameterValue(sourceParameter, spi);
// Store for later use with SetParametersOnCreatedTask( ... ).
this.composedTask = batask;
return batask;
}