Web Development & SEO Blog

Apr

C# Design Patterns - The Visitor Pattern

What is the visitor pattern?

The visitor design pattern is a way of separating an algorithm from an object structure upon which it operates. A practical result of this separation is the ability to add new operations to existing object structures without modifying those structures. Thus, using the visitor pattern helps conformance with the open/closed principle [Wikipedia].

Our Requirements

One principle that I really like is the Open/Closed principle which says that an object should be open to new functionality but closed to structural changes. The visitor pattern helps facilitate this principle by giving us the means to perform operations against an object without changing the objects structure.

Looking back at a previous pattern we wanted to adjust the registration cost for a dog if they had been picked up by the dog catcher.

Implementing The Visitor

Supposing we have the implementation for the interface below we could use the visitor pattern to perform our tasks without changing the existing classes. Since we won’t be changing the existing implementation we don’t need to worry about breaking existing features. Lets assume that the repository returns 3 infractions for our dog in the code below.

internal interface IDog {
    int Id { get; set; }
    string Name { get; set; }
    string Breed { get; set; }
    string Address { get; set; }
    DateTime RegisterDate { get; set; }
    int RegistrationCost { get; set; }
   ICollection<Infraction> Infractions { get; }
    void Accept(IVisitor visitor);
}

internal classDog : IDog {
privateIRepository _repo;
    public Dog(IRepository repo) {

        _repo = repo;

        RegistrationCost = 25;

    }
    public int Id { get; set; }

    public string Name { get; set; }

    public string Breed { get; set; }

    public string Address { get; set; }

    public DateTime RegisterDate { get; set; }

    public int RegistrationCost { get; set; }

    public ICollection<Infraction> Infractions { 

        get { return _repo.GetInfractions(Id); } 

    }
    public void Accept(IVisitor visitor) {

        visitor.Visit(this);

    }

}

internal interface IVisitor {

    void Visit(IDog dog)

}
internal class Visitor : IVisitor {

    public Visitor() { }

    public void Visit(IDog dog) {

        var cost = dog.RegistrationCost;

        var infractions = dog.Infractions.Count;

        //increase cost $5 for each infraction

        dog.RegistrationCost = cost + (infractions * 5);

    }

}

So we have our dog class and we have our visitor setup. All we have left to do is execute it.

class Program {
    static void Main() {
        IDog dog = new Dog(Repository.Create<IDog>());
            IVisitor visitor = new Visitor();
            dog.Accept(visitor);
            Console.WriteLine(dog.RegistrationCost); //=> 40
    }
}

Conclusion

So just like the Decorator pattern, with the visitor pattern we can modify our class without changing the classes code. This pattern is more flexible because we can create any number of visitor classes to do just about anything without changing any code.

Be sure to grab the RSS feed, sign up for email updates, or follow me on Twitter to stay up to date and not miss any posts.

The C# Design Patterns Series

Part 1 - An Overview
Part 2 - The Decorator Pattern
Part 3 - The Abstract Factory Pattern
Part 4 - The Observer Pattern
Part 5 - The Facade Pattern
Part 6 - The Visitor Pattern

8 people have commented on this post so far! Leave a Comment

Mar

C# Design Patterns - The Facade Pattern

ASP.Net Software Design

Today I am back with another design pattern. In this post we’ll be exploring the Facade pattern.

What Is The Facade Pattern

The facade pattern is a higher level interface that simplifies and brings together multiple interfaces of a subsystem. What this means is if you want to do something but that requires interacting with multiple subsystems you can create a facade that same only a few methods that handle all the interaction with the subsystem.

Our Application Requirements

In our city dog registration application lets assume there are a few things that need to be done when a new dog is registered. First the new dog and it’s owners must be entered into the system. Next the registration fee must be processed. Finally, we want the system to send the owners the welcome email.

This is a very simple example but this action requires 3 separate systems to do something in order to complete this one task of registering a new dog.

Using The Facade Pattern

For the sake of simplicity and not cluttering this post with too much code, I am not going to provide code for the sub systems, just the facade.


public class RegistrationManager : IRegister {
    private IAccountingService _accounting;
    private IMessageService _messaging;
    private IRepository = _repository;

    public RegistrationManager(IAccountService accounting, IMessagingService messaging, IRepository repository) {
        _accounting = accounting;
        _messaging = messaging;
        _repository = repository;
    }

    public void RegisterDog(IDog dog) {
        _repository.AddDog(dog);
        _accounting.ProcessPayment(dog.PaymentOrder);
        _messaging.SendWelcome(dog.Owners.Find(x => x.PrimaryContact))
    }
}

As you can see this is a very simple example but it illustrates the concept of the pattern. We have taken 3 tasks, each belonging to a different sub system, and combined them into 1 task in a facade class, in this case the RegistrationManager class.

The RegisterDog method adds the new dog to the repository, sends the payment order to the accounting system, and sends a welcome message to the dogs owners that are flagged as primary contacts.