What is the difference between 'DependsOnTargets' and 'AfterTargets' ?

Question

I can not distinguish these two. Please help!

Answer 1

DependsOnTarget - let's assume that you have two tasks: 1 - Build Project, 2 - Copy all content. You can start your build by executing task 2 and then in task declaration define it's dependencies. So if you define that task 2 depends on task 1 build process will start and execute task 1 and then 2.

AfterTargets - much simpler means only tasks which are execute after other targets. So taking the example from above - after Task 1 - build project execute task 2.

I hope this helps

Answer 2

DependsOnTargets

Defines the targets that must be executed before the target can be executed.

<Target Name="DependsOn" DependsOnTargets="DependencyTarget1;DependencyTarget2">
  <Message Text="Target : DependsOn"/>
</Target>

<Target Name="DependencyTarget2">
  <Message Text="Target : DependencyTarget2"/>
</Target> 

<Target Name="DependencyTarget1">
  <Message Text="Target : DependencyTarget1"/>
</Target> 

Output
> Target : DependencyTarget1
> Target : DependencyTarget2
> Target : DependsOn

BeforeTargets and AfterTargets (Only available in MSBuild 4)

Indicates that the target should run before or after the specified target or targets.

<Target Name="BeforeAndAfter">
  <Message Text="Target : BeforeAndAfter"/>
</Target>

<!-- BeforeTarget1 will run BEFORE target "BeforeAndAfter" -->
<Target Name="BeforeTarget" BeforeTargets="BeforeAndAfter">
  <Message Text="BeforeTarget run before : BeforeAndAfter"/>
</Target> 

<!-- BeforeTarget1 will run AFTER target "BeforeAndAfter" -->
<Target Name="AfterTarget" AfterTargets="BeforeAndAfter">
  <Message Text="AfterTarget run after : BeforeAndAfter"/>
</Target> 

Output
> BeforeTarget run before : BeforeAndAfter
> Target : BeforeAndAfter
> AfterTarget run after : BeforeAndAfter

• If you have multiples targets that should run before or after the same specified target, they will be executed in declaration order :

  <Target Name="BeforeAndAfter">
    <Message Text="Target : BeforeAndAfter"/>
  </Target>
  
  
  <!-- 
     BOTH BeforeTarget1 and BeforeTarget2 should run before target "BeforeAndAfter"
  -->
  <Target Name="BeforeTarget1" BeforeTargets="BeforeAndAfter">
    <Message Text="BeforeTarget1 run before : BeforeAndAfter"/>
  </Target> 
  
  
  <Target Name="BeforeTarget2" BeforeTargets="BeforeAndAfter">
    <Message Text="BeforeTarget2 run before : BeforeAndAfter"/>
  </Target> 
  

BeforeTargets and AfterTargets could be use to extend existing build process.

For example, with this attributes you can easily execute a target before CoreCompile (defines in Microsoft.CSharp.targets). Without that you'll have to override the property CoreCompileDependsOn.

Without AfterTargets you have no way to easily execute a target after another one if no extension point is defined (CallTarget at the end of the target with a property that you can override)

DependsOnTargets, BeforeTargets and AfterTargets execution order?

When DependsOnTargets, BeforeTargets and AfterTargets are used on the same target, the order of execution is :

• DependsOnTargets
• BeforeTargets
• The target

• AfterTargets

  <Target Name="MainTarget" DependsOnTargets="DefaultDependsOn">
    <Message Text="Target : MainTarget"/>
  </Target>
  
  
  <Target Name="DefaultDependsOn">
    <Message Text="Target : DefaultDependsOn"/>
  </Target>
  
  
  <Target Name="DefaultBeforeTarget" BeforeTargets="MainTarget">
    <Message Text="Target : DefaultBeforeTarget"/>
  </Target>
  
  
  <Target Name="DefaultAfterTarget" AfterTargets="MainTarget">
    <Message Text="Target : DefaultAfterTarget"/>
  </Target> 
  
  
  Output
  > Target : DefaultDependsOn
  > Target : DefaultBeforeTarget
  > Target : MainTarget
  > Target : DefaultAfterTarget