Task for pre-processing source files

[natemcmaster]

I'd like to contribute to MSBuild a task we wrote for aspnet that I think would be generally useful. Is this something MSBuild would accept as a PR?

GenerateFileFromTemplate

Purpose: pre-process a source file using MSBuild variables.
Usage:

<GenerateFileFromTemplate
   TemplateFile="MyFile.cs.in"
   OutputPath="$(IntermediateOutputPath)MyFile.cs"
   Properties="ClassName=Banana;Method=Abc" />

Template file example

// MyFile.cs.in
public class ${ClassName}
{
  public void Method${MethodName}()
  {
     Console.WriteLine("`${NotReplacedDueToBacktick}"");
  }
}

Template syntax:

• variables in the template file use powershell/bash syntax: ${VarName}.
• if you need a file with ${...}, you can escape this with a backtick: `${...}

Justification:
WriteLinesToFile is good, but I've frequently run into problems with it when I need to write a file that has \, /, or ; in it.

Current implementation: https://github.com/aspnet/BuildTools/blob/master/modules/BuildTools.Tasks/GenerateFileFromTemplate.cs, https://github.com/aspnet/BuildTools/blob/master/test/BuildTools.Tasks.Tests/GenerateFileFromTemplateTests.cs

cc @jeffkl @livarcocc

[natemcmaster]

Ping. Anyone from MSBuild interested in this? If I were to make a PR, would you accept it?

Tagging in @rainersigwald since you're the only MSBuild contributor that I know still works on this repo.

[rainersigwald]

This is surely useful, but I'm not sure whether we should add it to core MSBuild. As you mention, we have readlinesfromfile/writelinestofile, which can help in this scenario (but I agree it's clunky).

For more advanced uses, there's T4, which has a nice open-source implementation https://github.com/mono/t4.

I'm concerned that we'd take this, and folks would immediately start asking for more features until it turned into a t4 equivalent, which I don't think is appropriate for MSBuild.

Other @Microsoft/msbuild-maintainers might have different opinions, though.

[cdmihai]

WriteLinesToFile is good, but I've frequently run into problems with it when I need to write a file that has , /, or ; in it.

Can you fix those problems instead? :)

[natemcmaster]

Not sure it's that easy. The problems I ran into seem to related to a much bigger subject with strings vs paths - #1024.

Repro: run this on Linux. Output in both cases has the backslash flipped to a forward slash. { "key": "value /" with a quote" }.

<Project>
    <Target Name="Build">
        <PropertyGroup>
            <Content>{ "key": "value \" with a quote" }</Content>
        </PropertyGroup>

        <WriteLinesToFile Lines="$(Content)" File="out1.txt" Overwrite="true" />
        <WriteLinesToFile Lines="$([MSBuild]::Escape($(Content)))" File="out2.txt" Overwrite="true" />
    </Target>
</Project>

I agree that adding a t4 equivalent is inappropriate for MSBuild and can understand the hesitance to add to MSBuild itself. Is there an alternative? For example, have we considered making a NuGet package of MSBuild tasks that fall into the 'useful but maybe not for everyone' category? The existing implementation of GenerateFileFromTemplate I mentioned has lived in the aspnet build tools repo for years. I think it would be generally useful for others and am looking for the right vehicle to share it with others.

[ericstj]

A big side-effect of ReadLinesToFile / WriteLinesToFile is that it raises all the content into the msbuild session, bloating logs and slowing down the build. It's also not scalable: imagine trying to preprocess/evaluate a 1MB file with a dozen replacements. Additionally it requires people to know MSBuild tricks in order to do anything useful, which becomes a big blocker.

We don't need T4 with a code-execution model, MSBuild has tasks for that. We need a simple pre-processor for simple code-generation tasks.

[cdmihai]

So then the path of least resistance is having something like GenerateFileFromTemplate directly in MSBuild. The other options imply heavier work on msbuild, or extra maintenance to keep a separate nuget package of utility tasks.