Introducing the Visitor design pattern

Design patterns are proven solutions to software design problems. They help improve code quality, promote reusability, and increase maintainability. We use them to save time and produce quality, extensible and flexible code. In this article, we are going to introduce the Visitor design pattern.

Visitor design pattern is a behavioral design pattern that allows you to separate object behavior from object structure. This pattern is useful when you have a complex object structure and want to add new operations to it without changing the objects themselves.

The Visitor pattern consists of the following components:

• Visitor: This interface contains methods that are executed on different elements.
• Concrete Visitor: It is a class that implements the Visitor interface.
• Element: It is an interface that different components must implement. The Accept method is introduced in this interface, by which the Visitor commands can be executed.
• Concrete Element: It is a class that implements the Element interface and implements how to call Visitor commands in the Accept method.
• Object Structure: It is a class that holds a set of elements. This class can apply behaviors on the list of elements by receiving a Visitor.

Below is an example of how to implement the Visitor pattern in C#:

// Visitor interface
public interface IVisitor
{
    void Visit(ElementA element);
    void Visit(ElementB element);
}
// Concrete Visitor
public class ConcreteVisitor : IVisitor
{
    public void Visit(ElementA element)
    {
        // Perform some operation on ElementA
    }
    public void Visit(ElementB element)
    {
        // Perform some operation on ElementB
    }
}
// Element interface
public interface IElement
{
    void Accept(IVisitor visitor);
}
// Concrete Element
public class ElementA : IElement
{
    public void Accept(IVisitor visitor)
    {
       visitor.Visit(this);
    }
}
// Concrete Element
public class ElementB : IElement
{
    public void Accept(IVisitor visitor)
    {
       visitor.Visit(this);
    }
}
// Object Structure
public class ObjectStructure
{
    private List<IElement> elements = new List<IElement>();
    public void AddElement(IElement element)
    {
       elements.Add(element);
    }
    public void RemoveElement(IElement element)
    {
        elements.Remove(element);
    }
    public void Accept(IVisitor visitor)
    {
        foreach (var element in elements)
        {
           element.Accept(visitor);
        }
    }
}

In this example, we have a simple Visitor class that defines two different behaviors for two Elements. Also, each of the Elements has called the Visit method related to Visitor in its Accept method.

In the ObjectStructure class, we have a list of elements that are called using the Accept method in the ObjectStructure. By calling the Accept method, each Element operates based on the specific implementation that was made for it.

By using this pattern, you can achieve a flexible and extensible design that makes it easy to add new operations to the structure of existing objects. The Visitor pattern creates a clean separation between behaviors and structures. This pattern makes your code modular and easier to maintain over time.

To read about other design patterns, you can use the list below. There is also a code repository on GitHub that includes all the design patterns.