Compartilhar via

Instruções para criar modelos de texto T4

  • Artigo

Estas orientações gerais podem ser útil se você estiver gerando o código de programa ou outros recursos de aplicativo em Visual Studio.As regras não forem corrigidas.

Diretrizes para modelos de Design-Time T4

Os modelos de T4 de tempo de design são modelos que geram código em seu Visual Studio o projeto em tempo de design.Para obter mais informações, consulte Geração de código de tempo de design usando modelos de texto T4.

  • Gere variáveis aspectos do aplicativo.
    Geração de código é mais útil para esses aspectos do aplicativo que podem ser alteradas durante o projeto, ou será alterado entre versões diferentes do aplicativo.Separe esses aspectos de variáveis dos aspectos mais invariável, para que você possa determinar mais facilmente o que precisa ser gerado.Por exemplo, se seu aplicativo fornece um site da Web, separe a funções da lógica que define os caminhos de navegação de uma página para outra de fornecimento de página padrão.

  • Codifica os aspectos de variáveis em um ou mais modelos de origem.
    Um modelo é um arquivo ou banco de dados que lê de cada modelo para obter valores específicos para a variáveis partes do código que deve ser gerado.Modelos podem ser bancos de dados, arquivos XML de seu próprio design, diagramas ou linguagens específicas de domínio.Normalmente, um modelo é usado para gerar muitos arquivos em um Visual Studio project. Cada arquivo é gerado a partir de um modelo separado.

    Você pode usar mais de um modelo em um projeto.Por exemplo, você pode definir um modelo para a navegação entre páginas da Web e um modelo separado para o layout das páginas.

  • Concentre-se o modelo nas necessidades dos usuários e o vocabulário, não em sua implementação.
    Por exemplo, em um aplicativo do site da Web, você poderia esperar o modelo para se referir a páginas da Web e hiperlinks.

    Idealmente, escolha uma forma de apresentação adequada para o tipo de informação que o modelo representa.Por exemplo, um modelo de caminhos de navegação através de um site da Web pode ser um diagrama das caixas e setas.

  • Teste o código gerado.
    Use os testes manuais ou automatizados para verificar se o código resultante funciona como os usuários precisam ter.Evite a geração de testes do mesmo modelo do qual o código é gerado.

    Em alguns casos, os testes gerais podem ser executados no modelo diretamente.Por exemplo, você poderia escrever um teste que garante que todas as páginas no site da Web podem ser acessada pela navegação a partir de qualquer outro.

  • Permitir código personalizado: gerar classes parciais.
    Permitir código que você escreve à mão além ao código gerado.É incomum para um esquema de geração de código para ser capaz de levar em conta todas as variações possíveis que podem surgir.Portanto, você deve esperar adicionar ou anular certas partes do código gerado.Onde o material gerado está em um.NET linguagem como Visual C# ou Visual Basic, duas estratégias são especialmente úteis:

    • As classes geradas devem ser parciais.Isso permite que você adicione conteúdo ao código gerado.

    • Classes devem ser geradas em pares, uma herança da outra.A classe base deve conter todas as propriedades e métodos gerados, e a classe derivada deve conter apenas os construtores.Isso permite que seu código escritas à mão substituir qualquer um dos métodos gerados.

    Em outras linguagens geradas como, por exemplo, XML, use o <#@include#> a diretiva para tornar simples combinações de conteúdo gerado e escritas à mão.Em casos mais complexos, talvez você precise escrever uma etapa de pós-processamento que combina o arquivo gerado com quaisquer arquivos de escrita à mão.

  • Mova o material comum para arquivos de inclusão ou modelos de tempo de execução
    Para evitar a repetição semelhantes blocos de texto e o código em vários modelos, use o <#@ include #> diretiva.Para obter mais informações, consulte T4 Diretiva de inclusão.

    Você pode também criar modelos de texto de tempo de execução em um projeto separado e, em seguida, chamá-los a partir do modelo de design-time.Para fazer isso, use o <#@ assembly #> diretiva para acessar o projeto separado.Para obter exemplos, consulte "herança em modelos de texto" no Blog de Gareth Jones.

  • Considere a possibilidade de movimentação de grandes blocos de código em um assembly separado.
    Se você tiver blocos de código grandes e blocos de recurso de classe, ele pode ser útil mover alguns desse código para métodos que você compila em um projeto separado.Você pode usar o <#@ assembly #> diretiva para acessar o código no modelo.Para obter mais informações, consulte T4 Diretiva de Assembly.

    Você pode colocar os métodos em uma classe abstrata que o modelo pode herdar.A classe abstrata deve herdar de Microsoft.VisualStudio.TextTemplating.TextTransformation.Para obter mais informações, consulte T4 Diretriz de modelo.

  • Gerar código, não os arquivos de configuração
    Um método de escrever um aplicativo de variável é escrever código de programa genérico que aceita um arquivo de configuração.Um aplicativo escrito dessa maneira é muito flexível e pode ser reconfigurado quando as necessidades dos negócios mudam, sem a recriação do aplicativo.No entanto, uma desvantagem dessa abordagem é que o aplicativo executará menos bem que um aplicativo mais específico.Além disso, seu código de programa será mais difícil de ler e manter, parcialmente porque tem sempre lidar com os tipos mais genéricos.

    Por outro lado, um aplicativo cujos variáveis partes são gerados antes da compilação pode ser fortemente tipado.Isso torna muito mais fácil e mais confiáveis para escrever código escritas à mão e integrá-lo com o gerado partes do software.

    Para obter todos os benefícios da geração de código, tente gerar código de programa em vez de arquivos de configuração.

  • Usar uma pasta de código gerado
    Coloque os modelos e os arquivos gerados em uma pasta de projeto chamada código gerado, para tornar claro que esses não são arquivos que devem ser editados diretamente.Se você criar código personalizado para substituir ou adicionar classes geradas, coloque essas classes em uma pasta chamada código personalizado.A estrutura de um projeto típico tem esta aparência:

    MyProject
   Custom Code
      Class1.cs
      Class2.cs
   Generated Code
      Class1.tt
          Class1.cs
      Class2.tt
          Class2.cs
   AnotherClass.cs

Diretrizes para modelos de tempo de execução (pré-processado) T4

  • Mova o material comum para modelos herdados
    Você pode usar a herança para compartilhar a métodos e blocos de texto entre os modelos de texto T4.Para obter mais informações, consulte T4 Diretriz de modelo.

    Você também pode usar incluem arquivos que têm modelos de tempo de execução.

  • Mova grandes corpos de código em uma classe parcial.
    Cada modelo de tempo de execução gera uma definição de classe parcial que tem o mesmo nome como o modelo.Você pode escrever um arquivo de código que contém outra definição parcial da mesma classe.Você pode adicionar construtores, campos e métodos para a classe dessa maneira.Esses membros podem ser chamados de blocos de código no modelo.

    Uma vantagem de se fazer isso é que o código é mais fácil escrever, porque IntelliSense está disponível.Além disso, você pode obter uma separação melhor entre a apresentação e a lógica subjacente.

    Por exemplo, em MyReportText.tt:

    The total is: <#= ComputeTotal() #>

    In MyReportText-Methods.cs:

    private string ComputeTotal() { ... }

  • Permitir código personalizado: fornecer pontos de extensão
    Considere a possibilidade de gerar métodos virtuais em < bloqueia o recurso de classe # + # >.Isso permite que um único modelo a ser usado em muitos contextos sem modificação.Em vez de modificar o modelo, você pode construir uma classe derivada, que fornece a lógica adicional mínima.A classe derivada pode ser qualquer código regular, ou pode ser um modelo de tempo de execução.

    Por exemplo, em MyStandardRunTimeTemplate.tt:

    This page is copyright <#= CompanyName() #>.
<#+ protected virtual string CompanyName() { return ""; } #>

    No código de um aplicativo:

    class FabrikamTemplate : MyStandardRunTimeTemplate
{
  protected override string CompanyName() { return "Fabrikam"; }
}
...
  string PageToDisplay = new FabrikamTemplate().TextTransform();

Diretrizes para todos os modelos de T4

  • Separar a coleta de dados de geração de texto
    Tente evitar a mistura de computação e blocos de texto.Cada modelo de texto, use a primeira < # code Bloquear # > Para definir variáveis e realizar cálculos complexos.A partir do primeiro bloco de texto para baixo até o final do modelo ou a primeira < bloquear o recurso de classe # + # >, evite expressões longas e evitar loops e condicionais, a menos que contenham os blocos de texto.Essa prática torna o modelo mais fácil de ler e manter.

  • Não use .tt arquivos de inclusão
    Usar uma extensão de nome de arquivo diferente, como .ttinclude arquivos de inclusão.Use .tt apenas nos arquivos que você deseja ser processados como tempo de execução ou tempo de criação de modelos de texto.Em alguns casos, Visual Studio reconhece .tt arquivos e automaticamente define suas propriedades para processamento.

  • Inicie cada modelo como um protótipo fixo.
    Escreva um exemplo do código ou texto que você deseja gerar e certifique-se de que ele está correto.Altere sua extensão para .tt e inserir o código que modifica o conteúdo, lendo o modelo de forma incremental.

  • Considere o uso de modelos digitados.
    Embora você possa criar um esquema XML ou banco de dados para os modelos, talvez seja útil criar um idioma específico do domínio (DSL).Uma DSL tem a vantagem de que ele gera uma classe para representar cada nó no esquema e propriedades para representar os atributos.Isso significa que você pode programar em termos de modelo de negócios.Por exemplo:

    Team Members:
<# foreach (Person p in team.Members) 
 { #> 
    <#= p.Name #> 
<# } #>

  • Considere o uso de diagramas para os modelos.
    Muitos modelos mais efetivamente são apresentados e gerenciados simplesmente como tabelas de texto, especialmente se eles forem muito grandes.

    No entanto, para alguns tipos de requisitos de negócios, é importante esclarecer conjuntos complexos de relações e fluxos de trabalho e diagramas são o meio de melhor adequado.Uma vantagem de um diagrama é que ele é fácil de discutir com os usuários e outros participantes.Gerar código de um modelo no nível de requisitos de negócios, você faz seu código mais flexível quando as necessidades mudam.

    Diagramas de classe e de atividade UML freqüentemente podem ser adaptados para esses fins.Você também pode criar seu próprio tipo de diagrama como uma linguagem específica de domínio (DSL).Código pode ser gerado a partir de UML e de DSLs.Para obter mais informações, consulte Modelando o aplicativo e Modelando o aplicativo.

Consulte também

Conceitos

Geração de código de tempo de design usando modelos de texto T4

Geração de texto de tempo de execução com modelos de texto T4