Interpreter pattern in C#

Hello, C# lovers! 😍

Today I want to talk to you about one of the most useful and elegant design patterns: the Interpreter pattern. 🧐


The Interpreter pattern is a behavioral pattern that allows you to define the grammar of a language and interpret sentences in that language. It can be used to create domain-specific languages (DSLs) that are easy to read and write for humans and machines. 🤖


For example, you can use the Interpreter pattern to create a DSL for mathematical expressions, such as “2 + 3 * 4”, and evaluate them at runtime. 🧮

The main components of the Interpreter pattern are:

  • An abstract expression that defines the interface for interpreting a context.
  • A terminal expression that implements the abstract expression for atomic elements of the language.
  • A nonterminal expression that implements the abstract expression for composite elements of the language.
  • A context that contains information that is global to the interpreter.
  • A client that builds and interprets sentences in the language.

Let’s see how we can implement the Interpreter pattern in C# with a simple example. 🙌

We will create a DSL for boolean expressions, such as “true and false or not true”, and evaluate them at runtime. 🔥

First, we need to define an abstract expression that represents a boolean expression:

// Define an abstract expression that represents a boolean expression
public abstract class BooleanExpression
{
    // Define an abstract method for interpreting a context
    public abstract bool Interpret(Context context);
}


Next, we need to define terminal expressions that represent atomic elements of the language: true, false, and variables:

// Define a terminal expression that represents a constant value
public class ConstantExpression : BooleanExpression
{
    // Declare a private field to store the value
    private bool value;

    // Define a constructor that takes the value as a parameter
    public ConstantExpression(bool value)
    {
        // Assign the value to the field
        this.value = value;
    }

    // Override the Interpret method to return the value
    public override bool Interpret(Context context)
    {
        return value;
    }
}


// Define a terminal expression that represents a variable name
public class VariableExpression : BooleanExpression
{
    // Declare a private field to store the name
    private string name;

    // Define a constructor that takes the name as a parameter
    public VariableExpression(string name)
    {
        // Assign the name to the field
        this.name = name;
    }

    // Override the Interpret method to return the value of the variable from the context
    public override bool Interpret(Context context)
    {
        return context.GetVariable(name);
    }
}


Then, we need to define nonterminal expressions that represent composite elements of the language: and, or, and not:

// Define a non terminal expression that represents an and operation
public class AndExpression : BooleanExpression
{
    // Declare private fields to store the left and right operands
    private BooleanExpression left;
    private BooleanExpression right;

    // Define a constructor that takes the left and right operands as parameters
    public AndExpression(BooleanExpression left, BooleanExpression right)
    {
        // Assign the operands to the fields
        this.left = left;
        this.right = right;
    }

    // Override the Interpret method to return the logical and of the operands' values
    public override bool Interpret(Context context)
    {
        return left.Interpret(context) && right.Interpret(context);
    }
}


// Define a non terminal expression that represents an or operation
public class OrExpression : BooleanExpression
{
    // Declare private fields to store the left and right operands
    private BooleanExpression left;
    private BooleanExpression right;

    // Define a constructor that takes the left and right operands as parameters
    public OrExpression(BooleanExpression left, BooleanExpression right)
    {
        // Assign the operands to the fields
        this.left = left;
        this.right = right;
    }

    // Override the Interpret method to return the logical or of the operands' values
    public override bool Interpret(Context context)
    {
        return left.Interpret(context) || right.Interpret(context);
    }
}


// Define a non terminal expression that represents a not operation
public class NotExpression : BooleanExpression
{
    // Declare a private field to store the operand
    private BooleanExpression expression;

    // Define a constructor that takes the operand as a parameter
    public NotExpression(BooleanExpression expression)
    {
        // Assign the operand to the field
        this.expression = expression;
    }

    // Override the Interpret method to return the logical negation of the operand's value
    public override bool Interpret(Context context)
    {
        return !expression.Interpret(context);
    }
}


Finally, we need to define a context class that contains information that is global to the interpreter, such as the values of the variables:

// Define a context class that contains information that is global to the interpreter, such as the values of the variables
public class Context
{
    // Declare a private dictionary to store the variables and their values
    private Dictionary<string, bool> variables;

    // Define a constructor that initializes the dictionary
    public Context()
    {
        variables = new Dictionary<string, bool>();
    }

   // Define a method that sets the value of a variable in the dictionary 
   public void SetVariable(string name, bool value)
   {
       variables[name] = value;
   }

   // Define a method that gets the value of a variable from the dictionary 
   public bool GetVariable(string name)
   {
       return variables[name];
   }
}


Now we can use the interpreter pattern to create and evaluate boolean expressions in our DSL. For example:


// Create a context with some variables
Context context = new Context();
// Set the value of x to true
context.SetVariable("x", true);
// Set the value of y to false
context.SetVariable("y", false);

// Create an expression: x and y or not x
BooleanExpression expression = new OrExpression(
                                // Create an and expression with x and y as operands
                                new AndExpression(
                                    // Create a variable expression for x
                                    new VariableExpression("x"),
                                    // Create a variable expression for y
                                    new VariableExpression("y")
                                ),
                                // Create a not expression with x as operand
                                new NotExpression(
                                    // Create a variable expression for x
                                    new VariableExpression("x")
                                )
                            );

// Evaluate the expression with the context
bool result = expression.Interpret(context);

// Print the result
Console.WriteLine(result); // false

And that’s it! We have successfully implemented the Interpreter pattern in C#. 🎉

I hope you enjoyed this article and learned something new. 😊

If you want to learn more about the Interpreter pattern and other design patterns in C#, I recommend you check out these resources:


You can find the code examples here: source code

Thank you for reading and happy coding! 😁

Comments

Post a Comment

Popular posts from this blog

Which GOF patterns are good for C#?

Hello, C# fans! 😊 In this article, I will answer a common question that many C# developers have: which GOF patterns are good for C#? 🤔 GOF patterns are the 23 design patterns that were described in the book “ Design Patterns: Elements of Reusable Object-Oriented Software ” by Erich Gamma, Richard Helm, Ralph Johnson, and John Vlissides. They are also known as the Gang of Four (GoF) patterns. They are divided into three categories: creational, structural, and behavioral. 📚 These patterns provide solutions to common software design problems that you may encounter in your projects. They help you write code that is more reusable, flexible, maintainable, and elegant. 😍 But not all GOF patterns are equally useful or applicable in C#. Some of them are more relevant and popular than others. Some are already supported by the language features or the .NET framework. Some of them may be outdated or replaced by newer patterns. 😮 So, which GOF patterns are good for C#?  Creational patterns...
Read more

Angular on a regular SharePoint page (part 2)

Image
In my  previous article , we have added an empty angular element to the SharePoint page.  And now we are ready to move forward and add some functionality to our elements. Before we begin      First of all, let's create in SharePoint Announcements list with the name "Announcements" and add a couple of items with some text. We will access data in our list via the SharePoint REST API, calling "/_api/web/lists/getbytitle('Announcements')/Items" endpoint. Angular project      Now, open the angular elements project which we have created in the previous article in VS Code.      For convenience let's create an interface to work with our data model. Create the "data" folder wonder the "src/app" and create a new file named Announcement.ts.      Add this code to it: export interface Announcement { ID : number ; Title : string ; Body : string ; }      We will use the service to get the data from our list. ...
Read more

Chain of Responsibility pattern in C#

Hello, C# lovers! 😍 Today I want to talk about a very useful design pattern called Chain of Responsibility. This pattern allows you to pass a request along a chain of handlers until one of them can handle it. This way, you can avoid coupling the sender of the request with the receiver, and you can dynamically compose the chain at runtime. Sounds cool, right? 😎 Let’s see an example of how to implement this pattern in C#. Suppose you have a simple ATM machine that can dispense bills of 10, 20, and 50 dollars. You want to write a program that can handle any amount of money requested by the user, using the least number of bills possible. To do this, you can create an abstract class called Handler that defines an interface for handling the requests. It also has a reference to the next handler in the chain, and a method to set it. // The 'Handler' abstract class public abstract class Handler { protected Handler successor; public void SetSuccessor ( Handler successo...
Read more