1. Regeln zum Backslash‑Escape \

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

1. Velocity‑Variablennamenmüssen mit einem Buchstaben beginnen. $10.0 wird nicht als Variable erkannt und unverändert ausgegeben. Bei Text wie Microsoft $10,0 USD ist kein zusätzliches Escapen nötig；
2. Aufeinanderfolgende Backslashes heben sich paarweise auf；nur die Kombination \$ kann das Dollar‑Zeichen escapen；
3. Um $variablenName wörtlich anzuzeigen, Standardschreibweise：\$dog.

2. #if‑Verzweigungs‑Syntax

#set($ages = 22)
#if ($ages <13)
    <h1>Du bist ein Kind</h1>
#elseif ($ages <18)
    <h1>Du bist ein Jugendlicher</h1>
#elseif ($ages <35)
    <h1>Du bist junger Erwachsener</h1>
#elseif ($ages <60)
    <h1>Du bist mittleren Alters</h1>
#else
    <h1>Du bist im Rentenalter</h1>
#end

Ausführungsergebnis

$ages=22, Bedingung 22 < 35 trifft zu → Ausgabe：<h1>Du bist junger Erwachsener</h1>

Hinweise

1. Der Blockmuss mit #end abgeschlossen werden, fehlt er gibt es einen Parse‑Fehler；
2. Schlüsselwort：#elseif（Nicht als #else if mit Leerzeichen schreiben, das ist ungültig）；
3. Unterstützte Operatoren：< > <= >= == != && || u.v.m.；
4. Prüfung läuft von oben nach unten. Sobald eine Bedingung zutrifft, werden alle weiteren Zweige übersprungen.

Escape‑Zeichen und if‑Bedingungen

1. Backend‑Code der Person‑Entität (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; }
    }

    //Parameterloser Konstruktor
    public Person(){}
    //Konstruktor mit Parametern
    public Person(string name, int age)
    {
        this.name = name;
        this.age = age;
    }

    //Parameterlose Instanzmethode
    public string getMyName()
    {
        return this.name;
    }

    //Mehrparameter‑Instanzmethode
    public string JoinStr(string str1, string str2)
    {
        return str1 + str2;
    }
}

Objekt‑Variablen im C#‑Backend‑Code festlegen

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

2. VTL‑Template‑Code & Render‑Hinweise

Methodenaufruf<br />
$pTest.getMyName();

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

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

1. $pTest.getMyName()

• Aufruf der parameterlosen Objekt‑Methode getMyName()
• Rückgabewert Tom

Velocity Aufruf parameterloser Methoden: Klammern () können weggelassen werden, $pTest.getMyName ist gleichbedeutend mit $pTest.getMyName()

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

• Methode mit zwei String‑Parametern aufrufen
• VTL wertet zuerst $a, $b aus und übergibt die Werte "hello", "foxdevelop"
• Gibt das verkettete Ergebnis zurück: hellofoxdevelop

Zusammenfassung

1. Methodennamen beachten Groß‑/Kleinschreibung
   C# getMyName() ≠ GetMyName(), das Template muss exakt zur Quellcode‑Schreibweise passen.
2. Variablen direkt übergeben
   Keine zusätzlichen Anführungszeichen, $pTest.JoinStr($a,$b) ist korrekt; vermeide $pTest.JoinStr("$a","$b") (übergibt den Literal‑String „$a“)
3. Eigenschaft vs. Methode unterscheiden

• $pTest.Name → Zugriff auf Eigenschaft (getter)
• $pTest.getMyName() → Methodenaufruf

1. Rückgabewerte werden automatisch ausgegeben
   Schreibe im Template einfach $Objekt.Methode(), Velocity gibt den Rückgabewert automatisch aus. Nutze #set zum Auffangen des Ergebnisses ohne Ausgabe:

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

3. Finale Seiten‑Render‑Ausgabe

Methodenaufruf
Tom;

hellofoxdevelop;

Erweiterungsmethoden

Variablen‑Voreinstellung：#set ($valok = "hello foxdevelop")

Variablen‑Grenze ${} und Zugriffsunterschied mit .

${valok}.cn Variable + Suffix anhängen
${valok.cn} Zugriff auf Eigenschaft cn des Objekts valok

Einfache / Doppelte Anführungszeichen & Variablen‑Verklebung

Code	Ergebnis	Erläuterung
what$valok	whathello foxdevelop	Direkte Verkettung, Velocity erkennt die Variablengrenze automatisch
what$"valok"	what$“valok“	Ungültige Syntax. Nach $ darf kein Anführungszeichen folgen, Variable wird nicht geparst
what"$valok"	what“hello foxdevelop„	Anführungszeichen sind nur einfache Zeichen im Template, sie lösen keine String‑Auswertung aus; Variable wird normal aufgelöst
what'$valok'	what’hello foxdevelop‚	Gleiches Verhalten, einfache Anführungszeichen sind Literalzeichen
$valokwhat	$valokwhat	Variable nicht erkennbar! Velocity interpretiert valokwhat als kompletten Variablennamen und gibt rohen Text aus, wenn er fehlt
${valok}what	hello foxdevelopwhat	Geschweifte Klammern fixieren die Grenze, löst das Problem von Variable angehängt an Text

Zusammenfassung

1. Nutze immer ${Variablenname}, wenn Variable an Text angrenzt
   Falsch：$valokwhat；Richtig：${valok}what
2. Zum Anhängen von Text: ${valok}.cn schreiben, nicht ${valok.cn}
3. $!Variable stiller Verweis: gibt leer aus, wenn Variable fehlt, statt $xxx anzuzeigen
4. Anführungszeichen im Template‑HTML sind einfache Zeichen；Nur innerhalb von #set‑Zuweisungen verhalten sich einfache (keine Variablenauswertung) und doppelte Anführungszeichen (Variablen auflösen) unterschiedlich

#set($a = "$valok") // Doppelte Anführungszeichen: Variable auflösen, a=hello bamn
#set($a = '$valok') // Einfache Anführungszeichen: keine Auflösung, a=$valok

Ergänzung zu Variablengrenzen

1. Iterieren über eine String‑Liste

C#‑Backend‑Code

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

Velocity‑Template‑Code

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

Ausgabeergebnis: Jeder String der Liste wird in einer Schleife ausgelesen und mit Zeilenumbruch ausgegeben.

Syntaxerklärung

#foreach(Schleifenvariable in Sammlung) startet die Schleife, #end beendet sie.

2. Iterieren über Liste benutzerdefinierter Entitätsklassen

1. Person‑Entität (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. Liste im Backend zusammenbauen

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. Eigenschaftszugriff im Template

Template‑Code:

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

Daten können nicht gelesen werden! Fehler oder leere Ausgabe

Grundlegendes Funktionsprinzip

Regel für den Zugriff auf Objekteigenschaften in Velocity :
$per.xxx sucht automatisch nach der öffentlichen Get‑Methode GetXxx()

• $per.name → versucht per.getName() aufzurufen
• $per.age → versucht per.getAge() aufzurufen

Deine Entität:

• Private Felder: name, age
• Öffentliche Eigenschaften mit Großbuchstaben am Anfang: Name, Age, zugehörige Methoden GetName(), GetAge()

Korrekte Template‑Schreibweise:

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

Hinweis: Bei C#‑Konventionen beginnen Eigenschaften mit Großbuchstaben; Java‑Entitätseigenschaften sind üblicherweise klein geschrieben. Das ist eine häufige Fallgrube bezüglich Groß‑/Kleinschreibung für Einsteiger.

3. Eingebaute nützliche Variablen von #foreach

Innerhalb der Schleife stehen diese Variablen direkt zur Verfügung:

Beispiel:

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

4. Tabellendarstellung

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

Zusammenfassung

1. #foreach(Variable in Sammlung) + #end ist die Standardschleife von Velocity;
2. Bei normaler List‑Iteration gibst du $Variable direkt aus;
3. Iterieren über Entitätsobjekte: $Objekt.Eigenschaftsname Groß‑/Kleinschreibung der öffentlichen Eigenschaften beachten, niemals auf private Felder zugreifen;
4. Bei C#‑Entitäten empfiehlt es sich, Eigenschaften durchgängig mit großem Anfangsbuchstaben zu schreiben und dies auch im Template einzuhalten;
5. Wenn Daten leer angezeigt werden, prüfe zuerst Groß‑/Kleinschreibung der Eigenschaften und Vorhandensein des get‑Accessors.

Über Sammlungen iterieren

1. Unterschiede bei Template‑Kommentaren

Entwicklungshinweis: Nutze für fachliche Code‑Kommentare vorzugsweise ## / #* *#, damit Kommentare nicht im Seitenquellcode auftauchen.

2. Regeln für Variablennamen

Offizielle Grundregeln zur Namensgebung

1. Das erste Zeichen einer Variable muss ein Buchstabe sein (a‑z / A‑Z)
2. Erlaubte Folgezeichen: Buchstaben, Ziffern 0‑9, Unterstrich _, Bindestrich -

Bindestrich - sorgt für Operator‑Mehrdeutigkeit

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

Bei der Ausführung tritt folgender Fehler auf: Encountered "name" ... Was expecting one of:
Grund: Velocity interpretiert - als Subtraktionsoperator!
Der Engine parst es als $name - d, also Variable $name minus Variable d und erzeugt damit einen Syntaxkonflikt.

Zwei Lösungsansätze:

1. Empfohlen: Benennung mit Unterstrich (keine Mehrdeutigkeit, gängige Konvention)

#set($name_d = "hello world")

2. Variablengrenze mit geschweiften Klammern festlegen (unterstützt Namen mit Bindestrich)

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

Gültige / ungültige Beispiele im Vergleich

#  gültig
#set($name_d = "Unterstrich")
#set($name12d = "Buchstabe gefolgt von Zahlen")
#set(${name-1_2d} = "Bindestrich erfordert geschweifte Klammern")

#  Direkter Bindestrich ohne Klammern → Parse‑Fehler
#set($name-d = "Fehler!")
#set($name-1_2d = "Fehler!")

3. Schreibregeln für die #set‑Syntax

Standard‑Schreibweise (Leerzeichen um Klammern sind flexibel, einheitlicher Stil empfohlen)

#set($Variablenname = "Wert")

Zeichenketten müssen in doppelte Anführungszeichen gesetzt werden. Leerzeichen um das Gleichheitszeichen verbessern die Lesbarkeit.

Kommentare

1. Kernfunktion

Die Velocity‑Template‑Engine realisiert Wiederverwendung von Templates mit #include / #parse.
Wiederkehrende Seitenteile wie die Kopf‑Navigation _head.htm oder der Fußbereich mit Copyright‑Hinweis _footer.htm werden in separate Untertemplates ausgelagert und in Seiten eingebunden. Dadurch wird doppelter HTML‑Code vermieden.

2. Wesentliche Unterschiede

1. #include("Dateipfad")

Gibt den Dateiinhalt unverändert aus, ohne Velocity‑Variablen ($!{xxx}) im Untertemplate auszuwerten

• $!{testinclude} im Untertemplate wird nicht gerendert, der Text $!{testinclude} wird wörtlich ausgegeben
• Unterstützt das Einbinden mehrerer Dateien auf einmal: #include("a.htm","b.htm")
• Geeignet für: statisches HTML ohne jegliche VTL‑Variablen

2. #parse("Dateipfad")

Lädt das Untertemplate und wertet die gesamte Velocity‑Syntax aus. Vom Elterntemplate übergebene Variablen funktionieren im Untertemplate.

• $!{testinclude} im Untertemplate liest Kontext‑Variablen und ersetzt diese durch Werte aus dem Backend‑Code
• Akzeptiert nur einen einzelnen Dateipfad; mehrere gleichzeitige Einbindungen sind nicht möglich
• Geeignet für: gemeinsame Kopf‑ und Fußtemplates mit Variablen (Seitentitel, dynamische Copyright‑Texte usw.)

Auszug aus deinen Notizen:
#include fügt den Quelltext des Untertemplates unverändert ein ohne Auswertung, #parse führt die Syntaxauswertung durch

3. Praxisbeispiel

1. Backend‑Code (.cs)

context.Put("testinclude", "Text aus Untertemplate:");

2. Inhalt des Untertemplates _footer.htm

Copyright‑Hinweis $!{testinclude}

Fall ① mit #include("./themes/default/_footer.htm")

Seitenausgabe:

Copyright‑Hinweis $!{testinclude}

Die Variable wird nicht ausgewertet, der Platzhalter wird wörtlich angezeigt.

Fall ② mit #parse("./themes/default/_footer.htm")

Seitenausgabe:

Copyright‑Hinweis Text aus Untertemplate:

Die Variable wird korrekt aufgelöst. Deshalb wird in Projekten für gemeinsame Kopf‑ und Fußbereiche #parse bevorzugt verwendet.

4. Empfohlene Einsatzbereiche

Entwicklungsrichtlinie:
Verwende für gemeinsame Komponenten mit potenziell dynamischen Werten (Navigation, Copyright‑Bereich) durchgängig #parse. Für rein statische Text‑ und Stilfragmente nutze #include.

Template‑Wiederverwendung

1. Variablen definieren mit #set()

Zwei Möglichkeiten zur Variablendefinition:
Methode 1: Variablen im Backend‑Code (C#/Java) vorab definieren und im Template auslesen;
Methode 2: Variablen direkt im Template mit #set() festlegen (Hauptthema dieser Lektion)

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

• #set(Variable = Wert) unterstützt Zeichenketten, Zahlen, Arrays, Objekteigenschaften und Zuweisungen aus anderen Variablen
• Schwache Typisierung; es ist keine Typdeklaration nötig

2. Zwei Schreibweisen und Regeln für die Variablenausgabe

2.1 Grundformen

• $name: Existiert die Variable nicht, wird der Text $name unverändert ausgegeben
• $!name: Stille Ausgabe; gibt leeren Inhalt aus, falls die Variable fehlt (empfohlen, um fremde $xxx‑Texte auf der Seite zu vermeiden)
• Empfohlene Standardschreibweise: ${name} (geschweifte Klammern grenzen den Variablennamen klar ab)

2.2 Beispiel für Abgrenzungsprobleme

#set($name = "hello")
$namehello     × Der Motor interpretiert es als Variable $namehello und findet nichts
${name}hello   √ Korrekt: löst $name auf und hängt den Text hello an

3. Einzeilige Kommentare ##

## Dies ist ein Kommentar, er erscheint nicht im fertigen Output
#set($name = "test") ## Kommentare am Zeilenende sind ebenfalls erlaubt

1. Kommentare werdennicht in die gerenderte Seite übernommen;
2. Sie sind auch im Quelltext der Seite im Browser nicht sichtbar (werden schon bei der Template‑Verarbeitung verworfen).

4. Von #set unterstützte Zuweisungstypen

## Zeichenkettenzuweisung
#set($name = "hello world")

## Variable einer anderen Variable zuweisen
#set($obj= $name)

## Objekteigenschaften belegen
#set($obj.Friend = "monica")
#set($obj.Blame = $whitehouse.Leak)

## Methode aufrufen und Rückgabewert zuweisen
#set($obj.Plan = $spindoctor.weave($web))

## Zahlenzuweisung
#set($obj.Number = 123)

## Array‑Zuweisung
#set($obj.Say = ["Not", $my, "fault"])

5. Sonderregeln bei nicht vorhandenen Variablen

$sadfsdfsd

Wenn die Template‑Engine eine Variable nicht auflösen kann:

• Normale Schreibweise $sadfsdfsd: Gibt den Text $sadfsdfsd wörtlich aus
• Mit $!sadfsdfsd: Gibt eine leere Zeichenkette zurück, falls die Variable fehlt

Variablen im Template festlegen

1.1 PageInfo‑Entitätsklasse

Bisher haben wir nur einfache Zeichenketten übergeben. Das ist ineffizient und erschwert die Wartung. Wenn man Daten in Entitätsobjekte verpackt, wird der Code deutlich übersichtlicher.

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

• Privates Feld IsShowImage, nach außen über die Eigenschaft IsShowImage1 verfügbar
• Zugriff in der Vorlage: $info.IsShowImage1

1.2 Kontextdaten füllen

//Vorlagen‑Kontext‑Container
IContext context = new VelocityContext();

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

//Objekt pi unter dem Schlüssel info im Kontext ablegen
context.Put("info",pi);

//Beispiel für String‑Variable
context.Put("infotitle","Hallo");

context.Put("Schlüsselname",Daten)：Gibt Daten an die Vorlage weiter, die Vorlage liest sie über $Schlüsselname aus.

2. Wichtige Velocity‑Vorlagensyntax

2.1 Direktiv‑Zeichen #

Anweisungen, die mit # beginnen, sind Direktiven. Häufig verwendet:
#if, #else, #end, #foreach, #set, #include

Beispiel für bedingte Darstellung:

Bereiten Sie zwei Bilddateien vor und legen Sie diese unter Contents/Images im Website‑Stammordner ab. Über IsShowImage1 steuern Sie, welches Bild angezeigt wird.

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

Logik: Zeigt a.gif bei IsShowImage1=true, sonst b.gif an

2.2 Variablen‑Zeichen $

• $Variablenname：Gibt den Variablenwert aus
• ${Variablenname}：Variablenbegrenzung (wichtig!)

Anwendungsfall: Text folgt direkt auf eine Variable, die Engine kann die Variable‑Grenze nicht erkennen.

Falsche Schreibweise: $infotitlefoxdevelop.com
Die Engine interpretiert alles als Variable infotitlefoxdevelop, welche nicht existiert.

Richtige Schreibweise: ${infotitle}foxdevelop.com
Die Engine wertet infotitle als Variable aus und hängt die Zeichenkette foxdevelop.com an

2.3 Still‑Ausgabe‑Modifikator ! → $!Variablenname

Standardverhalten: Fehlt die Variable, wird der Text $Variablenname unverändert ausgegeben
$!Variablenname：Gibt Leertext aus, wenn Variable fehlt oder null ist; das‑$‑Zeichen wird nicht ausgegeben

Vergleichsbeispiel:

Vollständiger Testcode:

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

Zusammenfassung

1. Wenn Text hinter eine Variable angehängt wird, immer mit ${Variable} umschließen
2. In Produktivumgebungen bevorzugt $!{Variablenname} verwenden, damit bei Null‑Werten kein rohes $xxx das Layout zerstört
3. Bei #if‑Prüfung auf boolesche Eigenschaften direkt #if($info.IsShowImage1) schreiben, ==true ist überflüssig

Grundlegende Vorlagensyntax

Vorstellung

Weit verbreitet in ASP.NET-Projekten;
Für ASP.NET MVC steht standardmäßig die Razor-Template-Engine zur Verfügung;

Viele Entwickler setzen auf NVelocity, wenn herkömmliche .aspx-Projekte um das MVC-Muster erweitert werden sollen.

NVelocity wird nicht mehr weiterentwickelt und kommt nur noch in alten .NET Framework-Projekten zum Einsatz. Bei neuen Projekten empfehlen sich moderne Template-Engines wie Razor oder Handlebars.NET.

Zuordnung der Versionen zum .NET Framework

Velocity ist eine altbewährte Template-Engine für Java mit einer kompakten Syntax, die # und $ als Template-Markierungen nutzt. NVelocity übernimmt diese Syntax vollständig;

Download

Die letzte offizielle Aktualisierung erfolgte im Jahr 2018, die neueste Version ist 1.2.0

Sie können den Quellcode unter folgender Adresse herunterladen

Das Projekt ist quelloffen und wird auf GitHub gehostet castleproject/NVelocity: Castle’s NVelocity

Beim offiziellen Download handelt es sich nicht um vorkompilierte DLL-Dateien. Sie können den Quellcode herunterladen und selbst kompilieren oder das Projekt direkt zur Projektmappe Ihrer Anwendung hinzufügen.

Öffnen Sie die SLN-Datei mit Visual Studio

Die letzte Version basiert auf .NET Core 2.1. Es empfiehlt sich, das Projekt auf .NET 4.8 zu aktualisieren

Nach dem Kompilieren finden Sie die DLL-Dateien im Ausgabeverzeichnis

Anschließend können Sie die Datei in Ihr anderes ASP.NET Web-Projekt einbinden. Fügen Sie die NVelocity.dll Ihrem Web-Projekt hinzu.

Einbindung im Projekt

Fügen Sie dem Projekt die Assembly NVelocity.dll hinzu
Hauptvorteil: Mit dieser Template-Engine lassen sich unkompliziert mehrere Webseitenvorlagen (Designwechsel) realisieren

Legen Sie im Stammverzeichnis der Webseite einen Ordner namens Themes als Hauptverzeichnis für alle Vorlagen an
Erstellen Sie innerhalb von Themes mehrere Unterordner für einzelne Designs, zum Beispiel:

Erstellen Sie den Ordner Themes im Webstammverzeichnis als Designverzeichnis

Designverzeichnis

Erstellen Sie danach einen Ordner default für die Standardvorlage
Später können Sie weitere Vorlagenordner wie Themes/blue oder Themes/dark hinzufügen

Webstammverzeichnis
└── Themes
    ├── default      # Dateien des Standarddesigns
    ├── dark         # Dateien des dunklen Designs
    └── blue         # Dateien des blauen Designs

Zur Laufzeit wird der aktive Designname aus der Konfiguration ausgelesen, woraufhin NVelocity die Vorlagen aus dem passenden Designordner lädt.
Der Wechsel der Vorlage funktioniert durch die Änderung des konfigurierten Pfades zum Designordner – der eigentliche Geschäftslogikcode bleibt unverändert.
Geeignet für alte ASP.NET WebForm-(aspx)-Projekte zur Umsetzung eines Designwechsels für die Benutzeroberfläche.

aspx

Legen Sie eine neue ASPX-Seite im Webstammverzeichnis an: Register.aspx als Beispiel für den Zugriff.

Erstellen Sie im Ordner Themes/default eine Vorlagendatei namens register.htm. Diese Datei dient als NVelocity-Vorlage und enthält HTML-Code sowie Velocity-Syntax.

Öffnen Sie Register.aspx, behalten Sie ausschließlich die Seitenanweisung bei und entfernen Sie allen übrigen HTML-Inhalt:

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

Die ASPX-Datei übernimmt keine Darstellung des Seiteninhalts mehr, sondern fungiert nur als Einstiegspunkt des Controllers. Der Code-Behind lädt über NVelocity die Vorlage register.htm und gibt den generierten Inhalt aus.

Webstammverzeichnis
├─ Register.aspx          # Zugriffspunkt
├─ Register.aspx.cs       # Logik im Code-Behind
└─ Themes
    └─ default
        └─ register.htm   # NVelocity-Vorlage

Anschließend schreiben Sie den Code in Register.aspx.cs, um die Vorlage register.htm des aktuellen Designs zu laden, das Datenmodell zu übergeben und abschließend HTML zu generieren.

Zum Wechsel des Designs muss nur der Pfad zum Designordner angepasst werden, damit die Datei register.htm aus dem entsprechenden Ordner geladen wird.

aspx.cs

Öffnen Sie die Code-Behind-Datei Register.aspx.cs. Implementieren Sie die Rendering-Logik für NVelocity innerhalb der Methode Page_Load. Die Vorlage wird beim Laden der Seite verarbeitet und ausgegeben.

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)
        {
            // Hier Code zum Laden der Vorlage und Rendern der Seite mit NVelocity einfügen
        }
    }
}

Fügen Sie folgenden Code in Page_Load ein

protected void Page_Load(object sender, EventArgs e)
{
    //Schritt 1: Instanz der VelocityEngine erstellen
    VelocityEngine ve = new VelocityEngine();

    //Schritt 2: Engine-Konfiguration initialisieren
    ExtendedProperties pros = new ExtendedProperties();
    pros.AddProperty(RuntimeConstants.RESOURCE_LOADER, "file"); // Vorlagen aus Dateien laden
    pros.AddProperty(RuntimeConstants.FILE_RESOURCE_LOADER_PATH, Server.MapPath(@"")); // Stammverzeichnis der Vorlagen
    ve.Init(pros); // Engine mit Konfiguration initialisieren

    //Schritt 3: Vorlagendatei einlesen
    Template template = ve.GetTemplate("themes/default/register.htm");

    //Schritt 4: Kontext erstellen und Variablen an die Vorlage übergeben
    IContext context = new VelocityContext();
    context.Put("websiteName", "FoxDevelop");
    context.Put("domainName", "foxdevelop.com");

    //Schritt 5: Vorlage mit Daten zusammenführen und HTML rendern
    StringWriter writer = new StringWriter();
    template.Merge(context, writer); // Das Ergebnis der Darstellung wird im Writer gespeichert

    //Schritt 6: Seite ausgeben
    Response.Write(writer.ToString().Replace("\r\n", "<br/>"));
}

Dieser Code liest die HTML-Vorlagendatei, erstellt Variablen und ersetzt die Platzhalter innerhalb der HTML-Datei durch die zugewiesenen Werte.

1. Instanziierung VelocityEngine: Ein eigenständiges Engine-Objekt, abweichend vom globalen statischen Aufruf Velocity.Init(). Es unterstützt separate unabhängige Konfigurationen.
2. Initialisierung und Konfiguration der Engine

• RESOURCE_LOADER=file: Legt fest, dass Vorlagen aus lokalen Dateien geladen werden;
• FILE_RESOURCE_LOADER_PATH: Legt das Stammverzeichnis für die Vorlagensuche fest;
• ve.Init(pros): Lädt die Konfiguration und schließt die Initialisierung ab.

3. Laden der Vorlage mit GetTemplate(): Liest die Datei themes/default/register.htm ausgehend vom konfigurierten Stammverzeichnis.
4. Datenkontext VelocityContext: Mit context.Put(Schlüssel, Wert) werden C#-Variablen an die Vorlage übergeben. Innerhalb der HTM-Datei greifen Sie mit $websiteName und $domainName auf diese Werte zu.
5. Vorlagen-Rendering per Merge: Mit template.Merge(Kontext, Ausgabestream) werden Variablen in die Vorlage eingefügt und ein vollständiger HTML-String erzeugt. Der generierte Text wird über einen StringWriter aufgefangen.
6. Ausgabe mit Response: Der fertige HTML-Code wird an den Browser gesendet. Replace("\r\n","<br/>") wandelt Zeilenumbrüche des Quellcodes in HTML-Zeilenumbruch-Tags um.

htm-Vorlage

Bearbeiten Sie die Datei register.htm im Designordner

<!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>
    Webseite: $websiteName <br />
    Domain: $domainName
</body>
</html>

Die beiden Ausdrücke mit $xxxxxxx sind Platzhalter für die im Page_Load erstellten Variablen. Während der Darstellung werden sie automatisch durch die entsprechenden Werte ersetzt.

1. Variablenkennzeichnung $Variablenname $websiteName und $domainName sind VTL-Syntax von NVelocity. Im Programmcode werden sie mit context.Put("websiteName", "FoxDevelop") belegt, die Engine ersetzt diese Markierungen beim Rendering:

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

Ergebnis bei Ausführung

Webseite: FoxDevelop
Domain: foxdevelop.com

Einführung in NVelocity