WissensdatenbankPrüfungszentrum
DEDeutsch
Sprache wählen13

CKTIS / C#

Programmarchitektur: DSL-Parser, AST und Interpreter

Trennen Sie die Syntax einer kleinen domänenspezifischen Sprache von ihrer Ausführung. Ein Parser erstellt einen abstrakten Syntaxbaum, und ein AST-Interpreter berechnet anhand seiner Knoten das Ergebnis. Durch diese Trennung lassen sich Texteingabe, Programmdarstellung und Ausführungsregeln unabhängig voneinander testen.

Version: .NET 10; repository net10.0 and LangVersion=preview; feature versions require per-entry verification

Syntax

DSL text → parser → abstract syntax tree (AST) → AST interpreter → result

Die Programmarchitektur legt die Aufgaben der Komponenten und den Datenfluss zwischen ihnen fest. Für eine kleine domänenspezifische Sprache (DSL), die eine eng begrenzte Menge von Operationen beschreibt, verwenden Sie eine Verarbeitungskette: Text → Parser → abstract syntax tree (AST, abstrakter Syntaxbaum) → AST interpreter → Ergebnis. Dies ist ein Entwurfsmuster und keine spezielle C#-Funktion.

Der Parser prüft die Syntax und erstellt AST-Knoten, statt den Befehl bereits beim Einlesen auszuführen. Ein separater Lexer kann zunächst Tokens extrahieren; hier reicht das Aufteilen an Leerzeichen. Ein AST bewahrt die Struktur der Operationen, nicht unbedingt den vollständigen Quelltext. Er ist nicht mit dem vollständigkeitserhaltenden Roslyn-Baum gleichzusetzen, der auch Kommentare und Leerraum speichert.

Das Beispiel erkennt Befehle der Form add <int> <int>. Parse trennt den Text an Leerzeichen, verwirft leere Tokens und erwartet genau drei verbleibende Tokens. Das erste muss das kleingeschriebene add sein. Die anderen beiden müssen sich mit Int32.TryParse unter Verwendung von NumberStyles.AllowLeadingSign und CultureInfo.InvariantCulture als Int32-Werte einlesen lassen. Ein vorangestelltes Vorzeichen ist optional. Int32.TryParse ignoriert NUL-Zeichen (U+0000) am Ende numerischer Tokens, sodass auch eine Ziffer mit nachfolgendem NUL-Zeichen akzeptiert wird. Parse erstellt ein Add mit zwei Number-Knoten. Evaluate, der AST-Interpreter, berechnet die Knotenwerte rekursiv; er erzeugt weder Maschinencode noch IL. Die Eingabe add 2 3 ergibt 5.

Durch die Trennung der Schritte lassen sich Parser und Interpreter unabhängig testen. Parse löst FormatException aus, wenn nicht genau drei Tokens vorliegen, das erste Token nicht add lautet oder sich eines der beiden numerischen Tokens nicht einlesen lässt. Eine Addition außerhalb des Int32-Bereichs führt wegen checked zu OverflowException. Diese Sprache ist bewusst minimal und unterstützt keine verschachtelten Ausdrücke. Ergänzen Sie bei einer Erweiterung Diagnosen mit Textpositionen sowie Grenzen für Eingabelänge und Baumtiefe; die Aufteilung in Schritte allein macht die Ausführung nicht vertrauenswürdiger Programme nicht sicher.

Beispiele

using System;
using System.Globalization;

Expr ast = Parse("add 2 3");
Console.WriteLine(Evaluate(ast).ToString(CultureInfo.InvariantCulture));

static Expr Parse(string text)
{
    string[] tokens = text.Split(' ', StringSplitOptions.RemoveEmptyEntries);
    if (tokens.Length != 3 || tokens[0] != "add" ||
        !int.TryParse(tokens[1], NumberStyles.AllowLeadingSign,
            CultureInfo.InvariantCulture, out int left) ||
        !int.TryParse(tokens[2], NumberStyles.AllowLeadingSign,
            CultureInfo.InvariantCulture, out int right))
        throw new FormatException("Expected: add <int> <int>");

    return new Add(new Number(left), new Number(right));
}

static int Evaluate(Expr expr) => expr switch
{
    Number n => n.Value,
    Add a => checked(Evaluate(a.Left) + Evaluate(a.Right)),
    _ => throw new InvalidOperationException("Unknown AST node.")
};

abstract record Expr;
sealed record Number(int Value) : Expr;
sealed record Add(Expr Left, Expr Right) : Expr;

Ergebnis

5

Der angezeigte Code und das angegebene Ergebnis wurden in einer isolierten Umgebung mit der im Prüfnachweis für genau diese Version dokumentierten Methode verifiziert.

Quellen