Run Custom Tool for entire solution

Question

Is there a way to 'Run Custom Tool' for an entire solution?

Why? The custom tool is under development and when changes are made I need to refresh all the items that use it to make sure nothing breaks.

Sophiasophie

Are you talking about continous integration? – Crucible

Not CI no. We use several t4 files for code generation and it would be good to run the exe which transforms these all whenever we build. – Sophiasophie

Answer 1

Since I needed an answer for this and had to make it myself, here is the solution for "Run Custom Tool".

If you just need to run all your T4 templates again, then since VS2012 there is Transform all T4 in the Build menu.

For VS2017 they have removed macros, so follow https://msdn.microsoft.com/en-us/library/cc138589.aspx and make a plugin with your menu item instead. E.g. Name your command RefreshAllResxFiles, and paste this file in (The default command set doesnt include the dlls for VSLangProj, so just find the appropiate package in NuGet):

internal sealed class RefreshAllResxFiles
{
  public const int CommandId = 0x0100;
  public static readonly Guid CommandSet = new Guid(copy the guid from guidRefreshAllResxFilesPackageCmdSet from the vsct file);
  private readonly Package _package;
  private readonly DTE2 _dte;

  /// <summary>
  /// Initializes a new instance of the <see cref="RefreshAllResxFiles"/> class.
  /// Adds our command handlers for menu (commands must exist in the command table file)
  /// </summary>
  /// <param name="package">Owner package, not null.</param>
  private RefreshAllResxFiles(Package package)
  {
     _package = package ?? throw new ArgumentNullException(nameof(package));

     var commandService = ServiceProvider.GetService(typeof(IMenuCommandService)) as OleMenuCommandService;
     if (commandService != null)
     {
        var menuCommandId = new CommandID(CommandSet, CommandId);
        var menuItem = new MenuCommand(MenuItemCallback, menuCommandId);
        commandService.AddCommand(menuItem);
     }
     _dte = ServiceProvider.GetService(typeof(DTE)) as DTE2;
  }

  public static RefreshAllResxFiles Instance { get; private set; }
  private IServiceProvider ServiceProvider => _package;

  public static void Initialize(Package package)
  {
     Instance = new RefreshAllResxFiles(package);
  }

  /// <summary>
  /// This function is the callback used to execute the command when the menu item is clicked.
  /// See the constructor to see how the menu item is associated with this function using
  /// OleMenuCommandService service and MenuCommand class.
  /// </summary>
  private void MenuItemCallback(object sender, EventArgs e)
  {
     foreach (Project project in _dte.Solution.Projects)
        IterateProjectFiles(project.ProjectItems);
  }

  private void IterateProjectFiles(ProjectItems projectProjectItems)
  {
     foreach (ProjectItem file in projectProjectItems)
     {
        var o = file.Object as VSProjectItem;
        if (o != null)
           ProcessFile(o);
        if (file.SubProject?.ProjectItems != null)
           IterateProjectFiles(file.SubProject.ProjectItems);
        if (file.ProjectItems != null)
           IterateProjectFiles(file.ProjectItems);
     }

  }

  private void ProcessFile(VSProjectItem file)
  {
     if (file.ProjectItem.Name.EndsWith(".resx"))
     {
        file.RunCustomTool();
        Log(file.ProjectItem.Name);
     }
  }
  public const string VsWindowKindOutput = "{34E76E81-EE4A-11D0-AE2E-00A0C90FFFC3}";

  private void Log(string fileName)
  {
     var output = _dte.Windows.Item(VsWindowKindOutput);
     var pane = ((OutputWindow)output.Object).OutputWindowPanes.Item("Debug");
     pane.Activate();
     pane.OutputString(fileName);
     pane.OutputString(Environment.NewLine);
  }
}

And the old solution for macro:

Option Strict Off
Option Explicit Off
Imports System
Imports EnvDTE
Imports EnvDTE80
Imports EnvDTE90
Imports VSLangProj
Imports System.Diagnostics

Public Module RecordingModule
    Sub IterateFiles()
        Dim solution As Solution = DTE.Solution
        For Each prj As Project In solution.Projects
            IterateProjectFiles(prj.ProjectItems)
        Next
    End Sub

    Private Sub IterateProjectFiles(ByVal prjItms As ProjectItems)
        For Each file As ProjectItem In prjItms
            If file.Object IsNot Nothing AndAlso TypeOf file.Object Is VSProjectItem Then
                AddHeaderToItem(file.Object)
            End If
            If file.SubProject IsNot Nothing AndAlso file.SubProject.ProjectItems IsNot Nothing AndAlso file.SubProject.ProjectItems.Count > 0 Then
                IterateProjectFiles(file.SubProject.ProjectItems)
            End If
            If file.ProjectItems IsNot Nothing AndAlso file.ProjectItems.Count > 0 Then
                IterateProjectFiles(file.ProjectItems)
            End If
        Next
    End Sub

    Private Sub AddHeaderToItem(ByVal file As VSProjectItem)
        If file.ProjectItem.Name.EndsWith(".resx") Then
            file.RunCustomTool()
            Log(file.ProjectItem.Name)
        End If
    End Sub
    Private Sub Write(ByVal name As String, ByVal message As String)
        Dim output As Window = DTE.Windows.Item(EnvDTE.Constants.vsWindowKindOutput)
        Dim window As OutputWindow = output.Object
        Dim pane As OutputWindowPane = window.OutputWindowPanes.Item(name)
        pane.Activate()
        pane.OutputString(message)
        pane.OutputString(Environment.NewLine)
    End Sub
    Private Sub Log(ByVal message As String, ByVal ParamArray args() As Object)
        Write("Debug", String.Format(message, args))
    End Sub

    Private Sub Log(ByVal message As String)
        Write("Debug", message)
    End Sub

End Module

Pipes

This is code for a macro. You can add this code in the Macro IDE under Tools > Macros > Macros IDE. – Essene

As of VS2017 4.7.02558 "Transform all T4 templates" is back in the Build menu – Spacetime

@smirkingman: Transform all T4 templates is back in the Build menu, but it appears to be at least partially defunct. It does not run on a dotnetcore v2.0 project. – Subduct

Answer 2

In Visual Studio 2010 there is a button in the icon bar of the solution navigator that will run all of the t4 templates in a solution.

In Visual Studio 2012 show the "Build" toolbar. There is a button in that toolbar that will run all of the t4 templates in a solution.

Allout

It's still there in Visual Studio 2015. – Hamill

Answer 3

You can execute all T4 templates in a solution in Visual Studio 2010. Right-click on the upper toolbar space and enable the "Build" toolbar. This will add a toolbar with the following:

• Build Selection
• Build Solution
• Transform All T4 Templates
• Cancel

"Transform All T4 Templates" should give you what you want.

Interplanetary

I confirmed this is available in VS2017 Enterprise v15.6.2 Also in the menu at least as well as the toolbar – Lophobranch

Answer 4

For anyone who started using the solution provided in the other answers but is finding that running all of the templates in the solution is taking too long - and if a subset of the templates would suffice - then it is possible to run multiple templates using the following steps.

1. Select the templates that you wish to run in the Solution Explorer in Visual Studio. Note that it is the actual files that you should select - not the folder that contains them.
2. Right click on one of the selected template files and select Run Custom Tool from the context menu.

Onofredo