Customizable Team Foundation Build Targets

  • Article

MSBuild targets define how a MSBuild project is built. The Microsoft.TeamFoundation.Build.targets file defines the target hierarchy and a set of predefined MSBuild tasks and targets for Team Foundation Build used for all Team Foundation Build types. Each Team Foundation Build build type includes a project file that is named TfsBuild.proj. TfsBuild.proj imports the Microsoft.TeamFoundation.Build.targets file and provides values for various properties, item groups, and potentially overrides some of the extension point targets in the hierarchy.

Important

Do not modify the Microsoft.TeamFoundation.Build.targets file.

For more information about MSBuild targets, see MSBuild Targets.

Targets that can be Customized with Tasks

Tasks are contained in targets. Tasks provide the code that runs during the build process. The following table lists all the Team Foundation Build targets that are defined for extensibility. Insert your tasks into one of these targets depending on when you must run your custom tasks during the build process.

Note

We do not recommend that you extend other targets.

Target Name Description

BeforeEndToEndIteration

Insert your task into this target to run tasks before the EndToEndIteration target.

AfterEndToEndIteration

Insert your task into this target to run tasks after the EndToEndInteration target.

BuildNumberOverrideTarget

Used to override a target to customize the build number. The task you write must create an output property called BuildNumber.

BeforeClean

Called before clean is tried. Insert your task into this target to run pre-clean custom target.

AfterClean

Called after clean is completed. Insert your task into this target to run post-clean custom tasks.

BeforeGet

Called before sources are retrieved from source control. Insert your task into this target to run custom tasks before sources are retrieved.

AfterGet

Called after sources are retrieved. Insert your task into this target to run custom tasks before sources are retrieved.

BeforeLabel

Called before sources are labeled. Insert your task into this target to run custom tasks before the Label target.

AfterLabel

Called after labeling is completed. Insert your task into this target to run custom tasks after the Label target.

BeforeCompile

Called before compilation is started. Insert your task into this target to run custom tasks before the code files are compiled.

AfterCompile

Called after compilation is completed. Insert your task into this target to run custom tasks after the code files are compiled. For an example, see Walkthrough: Configuring Team Foundation Build to Build a Visual Studio Setup Project.

BeforeTest

Called before tests are run. Insert your task into this target to run custom tasks before the Test target.

AfterTest

Called after testing is completed. Insert your task into this target to run custom tasks after the Test target.

BeforeDropBuild

Called before saving the built binaries, build log files, and test results to the build-drop directory on the release server. Insert your task into this target to run custom tasks before the built files are saved to the drop-directory.

AfterDropBuild

Called after dropping the built binaries, build log files, and test results to the release server. Insert your task into this target to run custom tasks after the built files are saved to the drop-directory.

BeforeOnBuildBreak

Called before creating a work item on the build break. Insert your task into this target to run custom tasks before the BuildBreak target.

AfterOnBuildBreak

Called after a work item is created on the build break. Insert your task into this target to run custom tasks after the BuildBreak target.

Inserting Tasks into the Targets

The task code you write must be paired with a target. For more information, see How To: Write a Task. To write a custom task you must follow these steps.

  1. Write the task code, and check it into source control.

    Note

    It is good coding practice to check task code into source control, but it is not absolutely necessary.

  2. Register the custom task in the TfsBuild.proj file by declaring it using the UsingTask MSBuild element. For more information, see UsingTask Element (MSBuild).

    <UsingTask 
    TaskName="MyTasks.SimpleTask" 
    AssemblyName="MyAssembly.Build.Tasks"/>

  3. Run the task by inserting it into the desired target in the TfsBuild.proj file.

    <Target Name="BeforeGet">
    <SimpleTask />
</Target>

  4. Deploy the dll that contains the custom task on the build computer.

For an example of an end-to-end implementation of a custom task, see Walkthrough: Customizing Team Foundation Build with a Custom Task.

Order of Target Execution

The order of execution of the targets is in the following list.

  1. BeforeEndToEndIteration

  2. BuildNumberOverrideTarget

  3. InitializeEndToEndIteration

  4. BeforeClean

  5. CoreClean

  6. AfterClean

  7. Clean

  8. InitializeBuild

  9. InitializeWorkspace

  10. BeforeGet

  11. CoreGet

  12. AfterGet

  13. BeforeLabel

  14. CoreLabel

  15. AfterLabel

  16. PreBuild

  17. BeforeCompile

  18. CoreCompile

  19. AfterCompile

  20. Compile

  21. GetChangeSetsAndUpdateWorkItems

  22. PostBuild

  23. BeforeTest

  24. CoreTest

  25. AfterTest

  26. Test

  27. PackageBinaries

  28. TeamBuild

  29. BeforeDropBuild

  30. CoreDropBuild

  31. CopyLogFiles

  32. AfterDropBuild

  33. DropBuild

  34. AfterEndToEndIteration

  35. EndToEndIteration

See Also

Concepts

Understanding Team Foundation Build Configuration Files
Customizable Team Foundation Build Properties
Team Foundation Build Tasks