What is the benefit of Visitor pattern in an API?

Question

I am trying to understand the benefit of having the visitor pattern within an API. The below example is one I saw and I wanted an example as to why the pattern in beneficial i.e benefits. What would be the alternative implementation that would be negative and why compared to this. What benefit can be gained from the below implementation. In this api it contacts multiple universities to get the courses that they offer. Each get course service then has a defined number of responses using the Visitor Pattern:

Controller

[HttpGet]
public async Task Get()
{
    // CourseService already retrieved for a given uni 
    var result = await courseService.GetCourses(userSession);
    return result.Accept(new CourseVisitor());
}

Service - Each Uni has there own GetCourses Service but they all have set responses due to the Visitor pattern

public async Task GetCourses(UserSession userSession) {

// Depending on response from a given uni a set number of responses can be returned across ass uni services e.g
return new CoursesResult.BadRequest(); **or**
return new CoursesResult.Success(); etc
}

Element Abstract / Concrete Element

  public abstract class GetCourses
    {
        public abstract T Accept(ICourseVisitor visitor);

        public class Successful : CoursesResult
        {
            public CourseList Response { get; }

            public Successful(CourseList response)
            {
                Response = response;
            }

            public override T Accept(ICourseVisitor visitor)
            {
                return visitor.Visit(this);
            }
        }
   // Other responses then defined e.g Bad Request

IVisitor

    public interface ICourseVisitor
{
    T Visit(GetCoursesResult.Successful result);
    T Visit(GetCoursesResult.BadRequest result);

Visitor

    internal class CourseVisitor : ICourseVisitor
{
    public IActionResult Visit(GetCourses.Successful result)
    {
        return new OkObjectResult(result.Response);
    }

UPDATED QUERY Additionally I'm trying to understand why the service couldn't return something like this:

//Service returns this: return new Successful(listResponse)

 public interface ICoursesResult
    {
      IActionResult Accept();
    }

 public class Successful : ICoursesResult
    {
        public CourseList Response { get; }

        public Successful(CourseList response)
        {
            Response = response;
        }

        public IActionResult Accept()
        {
            return OkObjectResult(Response);
        }
    }

casablanca · Accepted Answer

The visitor pattern is normally used when you have a polymorphic type and you want to perform an externally defined operation based on the specific subtype of the object. In your example, CoursesResult is a polymorphic type and a visitor lets you convert a Successful response into an OkObjectResult without directly coupling these two types.

Your alternative approach where CoursesResult directly returns an IActionResult is traditional polymorphism, which is simpler but couples domain logic to the MVC layer.

Now, I don't know what your full set of responses looks like, but if you only have one successful response and the rest are errors, then the simplest approach here is to directly return the successful response and throw exceptions for the other cases:

public async Task GetCourses(UserSession userSession) {
  return courseList; /* or */ throw new BadRequestException();
}

Then your controller can simply catch exceptions and convert them to the appropriate IActionResult.

What is the benefit of Visitor pattern in an API?

Answers (2)

Related Questions