Nota
O acesso a esta página requer autorização. Pode tentar iniciar sessão ou alterar os diretórios.
O acesso a esta página requer autorização. Pode tentar alterar os diretórios.
Um modelo de texto contém o texto que será gerado a partir dele. Por exemplo, um modelo que cria uma página da Web conterá "<html>..." e todas as outras partes padrão de uma página HTML. Inseridos no modelo são blocos de controle, que são fragmentos de código de programa. Os blocos de controle fornecem valores variáveis e permitem que partes do texto sejam condicionais e repetidas.
Essa estrutura torna um modelo fácil de desenvolver, porque você pode começar com um protótipo do arquivo gerado e inserir incrementalmente blocos de controle que variam o resultado.
Os modelos de texto são compostos pelas seguintes partes:
Diretivas - elementos que controlam como o modelo é processado.
Blocos de texto - conteúdo que é copiado diretamente para a saída.
Blocos de controle - código de programa que insere valores variáveis no texto e controla partes condicionais ou repetidas do texto.
Para experimentar os exemplos deste tópico, copie-os para um ficheiro de modelo, como descrito em Geração de Código em Tempo de Design usando modelos de texto T4. Depois de editar o arquivo de modelo, salve-o e inspecione a saída .txt arquivo.
Diretivas
As diretivas de modelo de texto fornecem instruções gerais para o mecanismo de modelagem de texto sobre como gerar o código de transformação e o arquivo de saída.
Por exemplo, a diretiva a seguir especifica que o arquivo de saída deve ter uma extensão .txt:
<#@ output extension=".txt" #>
Para obter mais informações sobre diretivas, consulte T4 Text Template Directives.
Blocos de texto
Um bloco de texto insere texto diretamente no arquivo de saída. Não há formatação especial para blocos de texto. Por exemplo, o modelo de texto a seguir produzirá um arquivo de texto que contém a palavra "Olá":
<#@ output extension=".txt" #>
Hello
Blocos de controle
Blocos de controle são seções de código de programa que são usadas para transformar os modelos. A linguagem padrão é C#, mas para usar o Visual Basic, você pode escrever esta diretiva no início do arquivo:
<#@ template language="VB" #>
O idioma no qual você escreve o código nos blocos de controle não está relacionado ao idioma do texto gerado.
Blocos de controle padrão
Um bloco de controle padrão é uma seção do código do programa que gera parte do arquivo de saída.
Você pode misturar qualquer número de blocos de texto e blocos de controle padrão em um arquivo de modelo. No entanto, você não pode colocar um bloco de controle dentro de outro. Cada bloco de controle padrão é delimitado pelos símbolos <# ... #>.
Por exemplo, o seguinte bloco de controle e bloco de texto fazem com que o arquivo de saída contenha a linha "0, 1, 2, 3, 4 Olá!":
<#
for(int i = 0; i < 4; i++)
{
Write(i + ", ");
}
Write("4");
#> Hello!
Em vez de usar instruções explícitas Write() , você pode intercalar texto e código. O exemplo a seguir imprime "Olá!" quatro vezes:
<#
for(int i = 0; i < 4; i++)
{
#>
Hello!
<#
}
#>
Você pode inserir um bloco de texto sempre que uma Write(); instrução for permitida no código.
Observação
Quando incorporas um bloco de texto numa instrução composta, como num ciclo ou condicional, deves sempre usar chaves {...} para conter o bloco de texto.
Blocos de controle de expressão
Um bloco de controle de expressão avalia uma expressão e a converte em uma cadeia de caracteres. Isso é inserido no arquivo de saída.
Os blocos de controle de expressão são delimitados pelos símbolos <#= ... #>
Por exemplo, o seguinte bloco de controle faz com que o arquivo de saída contenha "5":
<#= 2 + 3 #>
Observe que o símbolo de abertura tem três caracteres "<#=".
A expressão pode incluir qualquer variável que esteja no escopo. Por exemplo, este bloco imprime linhas com números:
<#@ output extension=".txt" #>
<#
for(int i = 0; i < 4; i++)
{
#>
This is hello number <#= i+1 #>: Hello!
<#
}
#>
Blocos de controle de características de classe
Um bloco de controle de recurso de classe define propriedades, métodos ou qualquer outro código que não deve ser incluído na transformação principal. Os blocos de recursos de classe são freqüentemente usados para funções auxiliares. Normalmente, os blocos de recursos de classe são colocados em arquivos separados para que possam ser incluídos por mais de um modelo de texto.
Os blocos de controle de recurso de classe são delimitados pelos símbolos <#+ ... #>
Por exemplo, o seguinte arquivo de modelo declara e usa um método:
<#@ output extension=".txt" #>
Squares:
<#
for(int i = 0; i < 4; i++)
{
#>
The square of <#= i #> is <#= Square(i+1) #>.
<#
}
#>
That is the end of the list.
<#+ // Start of class feature block
private int Square(int i)
{
return i*i;
}
#>
As características da classe devem ser colocadas no final do arquivo no qual estão escritas. No entanto, você pode <#@include#> um arquivo que contém um recurso de classe, mesmo se a include diretiva seja seguida por blocos padrão e texto.
Para obter mais informações sobre blocos de controle, consulte Blocos de controle de modelo de texto.
Os blocos de recursos de classe podem conter blocos de texto
Você pode escrever um método que gera texto. Por exemplo:
List of Squares:
<#
for(int i = 0; i < 4; i++)
{ WriteSquareLine(i); }
#>
End of list.
<#+ // Class feature block
private void WriteSquareLine(int i)
{
#>
The square of <#= i #> is <#= i*i #>.
<#+
}
#>
É particularmente útil colocar um método que gera texto em um arquivo separado que pode ser incluído por mais de um modelo.
Usando definições externas
Assemblies
Os blocos de código do seu modelo podem usar tipos definidos nos assemblies .NET mais frequentemente usados, como o System.dll. Além disso, pode referenciar outros assemblies .NET ou os seus próprios. Você pode fornecer um nome de caminho ou o nome forte de um assembly:
<#@ assembly name="System.Xml" #>
Você deve usar nomes de caminho absolutos ou nomes de macro padrão no nome do caminho. Por exemplo:
<#@ assembly name="$(SolutionDir)library\MyAssembly.dll" #>
A diretiva assembly não tem efeito em um modelo de texto pré-processado.
Para obter mais informações, consulte Diretiva de montagem T4.
Espaços de nomes
A diretiva de importação é a mesma que a using cláusula em C# ou a imports cláusula no Visual Basic. Ele permite que você faça referência a tipos em seu código sem usar um nome totalmente qualificado:
<#@ import namespace="System.Xml" #>
Você pode usar quantas diretivas assembly e import quiser. Você deve colocá-los antes dos blocos de texto e controle.
Para obter mais informações, consulte Diretiva de importação T4.
Incluindo código e texto
A include diretiva insere texto de outro arquivo de modelo. Por exemplo, esta diretiva insere o conteúdo de test.txt.
<#@ include file="c:\test.txt" #>
O conteúdo incluído é processado quase como se fizesse parte do modelo de texto incluído. No entanto, você pode incluir um arquivo que contém um bloco <#+...#> de recurso de classe, mesmo que a diretiva include seja seguida por texto comum e blocos de controle padrão.
Para obter mais informações, consulte T4 Include Directive.
Métodos utilitários
Existem vários métodos como Write() que estão sempre disponíveis para si num bloco de controlo. Eles incluem métodos para ajudá-lo a recuar a saída e para relatar erros.
Você também pode escrever seu próprio conjunto de métodos de utilidade.
Para obter mais informações, consulte Métodos do utilitário de modelo de texto.
Transformando dados e modelos
A aplicação mais útil para um modelo de texto é gerar material com base no conteúdo de uma fonte, como um modelo, banco de dados ou arquivo de dados. Seu modelo extrai e reformata os dados. Uma coleção de modelos pode transformar essa fonte em vários arquivos.
Há várias abordagens para ler o arquivo de origem.
Leia um arquivo no modelo de texto. Esta é a maneira mais simples de obter dados no modelo:
<#@ import namespace="System.IO" #>
<# string fileContent = File.ReadAllText(@"C:\myData.txt"); ...
Carregue um arquivo como um modelo navegável. Um método mais poderoso é ler os dados como um modelo, que o código de modelo de texto pode percorrer. Por exemplo, você pode carregar um arquivo XML e navegar nele com expressões XPath. Você também pode usar xsd.exe para criar um conjunto de classes com as quais você pode ler os dados XML.
Edite o arquivo de modelo em um diagrama ou formulário. Domain-Specific Language Tools fornece ferramentas que permitem editar um modelo como um diagrama ou formulário do Windows. Isso facilita a discussão do modelo com os usuários do aplicativo gerado. Domain-Specific Language Tools também cria um conjunto de classes fortemente tipadas que refletem a estrutura do modelo. Para obter mais informações, consulte Gerando código a partir de uma linguagem Domain-Specific.
Caminhos de arquivo relativos em modelos de tempo de design
Em um modelo de texto em tempo de design, se você quiser fazer referência a um arquivo em um local relativo ao modelo de texto, use this.Host.ResolvePath(). Também deve definir hostspecific="true" na diretiva template.
<#@ template hostspecific="true" language="C#" #>
<#@ output extension=".txt" #>
<#@ import namespace="System.IO" #>
<#
// Find a path within the same project as the text template:
string myFile = File.ReadAllText(this.Host.ResolvePath("MyFile.txt"));
#>
Content of MyFile.txt is:
<#= myFile #>
Também pode obter outros serviços que são fornecidos pelo anfitrião. Para obter mais informações, consulte Acessando o Visual Studio ou outros hosts a partir de um modelo.
Os modelos de texto em tempo de design são executados em um AppDomain separado
Você deve estar ciente de que um modelo de texto em tempo de design é executado em um AppDomain separado da aplicação principal. Na maioria dos casos, isso não é importante, mas você pode descobrir restrições em certos casos complexos. Por exemplo, se você quiser passar dados para dentro ou para fora do modelo de um serviço separado, o serviço deverá fornecer uma API serializável.
(Isso não é verdade para um modelo de texto em tempo de execução, que fornece código que é compilado junto com o resto do código.)
Editando modelos
Editores de modelos de texto especializados podem ser baixados da Galeria Online do Extension Manager. No menu Ferramentas , clique em Gerenciador de extensões. Clique em Galeria Online e use a ferramenta de pesquisa.