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);
}
private IRepository _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.
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
From Geek Daily