{"id":1788,"date":"2023-05-09T14:02:29","date_gmt":"2023-05-09T07:02:29","guid":{"rendered":"https:\/\/csharptutorial.net\/?page_id=1788"},"modified":"2023-05-09T14:03:15","modified_gmt":"2023-05-09T07:03:15","slug":"csharp-interpreter-pattern","status":"publish","type":"page","link":"https:\/\/www.csharptutorial.net\/csharp-design-patterns\/csharp-interpreter-pattern\/","title":{"rendered":"C# Interpreter Pattern"},"content":{"rendered":"\n

Summary<\/strong>: in this tutorial, you will learn how to use the C# interpreter pattern to build grammar for interpreting a simple language.<\/p>\n\n\n\n

Introduction to the C# interpreter pattern<\/h2>\n\n\n\n

The interpreter pattern is a behavior pattern that allows you to build an interpreter for a simple language and specifies how to evaluate sentences or expressions in that language.<\/p>\n\n\n\n

The interpreter pattern defines the grammar of the language and provides a way to evaluate the grammar.<\/p>\n\n\n\n

Typically, the grammar consists of a set of classes<\/a>, each of which represents a rule in the grammar. The interpreter pattern combines the rules to form a hierarchy with the most basic rules at the bottom and the more complex rules at the top,<\/p>\n\n\n\n

For example, the following picture illustrates an expression 10 + 20 * (2 + 3) as a tree of rules:<\/p>\n\n\n

\n
\"C#<\/figure>\n<\/div>\n\n\n

To evaluate a sentence or expression, the interpreter takes input and applies the grammar rules to it. More specifically, the interpreter recursively evaluates the rules, applies the most basic rules first, and combines the result of each evaluation until the entire sentence or expression is evaluated.<\/p>\n\n\n\n

The result of the evaluation is typically a value or a set of values, depending on the specific application of the interpreter.<\/p>\n\n\n\n

The following UML diagram illustrates the Interpreter pattern:<\/p>\n\n\n

\n
\"C#<\/figure>\n<\/div>\n\n\n

The interpreter pattern involves the following participants:<\/p>\n\n\n\n

    \n
  • AbstractExpression<\/code> is an abstract class or an interface that has interpret()<\/code> method for evaluating the expression.<\/li>\n\n\n\n
  • TerminalExpression<\/code><\/code> is a concrete implementation of the abstract expression. The TerminalExpression<\/code><\/code> represents the simplest elements of the grammar such as variables, constants, or literals. A terminal expression cannot be further decomposed into smaller expressions. For example, in an arithmetic expression grammar, a terminal expression could be a number or a variable.<\/li>\n\n\n\n
  • NonTerminalExpression<\/code> represents the more complex elements of the language grammar built from simpler expressions. Unlike a terminal expression, a non-terminal expression can be decomposed into smaller expressions until they reach terminal expressions. For example, in an arithmetic expression grammar, a non-terminal expression could represent a binary operation such as addition, which is built from two terminal expressions.<\/li>\n\n\n\n
  • Context<\/code> is the context in that the interpreter evaluates the expression. It contains the information required for the evaluation of the expression.<\/li>\n\n\n\n
  • Client<\/code> is a class that is responsible for building an expression using the TerminalExpression<\/code> and NonterminalExpression<\/code>. It passes the expression to the interpreter for evaluation.<\/li>\n<\/ul>\n\n\n\n

    For example, the following picture shows the terminal and non-terminal expressions:<\/p>\n\n\n

    \n
    \"C#<\/figure>\n<\/div>\n\n\n

    C# interpreter pattern example<\/h2>\n\n\n\n

    The following program demonstrates how to use the C# interpreter pattern:<\/p>\n\n\n

    namespace<\/span> IterpreterPattern<\/span>;\n\n\/\/ Abstract Expression<\/span>\npublic<\/span> abstract<\/span> class<\/span> Expression<\/span>\n{\n    public<\/span> abstract<\/span> int<\/span> Interpret<\/span>(Context context<\/span>)<\/span>;\n}\n\n\/\/ Terminal Expression<\/span>\npublic<\/span> class<\/span> NumberExpression<\/span> : Expression<\/span>\n{\n    private<\/span> readonly<\/span> int<\/span> number;\n    public<\/span> NumberExpression<\/span>(int<\/span> number<\/span>)<\/span>\n    {\n        this<\/span>.number = number;\n    }\n    public<\/span> override<\/span> int<\/span> Interpret<\/span>(Context context<\/span>)<\/span>\n    {\n        return<\/span> number;\n    }\n}\n\n\/\/ Non-terminal Expression<\/span>\npublic<\/span>  class<\/span> AddExpression<\/span> : Expression<\/span>\n{\n    private<\/span> readonly<\/span> Expression _left;\n    private<\/span> readonly<\/span> Expression _right;\n    public<\/span> AddExpression<\/span>(Expression leftExpression, Expression rightExpression<\/span>)<\/span>\n    {\n        _left = leftExpression;\n        _right = rightExpression;\n    }\n    public<\/span> override<\/span> int<\/span> Interpret<\/span>(Context context<\/span>)<\/span>\n    {\n        return<\/span> _left.Interpret(context) + _right.Interpret(context);\n    }\n}\npublic<\/span> class<\/span> SubtractExpression<\/span> : Expression<\/span>\n{\n    private<\/span> readonly<\/span> Expression _left;\n    private<\/span> readonly<\/span> Expression _right;\n    public<\/span> SubtractExpression<\/span>(Expression leftExpression, Expression rightExpression<\/span>)<\/span>\n    {\n        _left = leftExpression;\n        _right = rightExpression;\n    }\n    public<\/span> override<\/span> int<\/span> Interpret<\/span>(Context context<\/span>)<\/span>\n    {\n        return<\/span> _left.Interpret(context) - _right.Interpret(context);\n    }\n}\n\npublic<\/span> class<\/span> MultiplyExpression<\/span> : Expression<\/span>\n{\n    private<\/span> readonly<\/span> Expression _left;\n    private<\/span> readonly<\/span> Expression _right;\n    public<\/span> MultiplyExpression<\/span>(Expression leftExpression, Expression rightExpression<\/span>)<\/span>\n    {\n        _left = leftExpression;\n        _right = rightExpression;\n    }\n    public<\/span> override<\/span> int<\/span> Interpret<\/span>(Context context<\/span>)<\/span>\n    {\n        return<\/span> _left.Interpret(context) * _right.Interpret(context);\n    }\n}\npublic<\/span> class<\/span> DivideExpression<\/span> : Expression<\/span>\n{\n    private<\/span> readonly<\/span> Expression _left;\n    private<\/span> readonly<\/span> Expression _right;\n    public<\/span> DivideExpression<\/span>(Expression leftExpression, Expression rightExpression<\/span>)<\/span>\n    {\n        _left = leftExpression;\n        _right = rightExpression;\n    }\n    public<\/span> override<\/span> int<\/span> Interpret<\/span>(Context context<\/span>)<\/span>\n    {\n        return<\/span> _left.Interpret(context) \/ _right.Interpret(context);\n    }\n}\n\n\/\/ Context<\/span>\npublic<\/span> class<\/span> Context<\/span>\n{\n    private<\/span> readonly<\/span> Dictionary<string<\/span>, int<\/span>> _variables;\n\n    public<\/span> Context<\/span>(<\/span>)<\/span>\n    {\n        _variables = new<\/span> Dictionary<string<\/span>, int<\/span>>();\n    }\n\n    public<\/span> void<\/span> SetVariable<\/span>(string<\/span> name, int<\/span> value<\/span><\/span>)<\/span>\n    {\n        _variables[name] = value<\/span>;\n    }\n\n    public<\/span> int<\/span> GetVariable<\/span>(string<\/span> name<\/span>)<\/span>\n    {\n        if<\/span> (_variables.TryGetValue(name, out<\/span> var<\/span> value<\/span>))\n        {\n            return<\/span> value<\/span>;\n        }\n        else<\/span>\n        {\n            throw<\/span> new<\/span> ArgumentException($\"Variable '{name}<\/span>' not found.\"<\/span>);\n        }\n    }\n}\n\n\/\/ Client<\/span>\npublic<\/span> class<\/span> Client<\/span>\n{\n    public<\/span> static<\/span> void<\/span> Main<\/span>(string<\/span>[] args<\/span>)<\/span>\n    {\n        var<\/span> context = new<\/span> Context();\n        context.SetVariable(\"x\"<\/span>, 2<\/span>);\n        context.SetVariable(\"y\"<\/span>, 3<\/span>);\n\n        \/\/ -> 10 + 20*(x + y)<\/span>\n        var<\/span> expression = new<\/span> AddExpression(\n            new<\/span> NumberExpression(10<\/span>),\n            new<\/span> MultiplyExpression(  \n                new<\/span> NumberExpression(20<\/span>),\n                new<\/span> AddExpression(\n                    new<\/span> NumberExpression(context.GetVariable(\"x\"<\/span>)),\n                    new<\/span> NumberExpression(context.GetVariable(\"y\"<\/span>))\n                )\n            )\n        );\n\n        var<\/span> result = expression.Interpret(context);\n\n        Console.WriteLine(\"Result: \"<\/span> + result); \n    }\n}<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
    Output:<\/p>\n\n\n
    Result: 110<\/span><\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
    How it works.<\/p>\n\n\n\n
    First, define the abstract class Expression:<\/p>\n\n\n
    public<\/span> abstract<\/span> class<\/span> Expression<\/span>\n{\n    public<\/span> abstract<\/span> int<\/span> Interpret<\/span>(Context context<\/span>)<\/span>;\n}<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
    Second, define the NumberExpression<\/code> class that inherits from the Expression<\/code> class:<\/p>\n\n\n
    public<\/span> class<\/span> NumberExpression<\/span> : Expression<\/span>\n{\n    private<\/span> readonly<\/span> int<\/span> number;\n    public<\/span> NumberExpression<\/span>(int<\/span> number<\/span>)<\/span>\n    {\n        this<\/span>.number = number;\n    }\n    public<\/span> override<\/span> int<\/span> Interpret<\/span>(Context context<\/span>)<\/span>\n    {\n        return<\/span> number;\n    }\n}<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
    The NumberExpression<\/code> serves as a TerminalExpression<\/code>.<\/p>\n\n\n\n
    Third, define the AddExpression<\/code> class that sums up two expressions:<\/p>\n\n\n
    public<\/span> class<\/span> AddExpression<\/span> : Expression<\/span>\n{\n    private<\/span> readonly<\/span> Expression _left;\n    private<\/span> readonly<\/span> Expression _right;\n    public<\/span> AddExpression<\/span>(Expression leftExpression, Expression rightExpression<\/span>)<\/span>\n    {\n        _left = leftExpression;\n        _right = rightExpression;\n    }\n    public<\/span> override<\/span> int<\/span> Interpret<\/span>(Context context<\/span>)<\/span>\n    {\n        return<\/span> _left.Interpret(context) + _right.Interpret(context);\n    }\n}<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
    The AddExpression<\/code> serves as a NonterminalExpression<\/code>.<\/p>\n\n\n\n
    Fourth, define the SubtractExpression<\/code>, MultiplyExpression<\/code>, and DivideExpression<\/code> classes like the AddExpression<\/code> class but subtract, multiply, and divide two numbers respectively.<\/p>\n\n\n
    public<\/span> class<\/span> SubtractExpression<\/span> : Expression<\/span>\n{\n    private<\/span> readonly<\/span> Expression _left;\n    private<\/span> readonly<\/span> Expression _right;\n    public<\/span> SubtractExpression<\/span>(Expression leftExpression, Expression rightExpression<\/span>)<\/span>\n    {\n        _left = leftExpression;\n        _right = rightExpression;\n    }\n    public<\/span> override<\/span> int<\/span> Interpret<\/span>(Context context<\/span>)<\/span>\n    {\n        return<\/span> _left.Interpret(context) - _right.Interpret(context);\n    }\n}\n\npublic<\/span> class<\/span> MultiplyExpression<\/span> : Expression<\/span>\n{\n    private<\/span> readonly<\/span> Expression _left;\n    private<\/span> readonly<\/span> Expression _right;\n    public<\/span> MultiplyExpression<\/span>(Expression leftExpression, Expression rightExpression<\/span>)<\/span>\n    {\n        _left = leftExpression;\n        _right = rightExpression;\n    }\n    public<\/span> override<\/span> int<\/span> Interpret<\/span>(Context context<\/span>)<\/span>\n    {\n        return<\/span> _left.Interpret(context) * _right.Interpret(context);\n    }\n}\npublic<\/span> class<\/span> DivideExpression<\/span> : Expression<\/span>\n{\n    private<\/span> readonly<\/span> Expression _left;\n    private<\/span> readonly<\/span> Expression _right;\n    public<\/span> DivideExpression<\/span>(Expression leftExpression, Expression rightExpression<\/span>)<\/span>\n    {\n        _left = leftExpression;\n        _right = rightExpression;\n    }\n    public<\/span> override<\/span> int<\/span> Interpret<\/span>(Context context<\/span>)<\/span>\n    {\n        return<\/span> _left.Interpret(context) \/ _right.Interpret(context);\n    }\n}<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
    Fifth, define the Context class that maintains a dictionary of variables for the expression:<\/p>\n\n\n
    public<\/span> class<\/span> Context<\/span>\n{\n    private<\/span> readonly<\/span> Dictionary<string<\/span>, int<\/span>> _variables;\n\n    public<\/span> Context<\/span>(<\/span>)<\/span>\n    {\n        _variables = new<\/span> Dictionary<string<\/span>, int<\/span>>();\n    }\n\n    public<\/span> void<\/span> SetVariable<\/span>(string<\/span> name, int<\/span> value<\/span><\/span>)<\/span>\n    {\n        _variables[name] = value<\/span>;\n    }\n\n    public<\/span> int<\/span> GetVariable<\/span>(string<\/span> name<\/span>)<\/span>\n    {\n        if<\/span> (_variables.TryGetValue(name, out<\/span> var<\/span> value<\/span>))\n        {\n            return<\/span> value<\/span>;\n        }\n        else<\/span>\n        {\n            throw<\/span> new<\/span> ArgumentException($\"Variable '{name}<\/span>' not found.\"<\/span>);\n        }\n    }\n}<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
    Finally, define the Client that composes the expression: 10 + 20 * (x + y), where x is 2 and y is 3:<\/p>\n\n\n
    public<\/span> class<\/span> Client<\/span>\n{\n    public<\/span> static<\/span> void<\/span> Main<\/span>(string<\/span>[] args<\/span>)<\/span>\n    {\n        var<\/span> context = new<\/span> Context();\n        context.SetVariable(\"x\"<\/span>, 2<\/span>);\n        context.SetVariable(\"y\"<\/span>, 3<\/span>);\n\n        \/\/ -> 10 + 20*(x + y)<\/span>\n        var<\/span> expression = new<\/span> AddExpression(\n            new<\/span> NumberExpression(10<\/span>),\n            new<\/span> MultiplyExpression(  \n                new<\/span> NumberExpression(20<\/span>),\n                new<\/span> AddExpression(\n                    new<\/span> NumberExpression(context.GetVariable(\"x\"<\/span>)),\n                    new<\/span> NumberExpression(context.GetVariable(\"y\"<\/span>))\n                )\n            )\n        );\n\n        var<\/span> result = expression.Interpret(context);\n\n        Console.WriteLine(\"Result: \"<\/span> + result); \n    }\n}<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
    Summary<\/h2>\n\n\n\n
      \n
    • Use the interpreter pattern to build an interpreter for a simple language.<\/li>\n<\/ul>\n
      \n\t
      \n\t\t
      Was this tutorial helpful ?<\/div>\n\t\t
      \n\t\t\t\n\t\t\t\t\n\t\t\t\t\t<\/path>\n\t\t\t\t<\/svg>\n\t\t\t\t Yes <\/span>\n\t\t\t<\/button>\n\n\t\t\t\n\t\t\t\t\n\t\t\t\t\t<\/path>\n\t\t\t\t<\/svg>\n\t\t\t\t No <\/span>\n\t\t\t<\/button>\n\t\t<\/div>\n\t<\/header>\n\n\t
      \n\t\t
      \n\t\t\t
      <\/div>\n\t\t\t\n\t\t\t