How to make an MSBuild Target that only runs once instead of once, before Targets that run once per framework in the TargetFrameworks tag?

Question

I have a code generator tool that I partially own, and now that csproj files can list multiple Target Frameworks in them and building builds all of them, I am trying to figure out how to make an MSBuild Target to do the code generation only once per running the build, no matter how many Target Frameworks are listed, and have the compiling for each of the Target Frameworks wait until the code generation has completed.

I currently have it conditional on a specific value of TargetFramework. For example, Condition="'netstandard2.0' == '$(TargetFramework)'".

This avoids the code generation tool being kicked off for each Target Framework at the same time and then getting access denied errors as the processes try to create/update the same files.

However, the other Target Frameworks go right to trying to compile without waiting for the code generation to complete, and fail without that code existing.

I would like to have my code generation happen only once each time a project is built and have the compiling for each Target Framework only begin once that has finished.

It needs to run each time a build is run, in case the inputs have changed and it generates different code.

Note: For the moment I am ignoring a case where #if FrameworkSpecificDefine is used to have different input code to the code generator, such that different Target Frameworks causes different output from the code generator. For now, I am considering the output of the code generator to be the same and valid across all Target Frameworks.

Update: After looking for a Target that happens before MSBuild splits into TargetFramework specific builds, that I could then hook to build before, I see this in Detailed Build Output in VS:

1>Target _SetBuildInnerTarget:
1>Target _ComputeTargetFrameworkItems:
1>Target DispatchToInnerBuilds:
1>  Using "MSBuild" task from assembly "Microsoft.Build.Tasks.Core, Version=15.1.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a".
1>  Task "MSBuild"
1>    Additional Properties for project "ProjectA.csproj":
1>      TargetFramework=netstandard2.0
1>    Additional Properties for project "ProjectA.csproj":
1>      TargetFramework=net47

I then set my target as BeforeTargets="DispatchToInnerBuilds" and it runs before the individual builds that set TargetFramework specifically and seems to meet my needs exactly.

(Adding to the BuildDependsOn property doesn't seem to work any longer: Add a msbuild task that runs after building a .NET Core project in Visual Studio 2017 RC; I suspect that Microsoft.Common.targets gets evaluated later in the new csproj format, and any appending to properties that you do in the project file are overwritten by Microsoft.Common.targets.)

Answer 1

While some targets only run in the inner builds, e.g. when you use BeforeTargets="BeforeBuild", the outer build also defines the IsCrossTargetingBuild variable to indicate that the currently running build is the outer build which dispatches to the inner build and is the preferred way to condition targets.

So you can condition your target like Condition="'$(IsCrossTargetingBuild)' == 'true'" to make sure the target is only run for the outer build.

Answer 2

Very helpful answers here, but my situation requires a generic target that can be called by projects that have single or multiple TargetFrameworks. I came up with a Singleton target that runs once per project, before the builds, regardless of the number of TargetFrameworks. Single run for all of these cases:

• <TargetFrameworks>netstandard2.0;net4.6</TargetFrameworks>
• <TargetFrameworks>netstandard2.0</TargetFrameworks>
• <TargetFramework>netstandard2.0</TargetFramework>

The key to this solution is to set a property (named IsCrossTargetingProject in the example below) that allows the individual builds to know if they are being launched by DispatchToInnerBuilds, and thus should only run in the outer build.

I could have used an example, so I decided to post it here for anyone else in this situation.

Example:

<Project>
    <PropertyGroup>
        <IsCrossTargetingProject Condition="$(TargetFrameworks) != ''">true</IsCrossTargetingProject>
    </PropertyGroup>

    <!--Only used to display properties to understand what the Singleton Target is doing.  Not required-->
    <Target Name="DebuggingDisplayProperties" BeforeTargets="DispatchToInnerBuilds;BeforeBuild">
        <Message Text="      ######################################################## Display Properties for $(MSBuildProjectName) $(TargetFramework)." Importance="high" />
        <Message Text="      IsCrossTargetingBuild: '$(IsCrossTargetingBuild)'" Importance="high" />
        <Message Text="      IsCrossTargetingProject: '$(IsCrossTargetingProject)'" Importance="high" />        
        <Message Text="      Compare => '$(IsCrossTargetingProject)' == '$(IsCrossTargetingBuild)'" Importance="high" />        
    </Target>
    
    <Target Name="SingletonTarget" Condition="'$(IsCrossTargetingProject)' == '$(IsCrossTargetingBuild)'" BeforeTargets="DispatchToInnerBuilds;BeforeBuild" >
        <!--Begin sample target body--> 
        <PropertyGroup Condition="'$(IsCrossTargetingBuild)' == ''">
            <CrossTargetMessage>$(TargetFramework)</CrossTargetMessage>
        </PropertyGroup>
        <PropertyGroup Condition="'$(IsCrossTargetingBuild)' == 'true'">
            <CrossTargetMessage>Multi-Targeted</CrossTargetMessage>
        </PropertyGroup>
        <Message Text="      ######################################################## Singleton Target for $(MSBuildProjectName) - $(CrossTargetMessage)." Importance="high" />
        <!--End sample target body--> 
    </Target>
</Project>

I have it in a separate file, and import it with the following line in my main project file:

<Import Project="..\Common\Singleton.targets" />

Answer 3

The other way is use GenerateNuspec when you want to change the nuget file.

You will find the Foo output once when you package.

Answer 4

On single target framework I only use BeforeTargets="PreBuildEvent":

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <TargetFramework>netstandard2.0</TargetFramework>
  </PropertyGroup>
  <Target Name="GenerateVersionInfo" BeforeTargets="PreBuildEvent">
    <Exec Command="your custom command" />
  </Target>
</Project>

on multi target frameworks I use BeforeTargets="DispatchToInnerBuilds"

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <TargetFrameworks>netstandard2.0;net461</TargetFrameworks>
  </PropertyGroup>
  <Target Name="GenerateVersionInfo" BeforeTargets="DispatchToInnerBuilds">
    <Exec Command="your custom command" />
  </Target>
</Project>

So my custom command is only exeuted once before every build. If you use InitialTargets, the command is executed more often than only once! For example if you save your project!

Answer 5

Condition="'$(TargetFrameworks)' == '' OR $(TargetFrameworks.EndsWith($(TargetFramework)))"