Ejecutar herramienta personalizada para la solución completa

Question

¿Hay alguna manera de "ejecutar la herramienta personalizada" para una solución completa?

¿Por qué? La herramienta personalizada está en desarrollo y, cuando se realicen cambios, debo actualizar todos los elementos que la utilizan para garantizar que nada se rompa.

Answer 1

Como necesitaba una respuesta para esto y tuve que hacerlo yo mismo, aquí está la solución para "Ejecutar herramienta personalizada".

Si sólo tiene que ejecutar todas las T4 plantillas de nuevo, entonces ya no es VS2012 transformar todo T4 en el menú Construir .

Para VS2017 han eliminado las macros, por lo tanto, siga https://msdn.microsoft.com/en-us/library/cc138589.aspx y haga un complemento con su elemento de menú. P.ej. Nombre sus RefreshAllResxFiles comando y pega este archivo en (La configuración del comando predeterminado duerma incluyen las DLL para VSLangProj, por lo que acaba de encontrar el paquete apropiado en 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); 
    } 
} 

Y la vieja solución de 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 

Answer 2

En Visual Studio 2010 hay un botón en la barra de iconos del navegador de soluciones que ejecutará todas las plantillas t4 en una solución.

En Visual Studio 2012, muestre la barra de herramientas "Crear". Hay un botón en esa barra de herramientas que ejecutará todas las plantillas t4 en una solución.

Answer 3

Puede ejecutar todas las plantillas T4 en una solución en Visual Studio 2010. Haga clic derecho en el espacio superior de la barra de herramientas y habilite la barra de herramientas "Crear". Esto agregará una barra de herramientas con lo siguiente:

• Selección Construir
• Generar solución
• transformar todos plantillas T4
• Cancelar

"Transform plantillas T4 Todos" debe darle lo que querer.

Answer 4

Para cualquier persona que haya comenzado a usar la solución provista en las otras respuestas, pero descubre que ejecutar todas las plantillas en la solución es demasiado largo, y si un subconjunto de las plantillas sería suficiente, entonces es posible ejecutar múltiples plantillas usando los siguientes pasos.

1. Seleccione las plantillas que desea ejecutar en el Explorador de soluciones en Visual Studio. Tenga en cuenta que son los archivos reales los que debe seleccionar: y no la carpeta que los contiene.
2. Haga clic con el botón derecho en uno de los archivos de plantilla seleccionados y seleccione Run Custom Tool en el menú contextual.