1. Regras de escape com barra invertida \

Variável pré‑definida：#set($dog = "woof woof")

1. Nomes de variáveis Velocityprecisam começar com letra. $10.0 não é reconhecido como variável e é exibido como está. Sendo assim, textos como Microsoft $10,0 USD não precisam de escape extra；
2. Barras invertidas consecutivas se anulam aos pares；apenas a combinação \$ consegue escapar o símbolo cifrão；
3. Para exibir $nomeVariavel de forma literal na página, sintaxe padrão：\$dog.

2. Sintaxe de ramificação condicional #if

#set($ages = 22)
#if ($ages <13)
    <h1>Você é uma criança</h1>
#elseif ($ages <18)
    <h1>Você é um adolescente</h1>
#elseif ($ages <35)
    <h1>Você é um jovem adulto</h1>
#elseif ($ages <60)
    <h1>Você é uma pessoa de meia‑idade</h1>
#else
    <h1>Você é idoso</h1>
#end

Resultado da execução

$ages=22, satisfaz 22 < 35 → saída：<h1>Você é um jovem adulto</h1>

Observações

1. Éobrigatório fechar o bloco com #end；sem ele ocorre erro de análise；
2. Palavra‑chave：#elseif（não escreva #else if com espaço, essa sintaxe é inválida）；
3. Operadores suportados：< > <= >= == != && || entre outros；
4. Avaliação de cima para baixo. Quando uma condição for atendida, os ramos seguintes não são executados.

Caracteres de escape e condicionais if

I‑Código da entidade Person no back‑end (C#)

public class Person
{
    private string name;
    public string Name
    {
        get { return name; }
        set { name = value; }
    }
    private int age;
    public int Age
    {
        get { return age; }
        set { age = value; }
    }

    //Construtor sem parâmetros
    public Person(){}
    //Construtor com parâmetros
    public Person(string name, int age)
    {
        this.name = name;
        this.age = age;
    }

    //Método de instância sem parâmetros
    public string getMyName()
    {
        return this.name;
    }

    //Método de instância com múltiplos parâmetros
    public string JoinStr(string str1, string str2)
    {
        return str1 + str2;
    }
}

Definir variáveis de objeto no código back‑end cs

Person pTest = new Person("Tom", 22);
context.Put("pTest", pTest);

II‑Código do modelo VTL & instruções de renderização

Chamada de método<br />
$pTest.getMyName();

#set($a = "hello")
#set($b = "foxdevelop")

$pTest.JoinStr($a, $b);

1. $pTest.getMyName()

• Invoca o método sem parâmetros do objeto getMyName()
• Retorna Tom

No Velocity, ao chamar método sem parâmetros os parênteses () podem ser omitidos. $pTest.getMyName é equivalente a $pTest.getMyName()

2. $pTest.JoinStr($a, $b)

• Chama o método que recebe dois parâmetros do tipo string
• O VTL primeiro interpreta $a e $b, passando os valores reais "hello" e "foxdevelop"
• Retorna o resultado da concatenação: hellofoxdevelop

Resumo

1. Diferença entre maiúsculas e minúsculas no nome do método é obrigatória
   No C#, getMyName() ≠ GetMyName(); o modelo deve seguir exatamente a escrita do código.
2. Passe variáveis diretamente nos parâmetros
   Não use aspas extras. $pTest.JoinStr($a,$b) está correto; evite escrever $pTest.JoinStr("$a","$b") (isso enviará o texto literal “$a”).
3. Diferenciar propriedades de métodos

• $pTest.Name → acessa uma propriedade (getter)
• $pTest.getMyName() → invoca um método

1. Valor de retorno é exibido automaticamente
   Ao escrever diretamente $objeto.metodo() no modelo, o Velocity imprime automaticamente o valor retornado. Se não quiser exibir o resultado, use #set para recebê‑lo:

#set($result = $pTest.JoinStr($a,$b))

III‑Saída renderizada da página final

Chamada de método
Tom;

hellofoxdevelop;

Métodos de extensão

Pré‑definição de variável: #set ($valok = "hello foxdevelop")

Diferenciação entre limite de variável ${} e acesso com .

${valok}.cn Concatenação de variável com sufixo
${valok.cn} Acessa o atributo cn pertencente ao objeto valok

Aspas simples / aspas duplas & junção de variáveis com texto

Código	Resultado renderizado	Explicação do funcionamento
what$valok	whathello foxdevelop	Concatenação direta, o Velocity identifica automaticamente o limite da variável
what$"valok"	what$”valok”	Sintaxe incorreta. Não é permitido colocar aspas logo após $, a variável não será interpretada
what"$valok"	what”hello foxdevelop“	As aspas são apenas caracteres comuns. Dentro do template elas não disparam análise de string, a variável é processada normalmente
what'$valok'	what’hello foxdevelop‘	Mesmo caso acima, aspas simples são caracteres literais comuns
$valokwhat	$valokwhat	Variável não reconhecida! O Velocity interpreta todo valokwhat como nome da variável. Se não encontrar, exibe o texto original
${valok}what	hello foxdevelopwhat	As chaves delimitam a variável, resolve completamente o problema de variável grudada ao texto

Resumo

1. Sempre utilize ${nomeDaVariavel} quando a variável for unida a outro texto
   Errado: $valokwhat; Correto: ${valok}what
2. Para concatenar sufixos de texto: use ${valok}.cn, não escreva ${valok.cn}
3. $!nomeDaVariavel referência silenciosa: retorna valor vazio se a variável não existir, não imprime o texto bruto $xxx
4. Aspas simples e duplas dentro do HTML do template são apenas caracteres comuns; somente dentro da atribuição #set existe diferença: aspas simples (não interpreta variáveis), aspas duplas (interpreta variáveis)

#set($a = "$valok") // Aspas duplas: interpreta variável, a=hello bamn
#set($a = '$valok') // Aspas simples: não interpreta variável, a=$valok

Observações complementares sobre limites de variável

1. Iterar uma lista de strings

Código backend C#

List<string> strList = new List<string>() {"dsd","sdfsd","asdfsd","asdfsdfsd"};
context.Put("strList", strList);

Código do template Velocity

#foreach($str in $strList)
    $str <br/>
#end

Resultado da execução: percorre cada texto da lista e exibe com quebra de linha.

Explicação da sintaxe

#foreach(variavelLoop in coleção) inicia o laço, #end fecha o laço.

2. Iterar lista de classes de entidade personalizadas

1. Entidade Person (C#)

public class Person
{
    private string name;
    public string Name
    {
        get { return name; }
        set { name = value; }
    }
    private int age;
    public int Age
    {
        get { return age; }
        set { age = value; }
    }
    public Person(){}
    public Person(string name,int age)
    {
        this.name = name;
        this.age = age;
    }
}

2. Montar a lista no backend

List<Person> pList = new List<Person>();
pList.Add(new Person("Jack", 1));
pList.Add(new Person("Ben", 11));
pList.Add(new Person("Kevin", 100));
pList.Add(new Person("Simon", 500));
pList.Add(new Person("Lulu", 20));
context.Put("pList", pList);

3. Forma de acessar propriedades no template

Código do template:

#foreach($per in $pList)
<tr>
    <td>$per.name</td>
    <td>$per.age</td>
</tr>
#end

Não consegue ler os dados! Erros ou conteúdo em branco

Princípio fundamental

Regra de acesso a propriedades de objeto no Velocity:
$per.xxx procura automaticamente o método Get público GetXxx()

• $per.name → tenta chamar per.getName()
• $per.age → tenta chamar per.getAge()

Sua entidade:

• Campos privados: name, age
• Propriedades públicas com letra inicial maiúscula: Name, Age, métodos correspondentes GetName(), GetAge()

Forma correta no template:

#foreach($per in $pList)
<tr>
    <td>$per.Name</td>
    <td>$per.Age</td>
</tr>
#end

Observação: No C# as propriedades começam com letra maiúscula; no Java costumam ser minúsculas. Essa é uma armadilha de caixa‑alta/baixa muito comum para iniciantes.

3. Variáveis embutidas úteis do #foreach

Variáveis nativas disponíveis dentro do laço:

Exemplo:

#foreach($per in $pList)
    $foreach.count , Nome: $per.Name
#end

4. Exibição em tabela

<table border="0" cellpadding="0" cellspacing="0">
#foreach($per in $pList)
    <tr>
        <td>$per.Name</td>
        <td>$per.Age</td>
    </tr>
#end
</table>

Resumo

1. #foreach(variavel in coleção) + #end é o laço padrão do Velocity;
2. Para iterar listas comuns, exiba diretamente $variavel;
3. Ao iterar objetos de entidade: use $objeto.nomePropriedade respeitando a capitalização das propriedades públicas, não acesse campos privados;
4. Nas entidades C#, recomenda‑se padronizar propriedades com letra inicial maiúscula e manter o mesmo padrão no template;
5. Se os dados ficarem em branco, verifique primeiramente a capitalização das propriedades e a existência do acessor get.

Iterar coleções

1. Diferença entre comentários de template

Dica de desenvolvimento: use preferencialmente ## / #* *# para comentários de lógica de negócio, evitando vazar anotações no código‑fonte da página.

2. Regras de nomenclatura de variáveis

Regras básicas oficiais

1. O primeiro caractere da variável precisa ser uma letra (a‑z / A‑Z)
2. Caracteres permitidos depois: letras, números 0‑9, sublinhado _, hífen -

O hífen - causa ambiguidade com operadores

#set($name-d = "test")

Ao executar, ocorre o erro: Encountered "name" ... Was expecting one of:
Motivo: o Velocity interpreta - como operador de subtração!
O motor interpreta como $name - d, ou seja, variável $name menos variável d, gerando conflito de sintaxe.

Duas formas de resolver:

1. Recomendado: usar sublinhado (sem ambiguidade, convenção comum)

#set($name_d = "hello world")

2. Delimitar a variável com chaves (compatível com nomes que possuem hífen)

#set(${name-d} = "hello world")
${name-d}

Comparativo exemplos válidos / inválidos

#  Válido
#set($name_d = "sublinhado")
#set($name12d = "inicia com letra mais números")
#set(${name-1_2d} = "hífen exige chaves")

#  Hífen direto sem chaves → erro de análise
#set($name-d = "Erro!")
#set($name-1_2d = "Erro!")

3. Regras de escrita da sintaxe #set

Forma padrão (espaços ao redor dos parênteses são flexíveis, recomenda‑se manter estilo consistente)

#set($nomeVariavel = "valor")

Strings precisam estar dentro de aspas duplas; mantenha espaços ao redor do sinal de igual para melhor legibilidade.

Comentários

1. Função principal

O motor de templates Velocity implementa a reutilização de templates por meio de #include / #parse.
Partes comuns das páginas web, como a navegação do cabeçalho _head.htm e o rodapé com direitos autorais _footer.htm, são extraídas em subtemplates independentes e importadas dentro das páginas, evitando a repetição de código HTML em vários locais.

2. Principais diferenças entre os dois comandos

1. #include("caminho‑do‑arquivo")

Apenas exibe o conteúdo original do arquivo, sem interpretar as variáveis do Velocity ($!{xxx}) presentes no subtemplate

• $!{testinclude} dentro do subtemplate não é renderizado; a string literal $!{testinclude} é exibida diretamente
• Suporta carregar vários arquivos de uma vez: #include("a.htm","b.htm")
• Ideal para: HTML puramente estático e trechos estáticos sem variáveis VTL

2. #parse("caminho‑do‑arquivo")

Importa o subtemplate e interpreta completamente a sintaxe do Velocity. Variáveis enviadas pelo template pai funcionam normalmente dentro do subtemplate.

• $!{testinclude} no subtemplate lê as variáveis de contexto e é substituído pelos valores enviados pelo código backend
• Aceita apenas um único caminho de arquivo e não permite importar múltiplos arquivos simultaneamente
• Ideal para: templates compartilhados com variáveis, como cabeçalhos e rodapés (títulos de página, textos dinâmicos de direitos autorais etc.)

Conteúdo das suas anotações da captura de tela:
#include apenas insere o código do subtemplate no template principal sem interpretá‑lo, enquanto #parse realiza a interpretação

3. Exemplo prático

1. Código backend (.cs)

context.Put("testinclude", "Texto vindo do subtemplate:");

2. Conteúdo do subtemplate _footer.htm

Informação de direitos autorais $!{testinclude}

Cenário ① Usando #include("./themes/default/_footer.htm")

Resultado exibido na página:

Informação de direitos autorais $!{testinclude}

A variável não foi interpretada e o placeholder é impresso literalmente.

Cenário ② Usando #parse("./themes/default/_footer.htm")

Resultado exibido na página:

Informação de direitos autorais Texto vindo do subtemplate:

A variável é renderizada corretamente. Esse é o motivo pelo qual #parse é preferido para templates compartilhados de cabeçalho e rodapé nos projetos.

4. Recomendações de uso

Regra de desenvolvimento:
Use sempre #parse para componentes compartilhados que provavelmente precisarão de variáveis dinâmicas, como menus de navegação e rodapés de direitos autorais. Utilize #include para trechos de texto e estilos totalmente estáticos.

Reutilização de templates

1. Definir variáveis com #set()

Duas formas de declarar variáveis:
Método 1: definir variáveis antecipadamente no código backend C#/Java e ler no modelo;
Método 2: definir variáveis diretamente dentro do modelo com #set() (ponto principal desta lição)

#set($name = "hello foxdevelop.com")
#set($okay = "common baby")
#set($nameokay = "$name|$okay")

• #set(variável = valor) aceita strings, números, arrays, propriedades de objetos e atribuições vindas de outras variáveis
• Tipagem fraca, não precisa declarar o tipo da variável

2. Duas sintaxes e regras para renderizar variáveis

2.1 Formas básicas

• $name: se a variável não existir, imprime o texto literal $name
• $!name: renderização silenciosa; retorna conteúdo vazio quando a variável falta (recomendado para evitar textos estranhos $xxx na página)
• Sintaxe padrão recomendada: ${name} (chaves delimitam explicitamente o nome da variável)

2.2 Exemplo de problema de limite

#set($name = "hello")
$namehello     × o motor interpreta como variável $namehello e não encontra
${name}hello   √ correto: resolve $name e concatena o texto hello

3. Comentários de linha única ##

## Este é um comentário, não aparece na saída final
#set($name = "test") ## comentários no fim da linha também são suportados

1. O conteúdo dos comentáriosnão é enviado para a página renderizada;
2. Não ficam visíveis no código‑fonte do navegador (são descartados durante o processamento do motor de modelos).

4. Tipos de atribuição suportados por #set

## Atribuição de string
#set($name = "hello world")

## Atribuir uma variável a outra
#set($obj= $name)

## Atribuir propriedades de objeto
#set($obj.Friend = "monica")
#set($obj.Blame = $whitehouse.Leak)

## Chamar método e atribuir seu retorno
#set($obj.Plan = $spindoctor.weave($web))

## Atribuição numérica
#set($obj.Number = 123)

## Atribuição de array
#set($obj.Say = ["Not", $my, "fault"])

5. Regras especiais para variáveis inexistentes

$sadfsdfsd

Quando o motor de modelo não consegue resolver a variável:

• Sintaxe normal $sadfsdfsd: imprime literalmente o texto $sadfsdfsd
• Usando $!sadfsdfsd: retorna string vazia quando a variável não existe

Definir variáveis dentro do modelo

1. Classe de entidade PageInfo

Até agora passávamos apenas strings simples. Essa abordagem é ineficiente e dificulta a manutenção. Empacotar dados em objetos de entidade deixa o código muito mais intuitivo.

public class PageInfo
{
    private bool IsShowImage;
    public bool IsShowImage1
    {
        get { return IsShowImage; }
        set { IsShowImage = value; }
    }
}

• Campo privado IsShowImage, exposto pela propriedade pública IsShowImage1
• Acesso dentro do template: $info.IsShowImage1

2. Preencher dados do contexto

//Container de contexto do template
IContext context = new VelocityContext();

PageInfo pi = new PageInfo();
pi.IsShowImage1 = true;

//Armazenar objeto pi com a chave info no contexto
context.Put("info",pi);

//Exemplo de variável string
context.Put("infotitle","Olá");

context.Put("nomeChave",dados)：envia dados para o template, o template lê os dados usando $nomeChave.

II. Sintaxe principal do template Velocity

1. Marcador de diretiva #

Instruções iniciadas com # são diretivas. As mais comuns:
#if, #else, #end, #foreach, #set, #include

Exemplo de renderização condicional:

Prepare duas imagens e coloque‑as na pasta Contents/Images na raiz do site. Altere o valor de IsShowImage1 para exibir imagens diferentes.

#if($info.IsShowImage1)
    <img src="./Contents/Images/a.gif" />
#else
    <img src="./Contents/Images/b.gif" />
#end

Lógica: exibe a.gif quando IsShowImage1=true, senão exibe b.gif

2. Marcador de variável $

• $nomeVariavel：exibe valor da variável
• ${nomeVariavel}：delimita o limite da variável (muito importante!)

Cenário: texto logo após a variável, o motor não consegue identificar onde termina o nome da variável.

Forma incorreta: $infotitlefoxdevelop.com
O motor interpreta tudo como variável infotitlefoxdevelop, que não existe.

Forma correta: ${infotitle}foxdevelop.com
O motor resolve a variável infotitle e concatena a string foxdevelop.com

3. Modificador de saída silenciosa ! → $!nomeVariavel

Comportamento padrão: se a variável não existir, o texto bruto $nomeVariavel é impresso na página
$!nomeVariavel：retorna conteúdo vazio quando variável não existe ou é nula, sem imprimir o cifrão

Exemplo comparativo:

Código de teste completo:

${infotitle}foxdevelop.com <br/>
$!infotitlefoxdevelop.com <br/>
$infotitle <br/>
$!infotitle <br/>

Resumo

1. Sempre envolva variável com ${variavel} quando for concatenar texto depois dela
2. Prefira usar $!{nomeVariavel} em ambiente de produção, evita que valores nulos imprimam $xxx e quebrem o layout
3. Ao testar propriedade booleana com #if, escreva diretamente #if($info.IsShowImage1), não é necessário escrever ==true

Sintaxe básica de templates

Apresentação

Amplamente utilizado em projetos ASP.NET;
O ASP.NET MVC conta com o motor de templates Razor nativo;

Muitos desenvolvedores optam pelo NVelocity quando querem adotar o padrão MVC em projetos tradicionais com páginas .aspx.

O NVelocity não recebe mais atualizações e só é utilizado em projetos legados do .NET Framework. Para projetos novos, dê preferência a motores modernos como Razor e Handlebars.NET.

Relação entre versões e o .NET Framework

Velocity é um motor de templates tradicional para Java, com sintaxe compacta que usa # e $ como marcadores. O NVelocity traz essa sintaxe integralmente para o ambiente .NET;

Download

A última atualização oficial ocorreu em 2018, sendo a versão mais recente a 1.2.0

Você pode baixar o código no endereço abaixo

Trata-se de um projeto open source hospedado no GitHub castleproject/NVelocity: Castle’s NVelocity

O arquivo baixado oficialmente não contém uma DLL já compilada. Você pode baixar o código fonte e compilar manualmente, ou adicionar o projeto diretamente à sua solução.

Abra o arquivo sln no Visual Studio

A última versão é baseada no .NET Core 2.1. Recomenda-se atualizar o projeto para o .NET 4.8

Após compilar, as DLLs estarão disponíveis no diretório de saída

Depois basta importar o arquivo em outros projetos ASP.NET Web. Adicione o NVelocity.dll ao seu projeto web.

Integração ao projeto

Adicione a referência ao assembly NVelocity.dll no projeto
Vantagem principal: com esse motor, fica muito simples implementar troca de múltiplos templates (mudança de tema) no site

Crie uma pasta chamada Themes na raiz do site, que funcionará como diretório principal de todos os templates
Dentro de Themes, crie subpastas para cada tema, como nos exemplos:

Crie a pasta Themes na raiz web como diretório de temas

Diretório de temas

Em seguida, crie uma pasta default para o template padrão
Você poderá adicionar outros conjuntos depois: Themes/blue, Themes/dark e assim por diante

Raiz do site
└── Themes
    ├── default      # Arquivos do tema padrão
    ├── dark         # Arquivos do tema escuro
    └── blue         # Arquivos do tema azul

Em tempo de execução, o nome do tema ativo é lido da configuração e o NVelocity carrega os templates da pasta correspondente.
A troca de template funciona alterando apenas o caminho configurado para a pasta de temas, sem necessidade de mudar o código de regras de negócio.
Ideal para projetos antigos ASP.NET WebForm (.aspx) que precisam de troca de visual na área pública.

aspx

Crie uma nova página aspx na raiz do site: Register.aspx, usada como exemplo de acesso.

Dentro de Themes/default, crie o arquivo de template register.htm. Esse arquivo é o template NVelocity e contém código HTML e sintaxe Velocity.

Abra Register.aspx, mantenha apenas a diretiva da página e apague todo o restante do conteúdo HTML:

<%@ Page Language="C#" AutoEventWireup="true" CodeBehind="Register.aspx.cs" Inherits="NVelocityStudy.Web.Register" %>

O arquivo aspx não fará mais a renderização da página, ele só serve como ponto de entrada do controlador. O código-behind chamará o NVelocity para carregar o template register.htm e gerar o conteúdo final.

Raiz do site
├─ Register.aspx          # Ponto de acesso
├─ Register.aspx.cs       # Lógica do código-behind
└─ Themes
    └─ default
        └─ register.htm   # Template NVelocity

Depois escreva o código em Register.aspx.cs para carregar o template register.htm do tema atual, enviar o modelo de dados e gerar o HTML final.

Para trocar de tema, basta alterar o caminho do diretório para carregar o arquivo register.htm da pasta do tema escolhido.

aspx.cs

Abra o arquivo de código-behind Register.aspx.cs. Implemente a lógica de renderização do NVelocity dentro do método Page_Load, executado para processar o template quando a página carregar.

using System;
using System.Collections.Generic;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;

namespace NVelocityStudy.Web
{
    public partial class Register : System.Web.UI.Page
    {
        protected void Page_Load(object sender, EventArgs e)
        {
            // Insira aqui o código para carregar o template e renderizar a página com NVelocity
        }
    }
}

Adicione o código abaixo dentro de Page_Load

protected void Page_Load(object sender, EventArgs e)
{
    //Passo 1: Criar instância do VelocityEngine
    VelocityEngine ve = new VelocityEngine();

    //Passo 2: Inicializar configurações do motor
    ExtendedProperties pros = new ExtendedProperties();
    pros.AddProperty(RuntimeConstants.RESOURCE_LOADER, "file"); // Carregar templates por arquivo
    pros.AddProperty(RuntimeConstants.FILE_RESOURCE_LOADER_PATH, Server.MapPath(@"")); // Diretório raiz dos templates
    ve.Init(pros); // Inicializar motor com as configurações

    //Passo 3: Ler arquivo de template
    Template template = ve.GetTemplate("themes/default/register.htm");

    //Passo 4: Criar contexto e enviar variáveis ao template
    IContext context = new VelocityContext();
    context.Put("websiteName", "FoxDevelop");
    context.Put("domainName", "foxdevelop.com");

    //Passo 5: Combinar template e dados para renderizar HTML
    StringWriter writer = new StringWriter();
    template.Merge(context, writer); // O resultado renderizado é salvo no writer

    //Passo 6: Enviar conteúdo para o navegador
    Response.Write(writer.ToString().Replace("\r\n", "<br/>"));
}

Esse código faz a leitura do arquivo HTML de template, cria variáveis e substitui os marcadores presentes no HTML pelos valores correspondentes.

1. Instanciar VelocityEngine: Objeto de motor independente, diferente da chamada global estática Velocity.Init(). Suporta múltiplas configurações separadas.
2. Inicialização e configuração do motor

• RESOURCE_LOADER=file: Define que os templates são carregados de arquivos locais;
• FILE_RESOURCE_LOADER_PATH: Configura o diretório base para busca de templates;
• ve.Init(pros): Carrega as configurações e conclui a inicialização.

3. Carregar template com GetTemplate(): Lê o arquivo themes/default/register.htm com base no diretório raiz configurado.
4. Contexto de dados VelocityContext: Com context.Put(chave, valor) enviamos variáveis C# para o template. Dentro do arquivo htm acessamos elas usando $websiteName e $domainName.
5. Renderização Merge no template: template.Merge(contexto, fluxoSaída) insere as variáveis no template e cria uma string HTML completa. Usamos StringWriter para receber o texto renderizado.
6. Saída via Response: Envia o HTML final ao navegador. Replace("\r\n","<br/>") converte quebras de linha do código fonte em tags HTML de quebra de linha.

Template htm

Edite o arquivo register.htm dentro do diretório de temas

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
    <title></title>
</head>
<body>
    Site: $websiteName <br />
    Domínio: $domainName
</body>
</html>

As duas marcações com $xxxxxxx são os espaços reservados das variáveis criadas no Page_Load. Elas serão substituídas pelos valores definidos durante a renderização.

1. Identificador de variável $nomeDaVariavel $websiteName e $domainName seguem a sintaxe VTL do NVelocity. Os valores são definidos no código com context.Put("websiteName", "FoxDevelop") e o motor faz a substituição automática na renderização:

• $websiteName → FoxDevelop
• $domainName → foxdevelop.com

Resultado da execução

Site: FoxDevelop
Domínio: foxdevelop.com

Apresentação do NVelocity