Skip to content

Example of visitor pattern (In C#, oh my)

Jump to bottom
Thomas Volden edited this page Feb 13, 2019 · 2 revisions

Visitor example

I have 2 messages types: Request, Confirmation. My objective is to write a XMLFormatter for the 2 types.

First try

I decide to make some interfaces, one for each type. They will all extend the same interface IMessage.

interface IMessage {
    string ID { get; }
}

interface IRequest : IMessage {
    string Action { get; }
}

interface IConfirmation : IMessage {
}

Now I can accept a IMessage and then check which type it actually is.

class XMLFormatter {
    public string Format(IMessage message) {
        if (message is IRequest request)
            return FormatRequest(request);
        if (message is IConfirmation confirmation)
            return FormatConfirmation(confirmation);
        return null;
    }

    private string FormatRequest(IRequest) {
        var returnValue = null;
        [...]
        return returnValue;
    }

    private string FormatConfirmation(IConfirmation) {
        var returnValue = null;
        [...]
        return returnValue;
    }
}

Everything works, so I ship it.

Multiple handlers

The customer wants to support two new formats: json and yml. To do this, I add an interface for formatters and implement the different kinds.

interface IFormatter {
    string Format(IMessage message);
}

class XMLFormatter : IFormatter {
    public string Format(IMessage message) {
        if (message is IRequest request)
            return FormatRequest(request);
        if (message is IConfirmation confirmation)
            return FormatConfirmation(confirmation);
        return null;
    }

    private string FormatRequest(IRequest) {
        var returnValue = null;
        [...]
        return returnValue;
    }

    private string FormatConfirmation(IConfirmation) {
        var returnValue = null;
        [...]
        return returnValue;
    }
}

class JSONFormatter : IFormatter {
    string Format(IMessage message) {
        if (message is IRequest request)
            return FormatRequest(request);
        if (message is IConfirmation confirmation)
            return FormatConfirmation(confirmation);
        return null;
    }

    private string FormatRequest(IRequest) {
        var returnValue = null;
        [...]
        return returnValue;
    }

    private string FormatConfirmation(IConfirmation) {
        var returnValue = null;
        [...]
        return returnValue;
    }
}

class YMLFormatter : IFormatter {
    string Format(IMessage message) {
        if (message is IRequest request)
            return FormatRequest(request);
        if (message is IConfirmation confirmation)
            return FormatConfirmation(confirmation);
        return null;
    }

    private string FormatRequest(IRequest) {
        var returnValue = null;
        [...]
        return returnValue;
    }

    private string FormatConfirmation(IConfirmation) {
        var returnValue = null;
        [...]
        return returnValue;
    }
}

Easy peasy, I ship it.

New message type

After a while I get the assignment to add a new Message type to handle errors.

I add a new class which implements the Message interface.

class Error : Message {
    string ID;
    string ErrorMessage;
}

I also add the new message to my formatters.

class XMLFormatter : IFormatter {
    public string Format(IMessage message) {
        if (message is IRequest request)
            return FormatRequest(request);
        if (message is IConfirmation confirmation)
            return FormatConfirmation(confirmation);
        if (message is IError error)
            return FormatError(error);
        return null;
    }

    [...]

    private string FormatError(IError) {
        var returnValue = null;
        [...]
        return returnValue;
    }
}

class JSONFormatter : IFormatter {
    public string Format(IMessage message) {
        if (message is IRequest request)
            return FormatRequest(request);
        if (message is IConfirmation confirmation)
            return FormatConfirmation(confirmation);
        if (message is IError error)
            return FormatError(error);
        return null;
    }

    [...]

    private string FormatError(IError) {
        var returnValue = null;
        [...]
        return returnValue;
    }
}

class YMLFormatter : IFormatter {
    string Format(IMessage message) {
        if (message is IRequest request)
            return FormatRequest(request);
        if (message is IConfirmation confirmation)
            return FormatConfirmation(confirmation);
        if (message is IError error)
            return FormatError(error);
        return null;
    }

    [...]

    private string FormatError(IError) {
        var returnValue = null;
        [...]
        return returnValue;
    }
}

I wonder if there is a way to avoid this type check stuff.

Visitor pattern

Let's look at the structure so far

@startuml
interface IMessage {
    string ID { get; }
}

interface IFormatter {
    string Format(IMessage)
}

class XMLFormatter {
    + string Format(IMessage)
    - FormatRequest(Request)
    - FormatConfirmation(Confirmation)
    - FormatError(Error)
}

class JSONFormatter {
    + string Format(IMessage)
    - FormatRequest(Request)
    - FormatConfirmation(Confirmation)
    - FormatError(Error)
}

class YMLFormatter {
    + string Format(IMessage)
    - FormatRequest(Request)
    - FormatConfirmation(Confirmation)
    - FormatError(Error)
}

interface IRequest {
    string ID { get; }
    string Action { get; }
}

interface IConfirmation {
    string ID { get; }
}

interface IError {
    string ID { get; }
    string ErrorMessage { get; }
}

IFormatter -> IMessage

XMLFormatter -up-|> IFormatter
JSONFormatter -up-|> IFormatter
YMLFormatter -up-|> IFormatter

IRequest -up-|> IMessage
IConfirmation -up-|> IMessage
IError -up-|> IMessage

@enduml

I'm guessing that new message types are higly unlikely. So I can try to apply the Visitor pattern.

First I'll implement a general Query Visitor, which referes to the CQRS. All you need to know now, is that a Query can return a value, but may not alter state.

interface IQueryVisitor<T> {
    T VisitRequest(IRequest);
    T VisitConfirmation(IConfirmation);
    T VisitError(IError);
}

Now let's change the IMessage to accept a visitor

interface IMessage {
    string ID { get; }
    T Accept<T>(IQueryVisitor<T> visitor);
}

This way I can get rid of the type check and the if statements, since the message type can identify it self. First I have to implement Accept method for all my message types. To do this, I'll change my message types from interfaces to abstract classes.

abstract class Request : IMessage {
    string ID;
    string Action;
    T Accept<T>(IQueryVisitor<T> visitor) {
        return visitor.VisitRequest(this);
    }
}

abstract class Confirmation : IMessage {
    string ID;
    string Action;
    T Accept<T>(IQueryVisitor<T> visitor) {
        return visitor.VisitConfirmation(this);
    }
}

abstract class Error : IMessage {
    string ID;
    string Action;
    T Accept<T>(IQueryVisitor<T> visitor) {
        return visitor.VisitError(this);
    }
}

Instead of the IFormatter interface, I'll implement the IQueryVisitor interface for my formatters.

class XMLFormatter : IQueryVisitor<string> {
    string VisitRequest(Request) {
        var returnValue = null;
        [...]
        return returnValue;
    }

    string VisitConfirmation(Confirmation) {
        var returnValue = null;
        [...]
        return returnValue;
    }

    string VisitError(Error) {
        var returnValue = null;
        [...]
        return returnValue;
    }
}

class JSONFormatter : IQueryVisitor<string> {
    string VisitRequest(Request) {
        var returnValue = null;
        [...]
        return returnValue;
    }

    string VisitConfirmation(Confirmation) {
        var returnValue = null;
        [...]
        return returnValue;
    }

    string VisitError(Error) {
        var returnValue = null;
        [...]
        return returnValue;
    }
}

class YMLFormatter : IQueryVisitor<string> {
    string VisitRequest(Request) {
        var returnValue = null;
        [...]
        return returnValue;
    }

    string VisitConfirmation(Confirmation) {
        var returnValue = null;
        [...]
        return returnValue;
    }

    string VisitError(Error) {
        var returnValue = null;
        [...]
        return returnValue;
    }
}

I'll create a FormatterFacade and inject the formatter.

class FormatterFacade : IFormatter {
    private readonly IQueryVisitor<string> _formatter;

    public FormatterFacade(IQueryVisitor<string> formatter) {
        _formatter = formatter;
    }

    string Format(IMessage message) {
        return message.Accept(_formatter);
    }
}
@startuml
interface IMessage {
    string ID { get; }
    T Accept<T>(IQueryVisitor<T>)
}

interface IMessageFormatter {
    string Format(IMessage)
}

interface IQueryVisitor<T> {
    T VisitRequest(Request)
    T VisitConfirmation(Confirmation)
    T VisitError(Error)
}

class MessageFormatter {
    string Format(IMessage)
}

class XMLFormatter {
    + string VisitRequest(Request)
    + string VisitConfirmation(Confirmation)
    + string VisitError(Error)
}

class JSONFormatter {
    + string VisitRequest(Request)
    + string VisitConfirmation(Confirmation)
    + string VisitError(Error)
}

class YMLFormatter {
    + string VisitRequest(Request)
    + string VisitConfirmation(Confirmation)
    + string VisitError(Error)
}

abstract class Request {
    string ID { get; }
    string Action { get; }
    T Accept<T>(IQueryVisitor<T>)
}

abstract class Confirmation {
    string ID { get; }
    T Accept<T>(IQueryVisitor<T>)
}

abstract class Error {
    string ID { get; }
    string ErrorMessage { get; }
    T Accept<T>(IQueryVisitor<T>)
}

IMessageFormatter -> IMessage

MessageFormatter -up-|> IMessageFormatter
MessageFormatter -> IQueryVisitor

XMLFormatter -up-|> IQueryVisitor : T = string
JSONFormatter -up-|> IQueryVisitor : T = string
YMLFormatter -up-|> IQueryVisitor : T = string

IQueryVisitor <-down- Request
IQueryVisitor <-down- Confirmation
IQueryVisitor <-down- Error

Request -up-|> IMessage
Confirmation -up-|> IMessage
Error -up-|> IMessage

@enduml

What did I get?

Obviously I got rid of the type casting and if-statements. Which is nice.

Also it's easier to test the formatters, now that the methods are public.

The real gain, is how easy it is to apply new visitors in the future. Let say we wanted to add a Logging of the messages.

class LogFormatter : IQueryVisitor<string> {
    string VisitRequest(Request) {
        var returnValue = null;
        [...]
        return returnValue;
    }

    string VisitConfirmation(Confirmation) {
        var returnValue = null;
        [...]
        return returnValue;
    }

    string VisitError(Error) {
        var returnValue = null;
        [...]
        return returnValue;
    }
}

Or say something completely different, like a validator:

class Validator : IQueryVisitor<bool> {
    bool VisitRequest(Request) {
        var returnValue = false;
        [...]
        return returnValue;
    }

    bool VisitConfirmation(Confirmation) {
        var returnValue = false;
        [...]
        return returnValue;
    }

    bool VisitError(Error) {
        var returnValue = null;
        [...]
        return returnValue;
    }
}

The downside is, that adding a new message type would be extremely costly.

Sincerly Thomas Volden

Clone this wiki locally