C# Helper Pattern vs Service Method

Question

Let's say we have the following classes:

public class Ticket {
  public int Id { get; set; }
  public string Event { get; set; }
  ...
}

public class TicketService {
  public void acceptTicket(Ticket ticket) {
    ...
  }

  ...
}

My question is, where's the best place to add static helper methods (that require no state like the service class might) related to the ticket entity? (Keeping in mind this is one entity/service amongst many other entities/services in the entire system).

Right now I'm thinking of the following possibilities:

1. Create a new class called TicketHelper in its own .cs file.
2. Create a static Helper class directly on the Ticket class
3. Create a static Helper class directly on the Service class
4. Just add the methods directly onto the service class as any other service method
5. ... a better solution than these?

For the sake of clarity, here's what I mean for #2 or #3.

public class TicketService {
  public void acceptTicket(Ticket ticket) {
    ...
  }

  ...

  public static class Helper {
    public static Dictionary<string, List<Ticket>> groupByName(List<Ticket> tickets) {
      // returns the map of name/tickets
    }
  }
}

The API might look as follows in this case:

Ticket ticket = new Ticket();
List<Ticket> tickets = new List<Tickets>();
TicketService service = new TicketService();
service.acceptTicket(ticket);

// leaving out the creation of a list of tickets...
var groups = TicketService.Helper.groupByName(tickets);

Answer 1

You could use extension methods for this. Create them in a separate TicketExtensions class.

public static class TicketExtensions {
  public static Dictionary<string, List<Ticket>> groupByName(this List<Ticket> tickets) {
    // returns the map of name/tickets
  }
}

...

var ticket = new Ticket();
var tickets = new List<Tickets>();
var service = new TicketService();
service.acceptTicket(ticket);

// leaving out the creation of a list of tickets...
var groups = tickets.groupByName();

Also, using interfaces like IEnumerable<T>, IList<T> or IDictionary<K, V> is preferable than the concrete collection classes.

Answer 2

Yet another possibility is to use the singleton pattern.

It has the advantages of:

• being able to implement an interface
• providing an object that you could pass to a method or constructor in a dependency injection scenario
• providing a static behavior

public interface ITicketHelper
{
    void HelpThis(Ticket t);
    IList<Ticket> HelpThat();
}

public class TicketHelper : ITicketHelper
{
    public static readonly TicketHelper Instance = new TicketHelper();

    private TicketHelper()
    { ... }

    public void HelpThis(Ticket t)
    { ... }

    public IList<Ticket> HelpThat()
    { ... }
}

Usage

 var result = TicketHelper.Instance.HelpThat();