根据对象类型解析服务的设计模式？

Question

I'm trying to refactor some code that basically has a switch statement on object type and calls a specific service method based off that type. I tried to keep the same code as basic as possible.

 if (user is Employee)
 {
     _userService.DoSomething(user);
 }
 else if (user is Manager)
 {
    _managerService.DoSomething(user);
 }
 else if (user is Executive)
 {
    _executiveService.DoSomething(user);
 }

I'd like to abstract the service calls to an interface and reduce the number of lines of code. My question is on the ServiceResolver part, is there a specific design pattern associated with this type of problem? I can easily create a class that has a switch statement that returns the correct service that implements the interface but that doesn't seem as clean as I'd like it. Any suggestions? I'm already using structure map constructor injection, could that be used with conditions or something?

public interface IUserDoSomethingService
{
     void DoSomething(User user)
}

var userDoSomethingService = _userDoSomethingServiceResolver(user);
userDoSomethingService.DoSomething(user);

Answer 1

Simples! I am going to assume you don't need to cast (you actually have the type strongly typed).

In that case you just need a Generic on IDoSomethingService

public interface IServiceDoSomethingOn<in T>
{
    void DoSomethingOn(T thing);
}

Now on the service call you just need to call...

public void DoSomethingOnSomethingElse<T>(T thatSomething)
{
    var service = ServiceResolver.Current.Resolve<IServiceDoSomethingOn<T>>();
    service.DoSomethingOn(thatSomething);
}

Edit: The semi generic solution. Warning I do not know how well structure map will deal with Covariance and Contravariance. So inheritance might not work.

public void DoSomethingOnSomethingElse(object thatSomething, Type type)
{
    var genericMethod = this.GetType().GetMethods()
                        .Single(x => x.IsGeneric && x.Name == "DoSomethingOnSomethingElse");
    var method = genericMethod.MakeGenericMethod(type);
    method.Invoke(this, new object[]{thatSomething});
}

Answer 2

From my view point, appropriate design pattern for your situation are strategy pattern. You can take reference here: http://blogs.microsoft.co.il/blogs/gilf/archive/2009/11/22/applying-strategy-pattern-instead-of-using-switch-statements.aspx .

You can register each Type name as a key into structure map to resolve the appropriate concrete class.

Hope this help.

Answer 3

Why not abstract factory pattern ?

public class UserServiceFactory : IUserServiceFactory {
  public EmployeeServiceFactory(IUserService employeeService
    , IUserService managerService
    , IUserService executiveService) {

    //null guards
    this.employeeService = employeeService;
    this.managerService = managerService;
    this.executiveService = executiveService;
  }
}

From here, you have 2 options, either use the traditional if-else statement or strategy pattern to resolve by object type.

If-else example (method inside UserServiceFactory):

public void DoSomething(User user) {
  if (user is Employee) {
    employeeService.DoSomething(user);
  }
  else if (user is Manager) {
    managerService.DoSomething(user);
  }
  else if (user is Executive) {
    executiveService.DoSomething(user);
  }
}

Resolve by object type:

public void DoSomething(Employee user) {
  employeeService.DoSomething(user);
}
public void DoSomething(Manager user) {
  managerService.DoSomething(user);
}
public void DoSomething(Executive user) {
  executiveService.DoSomething(user);
}

There should be another way to do it, by using naming over configuration, but I'm still incapable of doing it.

The usage in direct call:

public void CallUser() {
  // declare the services and user here
  UserServiceFactory userServiceFactory = new UserServiceFactory(employeeService
    , managerService
    , executiveService);
  userServiceFactory.DoSomething(user);
}

The usage in other service , inject the factory instead of the service collection.

public class UserServiceConsumer:IUserServiceConsumer {
  public UserServiceConsumer(IUserServiceFactory userServiceFactory) {
    this.userServiceFactory = userServiceFactory;
  }
  IUserServiceFactory userServiceFactory;

  public void ConsumeFactory(User user) {
    //do some validation maybe
    userServiceFactory.DoSomething(user);
  }
}

It may sound complicated, but simple enough after you understand it.

Answer 4

My idea is:

public interface IUserDoSomethingService {
    void DoSomething(Employee user);
    void DoSomething(Manager user);
    void DoSomething(Executive user);
}

Answer 5

You can also use Managed Extensibility Framework (MEF) , which is part of System.ComponentModel.Composition namespace in .Net and can be used in conjunction with ServiceLocator pattern. Here are some articles on MEF:

http://fernandomachadopirizen.wordpress.com/2010/04/19/a-simple-introduction-to-the-microsoft-extensibility-framework/

http://msdn.microsoft.com/en-IN/library/dd460648(v=vs.100).aspx