Visitor pattern in C#

Hi there, C# enthusiasts! 😍

In this post, I’m going to explain one of the most versatile and powerful design patterns in C#: the Visitor pattern. 🚀

The Visitor pattern is a way of separating an algorithm from an object structure on which it operates. It allows you to add new behaviors to existing classes without modifying them directly. 🙌

Sounds awesome, right? But how does it work? 🤔

The Visitor pattern involves four main components:

• The Visitor interface: this defines a Visit method for each type of element that can be visited.
• The ConcreteVisitor class: this implements the Visitor interface and provides the logic for each Visit method.
• The Element interface: this defines an Accept method that takes a Visitor as an argument.
• The ConcreteElement class: this implements the Element interface and calls the appropriate Visit method on the Visitor.
  
  

Let’s see an example of how to use the Visitor pattern in C#. Suppose we have a hierarchy of accounts that can be managed by a bank. We want to add new behavior to calculate the interest rate for each account, but we don’t want to modify the existing account classes. Here is how we can apply the Visitor pattern:

// The Visitor interface
public interface IAccountVisitor
{
    void Visit(SavingsAccount savingsAccount);
    void Visit(CheckingAccount checkingAccount);
    void Visit(CreditCardAccount creditCardAccount);
}


// The ConcreteVisitor class
public class InterestRateCalculator : IAccountVisitor
{
    public double TotalInterest { get; private set; }

    public void Visit(SavingsAccount savingsAccount)
    {
        // Calculate the interest rate for a savings account using its balance and rate
        TotalInterest += savingsAccount.Balance * savingsAccount.Rate / 100 + savingsAccount.Balance / 1000;
    }

    public void Visit(CheckingAccount checkingAccount)
    {
        // Calculate the interest rate for a checking account using its balance and rate
        TotalInterest += checkingAccount.Balance * checkingAccount.Rate / 100 + checkingAccount.Balance / 2000;
    }

    public void Visit(CreditCardAccount creditCardAccount)
    {
        // Calculate the interest rate for a credit card account using its balance and rate
        TotalInterest += creditCardAccount.Balance * creditCardAccount.Rate / 100;
    }
}


// The Element interface
public interface IAccount
{
    void Accept(IAccountVisitor visitor);
}


// The ConcreteElement class for savings accounts
public class SavingsAccount : IAccount
{
    public double Balance { get; set; }
    public double Rate { get; set; }

    public SavingsAccount(double balance, double rate)
    {
        Balance = balance;
        Rate = rate;
    }

    public void Accept(IAccountVisitor visitor)
    {
        // Call the Visit method for savings accounts on the visitor
        visitor.Visit(this);
    }
}


// The ConcreteElement class for checking accounts
public class CheckingAccount : IAccount
{
    public double Balance { get; set; }
    public double Rate { get; set; }

    public CheckingAccount(double balance, double rate)
    {
        Balance = balance;
        Rate = rate;
    }

    public void Accept(IAccountVisitor visitor)
    {
        // Call the Visit method for checking accounts on the visitor
        visitor.Visit(this);
    }
}

// The ConcreteElement class for credit card accounts
public class CreditCardAccount : IAccount
{
    public double Balance { get; set; }
    public double Rate { get; set; }

    public CreditCardAccount(double balance, double rate)
    {
        Balance = balance;
        Rate = rate;
    }

    public void Accept(IAccountVisitor visitor)
    {
        // Call the Visit method for credit card accounts on the visitor
        visitor.Visit(this);
    }
}

Now we can create some accounts and use the InterestRateCalculator visitor to compute their total interest:

// Create some accounts
SavingsAccount savings = new SavingsAccount(1000, 2);
CheckingAccount checking = new CheckingAccount(500, 1);
CreditCardAccount credit = new CreditCardAccount(-1000, 15);

// Create an InterestRateCalculator visitor
InterestRateCalculator calculator = new InterestRateCalculator();

// Use the visitor to calculate the interest rate for each account
savings.Accept(calculator);
checking.Accept(calculator);
credit.Accept(calculator);

// Print the total interest
Console.WriteLine($"The total interest is {calculator.TotalInterest}");

The output is:

The total interest is -123.75

As you can see, the Visitor pattern allows us to add new behaviors to existing classes without changing them. We can also create different visitors for different purposes, such as depositing, withdrawing, or transferring money. 💰

The Visitor pattern has some advantages and disadvantages that you should be aware of. Here are some of them:

• Advantages:
  • It makes adding new operations to existing classes easy without modifying them.
  • It promotes the separation of concerns and the single responsibility principle.
  • It allows you to reuse the same visitor for different object structures.
• Disadvantages:
  • It can make the code more complex and harder to understand.
  • It can introduce tight coupling between the visitor and the element classes.
  • It can violate the open/closed principle if new element types are added.
    
    

If you want to learn more about the Visitor pattern, here are some useful resources:

• C# Visitor Pattern - C# Tutorial
• C# Visitor Design Pattern - Dofactory
• Visitor Design Pattern in C# with Examples - Dot Net Tutorials
• C# Design Patterns: The Visitor Pattern | TheSharperDev
• 7 Questions About C# Visitor Pattern You Were Afraid to Ask - MethodPoet
  
  

I hope you enjoyed this post and learned something new about the Visitor pattern in C#. If you have any questions or feedback, please leave a comment below. And don’t forget to share this post with your friends and colleagues who might be interested in C# design patterns. 😊

You can find the code examples here: source code

Happy coding! 👩‍💻👨‍💻