TFService MSBUILD and T4 Code Generation - code-generation

Question

We are using a T4 file to manage our assembly versioning;
Basically we are following these procedure to regenerate our Assembly versionings on each build.
This is done by having the .csproj use the Modeling SDK for VS 2013 in order to customize T4 regeneration configuration with MSBUILD.
This works great! Unfortunately team-build for Team Foundation Service does not appear to support T4 code generation at build time as the instances of VS 12 on the build server do not have the TextTemplating.targets in the default install location; assumedly the Modeling/VS SDKs are not installed on the build server (from the TFService build failure logs):
The imported project "C:\Program Files (x86)\MSBuild\12.0\Microsoft\VisualStudio\v12.0\TextTemplating\Microsoft.TextTemplating.targets" was not found. Confirm that the path in the declaration is correct, and that the file exists on disk.
Are there plans to install the Microsoft-released VS 2013 addons (VS SDK, Modeling SDK, etc) to the build server image?
Is there a work around I can implement so that when I commit my code to Team Foundation Service via Git, the build won't break?
How can I configure TFService's Hosted Build Controller to transform my T4 files during its builds?

Answer 1

I ended up creating a different solution to the task of having the build server auto-version our assemblies. Instead of using T4 to dynamically create an AssemblyInfo.cs file to share via item link to other projects within the solution (and therefore have to deal with the annoyance of figuring out how to keep the regeneration of the file current for this purpose), I avoided T4 altogether. It was too much work integrating with the 3rd party remote build machine, managing the addons and SDKs that allow for T4 manipulation etc. There is a much simpler solution involving MSBuild Community Tasks that I found from this SO question. The solution is elegantly simple compared to T4! Here's how it shakes down:
Each time this project, Application.Versioning.csproj, is built, MSBUILD tasks defined in the 3rd-party, Nuget-installed 'MSBuildCommunity Tasks' library
dynamically generate [AssemblyFileVersion], [AssemblyInformationalVersion], [AssemblyVersion] based off of the current UTC date time and input them into a new file,
AutoVersion.cs, that resides in this project's 'Properties' directory (alongside the AssemblyInfo.cs file). The AssemblyInfo.cs has these assembly attributes
forever culled to avoid build errors of multiply-defined assembly attributes). After generation of AutoVersion.cs (which happens just before build), the compiler
integrates the aforementioned assembly versioning attributes into the built assembly. This versioning reflects the UTC time at which they were built (see below).
Every other .csproj in the .sln subscribes to this dynamic, build-time assembly versioning creating a file link to the generated AutoVersion.cs file.
These assemblies must also have their AssemblyInfo.cs' pruned. The assembly versioning for all subscribing .csprojs in the .sln is done each time the MyApplication.Versioning.csproj
is built (or rebuilt). Here's the .csproj for the versioning project:
<!-- START DYNAMIC ASSEMBLY VERSIONING WORK-->
<!--MSBuild Community Tasks path as installed via the nuget package 'Install-Package MSBuildTasks'-->
<PropertyGroup>
<MSBuildCommunityTasksPath>$(MSBuildThisFileDirectory)..\.build</MSBuildCommunityTasksPath>
<My-PropertiesDir>Properties</My-PropertiesDir>
</PropertyGroup>
<PropertyGroup>
<!--this should only be incremented (starting at zero) for MAJOR application releases this should never be reset only incremented!-->
<ManualMajorVersion>0</ManualMajorVersion>
<!--3 digits maximum should only be manually incremented (starting at zero) for feature releases-->
<!--!this should be reset to '0' at the start of each caldenar Year-->
<ManualMinorVersion>0</ManualMinorVersion>
</PropertyGroup>
<!--Import MSBuild Community Tasks library installed from Nuget -->
<!--This library contains defined MSBUILD tasks useful for dynamically generating Assembly information via MSBUILD https://github.com/loresoft/msbuildtasks-->
<Import Project="$(MSBuildCommunityTasksPath)\MSBuild.Community.Tasks.Targets" />
<Target Name="BeforeBuild">
<Time Format="yy.MM.dd.HHmm" Kind="Utc">
<Output TaskParameter="FormattedTime" PropertyName="My-VersionNumber" />
</Time>
<Message Text="Auto versioning from UTC time: $(My-VersionNumber) ...">
</Message>
<Time Format="yy" Kind="Utc">
<Output TaskParameter="FormattedTime" PropertyName="Year" />
</Time>
<Time Format="MM" Kind="Utc">
<Output TaskParameter="FormattedTime" PropertyName="Month" />
</Time>
<Time Format="dd" Kind="Utc">
<Output TaskParameter="FormattedTime" PropertyName="Day" />
</Time>
<Time Format="HH" Kind="Utc">
<Output TaskParameter="FormattedTime" PropertyName="Hour" />
</Time>
<Time Format="mm" Kind="Utc">
<Output TaskParameter="FormattedTime" PropertyName="Minute" />
</Time>
<ItemGroup>
<My-AssemblyInfo Include="$(My-PropertiesDir)\AutoVersion.cs" />
<Compile Include="#(My-AssemblyInfo)" />
</ItemGroup>
<MakeDir Directories="$(My-PropertiesDir)" />
<PropertyGroup>
<GeneratedAssemblyVersion>$(ManualMajorVersion).$(Year)$(ManualMinorVersion).$(Month)$(Day).$(Hour)$(Minute)</GeneratedAssemblyVersion>
</PropertyGroup>
<AssemblyInfo OutputFile="#(My-AssemblyInfo)" CodeLanguage="CS" AssemblyFileVersion="$(GeneratedAssemblyVersion)" AssemblyInformationalVersion="$(GeneratedAssemblyVersion)" AssemblyVersion="$(GeneratedAssemblyVersion)" Condition="$(GeneratedAssemblyVersion) != '' " />
</Target>
<!-- END DYNAMIC ASSEMBLY VERSIONING WORK-->
as well as unit test to verify for yourself:
/// <summary> A test to validate the configured, auto-generated assembly versioning is working as expected </summary>
[Test]
public void AssemblyVersioningTest()
{
DirectoryInfo currentDirectory = new DirectoryInfo(Directory.GetCurrentDirectory());
DirectoryInfo versioningDir = new DirectoryInfo(currentDirectory.FullName + "\\" + VERSIONING_DYNAMIC_FILE_DIRECTORY);
// verify versioning directory located/loaded/exists
Assert.IsTrue(versioningDir.Exists);
// locate the VERSIONING_DYNAMIC_FILE file within the VERSIONING_DYNAMIC_FILE_DIRECTORY directory
string dynamicFilePath = versioningDir.FullName + "\\" + VERSIONING_DYNAMIC_FILE;
// get the FileInfo for the file that is used to dynamically generate assembly versioning
FileInfo dynamicVersioningFileInfo = new FileInfo(dynamicFilePath);
Assert.IsTrue(dynamicVersioningFileInfo.Exists);
// get the two digit creation Dates/Times for the assembly's file as strings
// since that's what the versioning reflects
DateTime dynamicVersioningFileLastWriteTime = dynamicVersioningFileInfo.LastWriteTime;
#region Created VERSIONING_DYNAMIC_FILE
string dynamicVersioningFileLastWriteTimeYear = dynamicVersioningFileLastWriteTime.ToUniversalTime().ToString("yy");
string dynamicVersioningFileLastWriteTimeMonth = dynamicVersioningFileLastWriteTime.ToUniversalTime().ToString("MM");
string dynamicVersioningFileLastWriteTimeDay = dynamicVersioningFileLastWriteTime.ToUniversalTime().ToString("dd");
string dynamicVersioningFileLastWriteTimeHour = dynamicVersioningFileLastWriteTime.ToUniversalTime().ToString("HH");
string dynamicVersioningFileLastWriteTimeMinute = dynamicVersioningFileLastWriteTime.ToUniversalTime().ToString("mm");
#endregion Created VERSIONING_DYNAMIC_FILE
// get *this* assembly from the .sln using reflection since this assembly consumes/is dependent upon the versioning functionality we
// are testing
Assembly theAssemblyExecutingThisTest = Assembly.GetExecutingAssembly();
// get this assembly's version
// we will investigate this to compare it to a reverse-engineering of what we would
// expect it to be based
AssemblyName testingAssemblyName = theAssemblyExecutingThisTest.GetName();
Version testingAssemblyVersion = testingAssemblyName.Version;
#region Generated Assembly Versioning
// get the first two digits of the assemblyVersion.MinorVersion - these represent the year
string testingAssemblyVersionMinorYear = testingAssemblyVersion.Minor.ToString().Substring(0, 2);
// the rest of the digits represent the manually-configured version and can be 1-3 chars long
string testingAssemblyVersionMinorManual = GetMinorManualFromVersionString(testingAssemblyVersion.Minor.ToString());
string testingAssemblyVersionBuildMonth = testingAssemblyVersion.Build.ToString("D4").Substring(0, 2);
string testingAssemblyVersionBuildDay = testingAssemblyVersion.Build.ToString("D4").Substring(2, 2);
string testingAssemblyVersionRevisionHour = testingAssemblyVersion.Revision.ToString("D4").Substring(0, 2);
string testingAssemblyVersionRevisionMinute = testingAssemblyVersion.Revision.ToString("D4").Substring(2, 2);
#endregion Generated Assembly Versioning
// verify the assembly's minor version: last two digits match of assembly file creation year
// (pad minorversion 4 spaces in case released minor version is empty)
Assert.AreEqual(dynamicVersioningFileLastWriteTimeYear,
testingAssemblyVersionMinorYear,
"Assembly's minor version: last two digits do not match assembly file last write time year");
// verify the assembly's minor version is comprised of two digit 'released minor version' + two digit year of assembly file creation date
Assert.AreEqual(dynamicVersioningFileLastWriteTimeYear + testingAssemblyVersionMinorManual,
testingAssemblyVersionMinorYear + testingAssemblyVersionMinorManual,
"Assembly's minor version: not comprised of two digit year of assembly file last write time date + dynamically-sized 'minor manual version' + ");
// verify the Assembly's build version is comprised of two digit month + two digit day of assembly file creation date
Assert.AreEqual(dynamicVersioningFileLastWriteTimeMonth + dynamicVersioningFileLastWriteTimeDay,
testingAssemblyVersionBuildMonth + testingAssemblyVersionBuildDay,
"Assembly's build version: not comprised of two digit month + two digit day of assembly file last write time date");
// verify the Assembly's revision version is comprised two digit hour + two digit minute of assembly file creation date
Assert.AreEqual(dynamicVersioningFileLastWriteTimeHour + dynamicVersioningFileLastWriteTimeMinute,
testingAssemblyVersionRevisionHour + testingAssemblyVersionRevisionMinute,
"Assembly's revision version: comprised two digit hour + two digit minute of assembly file last write time date");
}

Answer 2

We solved a similar issue by including the V&M SDK files (Microsoft.TextTemplating.Build.Tasks.dll, Microsoft.TextTemplating.targets, Microsoft.VisualStudio.TextTemplating.Sdk.Host.1X.0.dll) in an external_libraries folder in source control.
IMO this is the One True Way to manage 3rd party SDKs in large projects: installation on every individual dev machine and build server is too brittle to be practical.