What alternatives are there to using an object of a contravariant interface polymorphously?

Question

The gist of what I'm trying to do is get an instance of the appropriate user service, then pass it whatever subtype of User we're working with.

Models:

public class User
{
 public string FirstName { get; set; }
 public string LastName { get; set; }
}
public class Student : User
{
 public int Grade { get; set; }
}
public class Staff : User
{
 public DateTime HireDate { get; set; }
}

Services:

public interface IUserService<T> where T : User
{
 void Save(T user);
}
public class StudentService : IUserService<Student>
{
 public void Save(Student user)
 {
 // Student-specific code
 }
}
public class StaffService : IUserService<Staff>
{
 public void Save(Staff user)
 {
 // Staff-specific code
 }
}

My first try was to new up the matching service and up-cast. I found out that didn't work since it would violate type safety: e.g., the compiler wouldn't be able to tell if I were passing in a compatible user later on.

public void Process(User user)
{
 IUserService<User> service;
 if (user is Staff)
 service = (IUserService<User>)new StaffService(); // InvalidCastException
 else if (user is Student)
 service = (IUserService<User>)new StudentService(); // InvalidCastException
 else
 throw new ArgumentException("...");
 service.Save(user);
}

I understand why that's the case now, but I haven't been able to come up with an alternative that still allows for:

1. Enforcing a contract (any user service has to implement these methods)
2. Calling methods in a generic way (just pass in the user object)
3. Avoiding duplicate code

What I really don't want to do is end up with something like:

if (user is Staff)
{
 var service = new StaffService();
 service.Save(user);
}
else if (user is Student)
{
 var service = new StudentService();
 service.Save(user);
}
// etc.

Not so bad with two user types and one method call, but the actual code is more complex.

• johnny: Isn't this a need for Dependency Injection?
• johnny: stackoverflow.com/questions/5423125/…
• walpen: If you have a stable set of user subclasses, a visitor would be reasonable. You could then write an IUserService on User that stores a IUserService for each subtype and uses the visitor interface to dispatch the appropriate service.
• Caleth: why not void process<T> where T : User ?
• Eric Eskildsen: @Caleth Exactly what I ended up changing it to. Kicking myself for missing it, but a good night's rest does wonders. Could you repost as an answer?

Answer 1

You want to match the UserService subtype to the User subtype, which is fairly simple to do with (the same) type parameter you use in IUserService.

public void Process<T>(T user) where T : User
{
 IUserService<T> service;
 if (user is Staff)
 service = new StaffService(); // No more cast
 else if (user is Student)
 service = new StudentService(); // No more cast
 else
 throw new ArgumentException("...");
 service.Save(user);
}

This still has the problem that Process has to know what Service class to instantiate, which we can get around slightly awkwardly like so:

public void Process<T, S>(T user) where T : User where S : IUserService<T>
{
 IUserService<T> service = new S(); // No more "if ... is ..." chain 
 service.Save(user);
}

However that will complicate the call sites of Process

• Ben Aaronson: I don't think that first code snippet will compile. C# doesn't take into account the user is Staff when checking if it can assign a StaffService to service
• Caleth: The whole point is that service is IUserService<Staff> because of the generic parameter
• Eric Eskildsen: This did it! Thanks. I ended up moving the instantiation into a factory and kept just the one type parameter. Works great.
• Ben Aaronson: @Caleth Yeah, but the compiler will want every branch to be valid for all possible T. It doesn't take into account that some branches will only be run for some values of T. It doesn't say "well we only try to assign StaffService if T is Staff so we only need to assign a StaffService to IUserService<Staff>". Try copy-pasting it into Visual Studio and you'll see.