1. Reglas de escape con barra invertida \

Variable predefinida：#set($dog = "woof woof")

1. Los nombres de variable Velocitydeben empezar por letra. $10.0 no se interpreta como variable y se muestra tal cual. Por lo tanto textos como Microsoft $10,0 USD no necesitan escape adicional；
2. Las barras invertidas consecutivas se cancelan por pares；solo la combinación \$ puede escapar el símbolo dólar；
3. Para mostrar literalmente $nombreVariable en la página, sintaxis estándar：\$dog.

2. Sintaxis condicional de ramas #if

#set($ages = 22)
#if ($ages <13)
    <h1>Eres un niño</h1>
#elseif ($ages <18)
    <h1>Eres un adolescente</h1>
#elseif ($ages <35)
    <h1>Eres un adulto joven</h1>
#elseif ($ages <60)
    <h1>Eres una persona de mediana edad</h1>
#else
    <h1>Eres una persona mayor</h1>
#end

Resultado de ejecución

$ages=22, cumple la condición 22 < 35 → salida：<h1>Eres un adulto joven</h1>

Notas importantes

1. Esobligatorio cerrar el bloque con #end；si falta se produce error de análisis；
2. Palabra clave：#elseif（no escribir #else if con espacio, es sintaxis incorrecta）；
3. Operadores soportados：< > <= >= == != && || y otros；
4. Se evalúa de arriba hacia abajo. Cuando se cumple una condición, las ramas siguientes no se ejecutan.

Caracteres de escape y sentencias if

1. Código de la entidad Person en backend (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; }
    }

    //Constructor sin parámetros
    public Person(){}
    //Constructor con parámetros
    public Person(string name, int age)
    {
        this.name = name;
        this.age = age;
    }

    //Método de instancia sin parámetros
    public string getMyName()
    {
        return this.name;
    }

    //Método de instancia con varios parámetros
    public string JoinStr(string str1, string str2)
    {
        return str1 + str2;
    }
}

Definir variables de objeto en el código backend C#

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

2. Código de plantilla VTL & notas de renderizado

Llamada al método<br />
$pTest.getMyName();

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

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

1. $pTest.getMyName()

• Llamar al método sin parámetros del objeto getMyName()
• Devuelve Tom

Llamada de método sin parámetros en Velocity: los paréntesis () se pueden omitir, $pTest.getMyName equivale a $pTest.getMyName()

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

• Ejecutar método con dos parámetros de cadena
• VTL resuelve primero $a, $b y pasa los valores reales "hello", "foxdevelop"
• Retorna el resultado concatenado: hellofoxdevelop

Resumen

1. El nombre del método distingue mayúsculas y minúsculas
   C# getMyName() ≠ GetMyName(), la plantilla debe coincidir exactamente con la escritura del código.
2. Pasa variables directamente
   No añadas comillas extra, $pTest.JoinStr($a,$b) es correcto; no uses $pTest.JoinStr("$a","$b") (pasará la cadena literal «$a»)
3. Diferencia entre propiedad y método

• $pTest.Name → acceder a propiedad (getter)
• $pTest.getMyName() → llamada a método

1. Los valores devueltos se imprimen automáticamente
   Escribe directamente $objeto.metodo() en la plantilla, Velocity muestra el valor devuelto automáticamente. Usa #set para capturar el resultado sin imprimirlo:

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

3. Salida final renderizada de la página

Llamada al método
Tom;

hellofoxdevelop;

Métodos de extensión

Predefinición de variable：#set ($valok = "hello foxdevelop")

Límite de variable ${} y diferencias de acceso con .

${valok}.cn Concatenar variable + sufijo
${valok.cn} Acceder a la propiedad cn del objeto valok

Comillas simples / dobles & fusión de variables

Código	Resultado renderizado	Explicación
what$valok	whathello foxdevelop	Concatenación directa, Velocity detecta automáticamente el límite de variable
what$"valok"	what$»valok»	Sintaxis no válida. No se puede poner comilla justo después de $, no se interpreta la variable
what"$valok"	what»hello foxdevelop«	Las comillas son caracteres ordinarios dentro de plantilla, no activan análisis de cadena; la variable se resuelve correctamente
what'$valok'	what’hello foxdevelop‘	Mismo comportamiento, las comillas simples son caracteres literales
$valokwhat	$valokwhat	Variable no reconocida. Velocity toma valokwhat como nombre completo de variable y muestra el texto original si no la encuentra
${valok}what	hello foxdevelopwhat	Las llaves delimitan la variable, soluciona la fusión entre variable y texto

Resumen

1. Usa siempre ${nombreVariable} cuando la variable se une a otro texto
   Incorrecto：$valokwhat；Correcto：${valok}what
2. Para añadir sufijo: escribe ${valok}.cn, no ${valok.cn}
3. Referencia silenciosa $!variable: devuelve vacío si no existe la variable, no imprime $xxx
4. Las comillas dentro del HTML de plantilla son caracteres normales；Solo dentro de asignaciones #set las comillas simples (no resuelven variables) y dobles (resuelven variables) tienen comportamiento distinto

#set($a = "$valok") // Comillas dobles: resuelve variable, a=hello bamn
#set($a = '$valok') // Comillas simples: no resuelve variable, a=$valok

Notas complementarias sobre límites de variable

1. Iterar sobre una lista de cadenas

Código backend en C#

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

Código de plantilla Velocity

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

Resultado de ejecución: recorre cada cadena de la lista y la imprime con salto de línea.

Explicación de sintaxis

#foreach(variableBucle in colección) inicia el bucle, #end lo cierra.

2. Iterar sobre lista de clases de entidad personalizadas

1. Entidad 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. Preparar la lista en el 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. Sintaxis para acceder a propiedades en plantilla

Código de plantilla:

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

No se pueden leer los datos : aparecen errores o contenido vacío

Principio fundamental

Reglas de acceso a propiedades de objetos en Velocity:
$per.xxx busca automáticamente el método Get público GetXxx()

• $per.name → intenta invocar per.getName()
• $per.age → intenta invocar per.getAge()

Tu entidad:

• Campos privados: name, age
• Propiedades públicas con primera letra mayúscula: Name, Age, métodos correspondientes GetName(), GetAge()

Sintaxis correcta de plantilla:

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

Nota: En C# las propiedades empiezan con mayúscula; en Java suelen ser minúsculas. Es una trampa común de mayúsculas y minúsculas para quienes empiezan.

3. Variables integradas útiles de #foreach

Variables disponibles directamente dentro del bucle:

Ejemplo:

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

4. Mostrar en tabla

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

Resumen

1. #foreach(variable in colección) + #end es el bucle estándar de Velocity;
2. Para listas normales, imprime directamente $variable;
3. Al iterar objetos de entidad: $objeto.nombrePropiedad respeta la capitalización de las propiedades públicas, no accedas a campos privados;
4. En entidades C# se recomienda usar mayúscula inicial en propiedades y mantener la misma escritura en plantillas;
5. Si los datos aparecen vacíos, revisa primero mayúsculas/minúsculas de propiedades y la existencia del accesor get.

Iterar colecciones

1. Diferencias entre comentarios de plantilla

Recomendación de desarrollo: usa preferiblemente ## / #* *# para comentarios de lógica de negocio, evitando filtrar comentarios en el código fuente de la página.

2. Reglas de nomenclatura de variables

Reglas básicas oficiales

1. El primer carácter de la variable debe ser una letra (a‑z / A‑Z)
2. Caracteres permitidos después: letras, números 0‑9, guion bajo _, guion -

El guion - genera ambigüedad con operadores

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

Al ejecutar salta el error: Encountered "name" ... Was expecting one of:
Causa: Velocity interpreta - como operador de resta!
El motor lo analiza como $name - d, es decir variable $name menos variable d, generando conflicto sintáctico.

Dos soluciones:

1. Recomendado: usar guion bajo (sin ambigüedad, convención habitual)

#set($name_d = "hello world")

2. Delimitar variable con llaves (compatible con nombres que contienen guion)

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

Comparativa ejemplos válidos / inválidos

#  Válido
#set($name_d = "guion bajo")
#set($name12d = "empieza por letra más números")
#set(${name-1_2d} = "guion requiere llaves")

#  Guion directo sin llaves → error de análisis
#set($name-d = "¡Error!")
#set($name-1_2d = "¡Error!")

3. Normas de escritura para la sintaxis #set

Forma estándar (espacios alrededor de paréntesis flexibles, se recomienda mantener un estilo uniforme)

#set($nombreVariable = "valor")

Las cadenas deben ir entre comillas dobles; mantén espacios alrededor del signo igual para mejorar la legibilidad.

Comentarios

1. Función principal

El motor de plantillas Velocity implementa la reutilización de plantillas mediante #include / #parse.
Las partes comunes de una página web como la cabecera de navegación _head.htm y el pie de página con derechos de autor _footer.htm se extraen en subplantillas independientes que se importan, evitando código HTML duplicado.

2. Diferencias clave

1. #include("ruta‑del‑archivo")

Simplemente imprime el contenido original del archivo, sin interpretar las variables Velocity ($!{xxx}) dentro de la subplantilla

• $!{testinclude} dentro de la subplantilla no se renderiza, se muestra literalmente la cadena $!{testinclude}
• Permite cargar varios archivos a la vez: #include("a.htm","b.htm")
• Ideal para: fragmentos HTML estáticos sin variables VTL

2. #parse("ruta‑del‑archivo")

Importa la subplantilla e interpreta toda la sintaxis Velocity. Las variables enviadas desde la plantilla padre funcionan correctamente en la subplantilla.

• $!{testinclude} en la subplantilla lee variables del contexto y muestra los valores proporcionados por el código backend
• Solo admite una ruta de archivo, no permite importar varios archivos simultáneamente
• Ideal para: cabeceras, pies de página y otras plantillas comunes que usan variables (títulos de página, textos dinámicos de copyright…)

Fragmento de tus notas:
#include pega el código de la subplantilla sin interpretarlo, mientras que #parse ejecuta el análisis sintáctico

3. Ejemplo práctico

1. Código backend (.cs)

context.Put("testinclude", "Texto desde subplantilla:");

2. Contenido de la subplantilla _footer.htm

Información de copyright $!{testinclude}

Caso ① usando #include("./themes/default/_footer.htm")

Resultado de salida en la página:

Información de copyright $!{testinclude}

La variable no se interpreta y el marcador se muestra tal cual.

Caso ② usando #parse("./themes/default/_footer.htm")

Resultado de salida en la página:

Información de copyright Texto desde subplantilla:

La variable se resuelve correctamente. Por eso en proyectos reales se prefiere #parse para cabeceras y pies de página compartidos.

4. Recomendaciones de uso

Norma de desarrollo:
Usa #parse para componentes comunes que puedan necesitar valores dinámicos (navegación, pie de página). Usa #include para fragmentos puramente estáticos de texto o estilos.

Reutilización de plantillas

1. Definir variables con #set()

Dos formas de declarar variables:
Método 1: definir variables previamente desde código backend C#/Java y leerlas en la plantilla;
Método 2: definir variables directamente dentro de la plantilla con #set() (punto principal de esta lección)

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

• #set(variable = valor) admite cadenas, números, matrices, propiedades de objetos y asignaciones desde otras variables
• Tipado débil, no hace falta declarar el tipo de la variable

2. Dos sintaxis y normas para renderizar variables

2.1 Formas básicas

• $name: si la variable no existe, imprime literalmente $name
• $!name: renderizado silencioso; devuelve contenido vacío cuando falta la variable (recomendado para evitar textos extraños $xxx en la página)
• Sintaxis estándar recomendada: ${name} (las llaves delimitan explícitamente la variable)

2.2 Ejemplo de problema de límites

#set($name = "hello")
$namehello     × el motor lo interpreta como variable $namehello y no la encuentra
${name}hello   √ correcto: resuelve $name y concatena el texto hello

3. Comentarios de una sola línea ##

## Esto es un comentario, no aparecerá en el resultado final
#set($name = "test") ## también se admiten comentarios al final de línea

1. El texto de los comentarios no se envía a la página renderizada;
2. No se ven en el código fuente del navegador (el motor de plantillas los elimina durante el procesamiento).

4. Tipos de asignación soportados por #set

## Asignación de cadena
#set($name = "hello world")

## Asignar una variable a otra
#set($obj= $name)

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

## Llamar método y asignar su valor devuelto
#set($obj.Plan = $spindoctor.weave($web))

## Asignación numérica
#set($obj.Number = 123)

## Asignación de matriz
#set($obj.Say = ["Not", $my, "fault"])

5. Reglas especiales para variables inexistentes

$sadfsdfsd

Cuando el motor de plantillas no logra resolver la variable:

• Sintaxis normal $sadfsdfsd: imprime literalmente el texto $sadfsdfsd
• Si usas $!sadfsdfsd: devuelve cadena vacía cuando la variable no existe

Definir variables dentro de la plantilla

1. Clase de entidad PageInfo

Hasta ahora solo pasábamos cadenas de texto simples. Esto resulta poco eficiente y dificulta el mantenimiento. Al encapsular los datos en objetos de entidad el código es mucho más claro.

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

• Campo privado IsShowImage, expuesto mediante la propiedad pública IsShowImage1
• Acceso desde plantilla: $info.IsShowImage1

2. Cargar datos en el contexto

//Contenedor de contexto de plantilla
IContext context = new VelocityContext();

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

//Guardar el objeto pi en el contexto con la clave info
context.Put("info",pi);

//Ejemplo de variable de cadena
context.Put("infotitle","Hola");

context.Put("nombreClave",datos)：envía datos a la plantilla, la plantilla los lee con $nombreClave.

II. Sintaxis principal de plantillas Velocity

1. Símbolo de directiva #

Las instrucciones que empiezan por # son directivas. Las más usadas:
#if, #else, #end, #foreach, #set, #include

Ejemplo de renderizado condicional:

Prepara dos imágenes y colócalas en la carpeta Contents/Images de la raíz del sitio web. Cambia el valor de IsShowImage1 para visualizar una imagen u otra.

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

Lógica: muestra a.gif cuando IsShowImage1=true, en caso contrario muestra b.gif

2. Símbolo de variable $

• $nombreVariable：muestra el valor de la variable
• ${nombreVariable}：delimita el límite de variable (¡muy importante!)

Caso práctico: texto justo después de la variable, el motor no distingue dónde termina el nombre de variable.

Forma incorrecta: $infotitlefoxdevelop.com
El motor interpreta todo como una variable infotitlefoxdevelop que no existe.

Forma correcta: ${infotitle}foxdevelop.com
El motor resuelve la variable infotitle y concatena la cadena foxdevelop.com

3. Modificador de salida silenciosa ! → $!nombreVariable

Comportamiento por defecto: si la variable no existe, se imprime tal cual el texto $nombreVariable
$!nombreVariable：si la variable no existe o es null, devuelve vacío sin imprimir el signo dólar

Ejemplo comparativo:

Código de prueba completo:

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

Resumen

1. Si concatenas texto después de una variable, envuélvela siempre con ${variable}
2. En entorno de producción usa preferiblemente $!{nombreVariable}, evita que valores nulos impriman $xxx y rompan el diseño
3. Para comprobar propiedades booleanas con #if escribe directamente #if($info.IsShowImage1), no hace falta poner ==true

Sintaxis básica de plantillas

Introducción

Se usa ampliamente en proyectos ASP.NET;
ASP.NET MVC cuenta con el motor de plantillas Razor integrado;

Muchos desarrolladores eligen NVelocity cuando desean incorporar el patrón MVC a proyectos tradicionales de páginas .aspx.

NVelocity ya no recibe mantenimiento y solo se emplea en proyectos antiguos basados en .NET Framework. En proyectos nuevos, se recomiendan motores modernos como Razor o Handlebars.NET.

Relación entre versiones y .NET Framework

Velocity es un veterano motor de plantillas para Java, con una sintaxis sencilla que usa # y $ como marcadores de plantilla. NVelocity trasplanta completamente esta sintaxis;

Descarga

Su última actualización oficial fue en 2018 y la versión más reciente es la 1.2.0

Puede descargarlo desde la siguiente dirección

Es un proyecto de código abierto alojado en GitHub castleproject/NVelocity: Castle’s NVelocity

El archivo oficial descargado no contiene una DLL compilada. Puede descargar el código fuente y compilarlo por su cuenta, o agregar directamente el proyecto a la solución de su aplicación.

Abra el archivo sln con Visual Studio

La última versión está desarrollada sobre .NET Core 2.1. Se aconseja actualizar el proyecto a .NET 4.8

Tras compilar, encontrará las DLL en el directorio de salida

Luego solo tiene que integrarlo en otros proyectos web ASP.NET. Añada el archivo NVelocity.dll a su proyecto web.

Integración en el proyecto

Agregue la referencia al ensamblado NVelocity.dll en su proyecto
Ventaja principal: este motor facilita implementar el cambio de múltiples plantillas (cambio de temas) en el sitio web

Cree una carpeta llamada Themes en el directorio raíz del sitio web, que servirá como directorio principal de todas las plantillas
Dentro de Themes cree varias carpetas independientes para cada tema, por ejemplo:

Cree la carpeta Themes en el directorio raíz web como directorio de temas

Directorio de temas

A continuación cree una carpeta default para la plantilla predeterminada
Más adelante podrá añadir otros conjuntos de plantillas como Themes/blue, Themes/dark

Directorio raíz web
└── Themes
    ├── default      # Archivos de la plantilla predeterminada
    ├── dark         # Archivos del tema oscuro
    └── blue         # Archivos del tema azul

En tiempo de ejecución se lee el nombre del tema activo desde la configuración y NVelocity carga las plantillas del directorio correspondiente.
Cambiar la plantilla consiste básicamente en modificar la configuración para apuntar a otra carpeta de temas, sin alterar el código de lógica de negocio.
Ideal para proyectos antiguos ASP.NET WebForm (.aspx) que requieren funcionalidad de cambio de apariencia de la interfaz pública.

aspx

Cree una nueva página aspx en el directorio raíz del sitio: Register.aspx, que usaremos como ejemplo de acceso.

Dentro de Themes/default cree un archivo de plantilla register.htm. Este archivo actúa como plantilla NVelocity y contiene código HTML y sintaxis Velocity.

Abra Register.aspx, conserve únicamente la directiva de página y elimine todo el resto del contenido HTML:

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

El archivo aspx ya no se encarga de renderizar la página, solo actúa como punto de entrada del controlador. El código trasero invoca NVelocity para cargar la plantilla register.htm y generar el contenido de salida.

Directorio raíz web
├─ Register.aspx          # Punto de acceso
├─ Register.aspx.cs       # Lógica del código trasero
└─ Themes
    └─ default
        └─ register.htm   # Plantilla NVelocity

Luego escriba el código en Register.aspx.cs para indicar que se cargue la plantilla register.htm del tema activo, pasar el modelo de datos y generar finalmente el HTML.

Si desea cambiar de tema, solo debe modificar la ruta del directorio de temas para cargar el archivo register.htm de la carpeta correspondiente.

aspx.cs

Abra el archivo de código trasero Register.aspx.cs. Escriba la lógica de renderizado de NVelocity dentro del método Page_Load, que se ejecutará para procesar la plantilla al cargarse la página.

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)
        {
            // Escriba aquí el código para cargar la plantilla y renderizar la página con NVelocity
        }
    }
}

Añada el siguiente código dentro de Page_Load

protected void Page_Load(object sender, EventArgs e)
{
    //Paso 1: Crear instancia de VelocityEngine
    VelocityEngine ve = new VelocityEngine();

    //Paso 2: Inicializar configuración del motor
    ExtendedProperties pros = new ExtendedProperties();
    pros.AddProperty(RuntimeConstants.RESOURCE_LOADER, "file"); // Cargar plantillas desde archivos
    pros.AddProperty(RuntimeConstants.FILE_RESOURCE_LOADER_PATH, Server.MapPath(@"")); // Directorio raíz de plantillas
    ve.Init(pros); // Inicializar motor con la configuración

    //Paso 3: Leer archivo de plantilla
    Template template = ve.GetTemplate("themes/default/register.htm");

    //Paso 4: Crear contexto y pasar variables a la plantilla
    IContext context = new VelocityContext();
    context.Put("websiteName", "FoxDevelop");
    context.Put("domainName", "foxdevelop.com");

    //Paso 5: Combinar plantilla y datos para renderizar HTML
    StringWriter writer = new StringWriter();
    template.Merge(context, writer); // El resultado renderizado se guarda en writer

    //Paso 6: Enviar contenido al navegador
    Response.Write(writer.ToString().Replace("\r\n", "<br/>"));
}

Este código lee el archivo HTML de plantilla, crea variables y sustituye los marcadores que aparecen en el HTML por sus valores correspondientes.

1. Instanciar VelocityEngine: Objeto motor independiente, distinto a la llamada estándar global Velocity.Init(). Permite usar múltiples configuraciones separadas.
2. Inicialización y configuración del motor

• RESOURCE_LOADER=file: Especifica que las plantillas se cargan desde archivos locales;
• FILE_RESOURCE_LOADER_PATH: Define el directorio raíz donde se buscan las plantillas;
• ve.Init(pros): Carga la configuración y finaliza la inicialización.

3. Cargar plantilla con GetTemplate(): Lee el archivo themes/default/register.htm tomando como base el directorio raíz configurado.
4. Contexto de datos VelocityContext: Con context.Put(clave, valor) se envían variables C# a la plantilla. Dentro del archivo htm accede a ellas con $websiteName y $domainName.
5. Renderizado Merge de plantillas: template.Merge(contexto, flujoSalida) inserta las variables en la plantilla y genera una cadena HTML completa. Se usa StringWriter para recibir el texto renderizado.
6. Salida mediante Response: Envía el HTML final al navegador. Replace("\r\n","<br/>") convierte los saltos de línea del código fuente en etiquetas HTML de salto de línea.

Plantilla htm

Modifique el archivo register.htm dentro del directorio 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>
    Sitio web: $websiteName <br />
    Dominio: $domainName
</body>
</html>

Las dos expresiones con $xxxxxxx son los marcadores de las variables definidas en Page_Load, y serán sustituidos por sus valores durante el renderizado.

1. Identificador de variable $nombreVariable $websiteName y $domainName corresponden a la sintaxis VTL de NVelocity. Se asignan valores en el código con context.Put("websiteName", "FoxDevelop") y el motor los reemplaza automáticamente al renderizar:

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

Resultado de ejecución

Sitio web: FoxDevelop
Dominio: foxdevelop.com

Introducción a NVelocity