Diretrizes para a criação de modelos de texto T4

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

Diretrizes para modelos de tempo de Design 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 os 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 de um 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. Podem ser a modelos de 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 projeto deVisual Studio . 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.

• Focalizar o modelo dos usuários necessidades e vocabulário, não em sua implementação.
  Por exemplo, um aplicativo do site da Web, você esperaria 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. Para evitar 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 alcançada por navegação de qualquer outra.

• Permitir código personalizado: Gere classes parciais.
  Permitir código que você escreve à mão além do código gerado. É incomum que 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 substituir a parte 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 lhe permite adicionar 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 escrita à mão e gerado conteúdo. 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 incluir arquivos 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 chamá-los a partir do modelo de tempo de design. Para fazer isso, use o <#@ assembly #> a diretiva para acessar o projeto separado. Para obter exemplos, consulte "herança em modelos de texto" 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, talvez seja útil mover alguns desse código em métodos que você compilar 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 um 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 altera de requisitos de negócios, 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 ela 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 confiáveis para escrever código escritas à mão e integrá-lo com o gerado de 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 as 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 os métodos e os 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 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 os 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 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 o 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 normal 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 misturar os blocos de texto e de computação. Cada modelo de texto, use a primeira < # de bloquear # code > Para definir variáveis e executar cálculos complexos. A partir do primeiro bloco de texto até o final do modelo ou o primeiro < bloquear o recurso de classe # + # >, evite expressões longas e evitar loops e condicionais, a menos que eles contêm blocos de texto. Essa prática faz com que 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 para incluir arquivos. Use .tt apenas para arquivos que você deseja ser processados como modelos de texto de tempo de execução ou em tempo de design. 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 certificar-se de que ele está correto. Em seguida, altere a 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 os diagramas são o melhor meio adequado. Uma vantagem de um diagrama é o que é fácil discutir com os usuários e outros participantes. Gerando o código de um modelo no nível de requisitos de negócios, você tornar seu código mais flexível quando as necessidades mudam.

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

Consulte também

Conceitos

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

Outros recursos

Geração de texto de tempo de execução usando os modelos de texto T4

Histórico de alterações