如何将泛型类型的抽象类约束到派生类的接口？

Question

My question is similar to this question with the difference that rather than constraining to to the derived class directly I would like to constrain to the interface on that class.

Some background: I am trying to create a type safe interface driven framework for creating SignalR Hub Proxies, mainly for the case that if a hub name or one of its methods change I don't have to search through a bunch of strings to resolve the issue; on that note my signal r client is all dot net so no worries about java script.

So if I have this base class:

public abstract class BaseClientProxy<T>
{
    protected IHubProxy proxy;

    protected void Invoke<TDto>(TDto dto)
    {
        proxy.Invoke(this.GetCallingMethod(), dto);
    }

    protected void Invoke()
    {
        proxy.Invoke(this.GetCallingtMethod());
    }

    protected BaseClientProxy(HubConnection conn)
    {
        proxy = conn.CreateHubProxy<T>();
    }
}

And a hub proxy like:

    public class FoobarServiceProxy : BaseClientProxy<IFoobarService>, IFoobarService
{
    public FoobarServiceProxy(HubConnection conn) : base(conn)
    {          
    }

    public void Bar(BarDto bar)
    {
        proxy.Invoke(this.GetCurrentMethod(), bar);
    }

    ...
}

How could I Remove the need to Specify the interface to both the base and the derived? I am open to restructuring this a bit as well as I'm not too far down the proverbial rabbit hole yet.

Answer 1

It appears that what you want is a sort of "generic proxy", which you can create against any interface. You want to do something like this:

public abstract class BaseClientProxy<T> : T

In other words, you want to have a class implement an interface that is not known at compile time.

That is not allowed. If you try to compile it, you get

error CS0689: Cannot derive from 'T' because it is a type parameter

That is impossible to compile since you have no idea what the members of T are going to be. Even if you placed a type constraint on T that would allow the compiler to know some of its members, you still could not know all of the members that may needed at run time (for, eg child interfaces that add members).

However, you can add a type constraint to the abstract class that will guarantee that T implements a given interface in all cases. Unfortunately, you still have to apply the same constraint on all subclasses, but fortunately the compiler checks that for you.

Another alternative would be to make the proxy a member of the parent class (instead of a base):

public abstract BaseClientProxy<T>
{
    public T Client {
        // etc
    }
}

You couldn't substitute the proxy itself for T 's, but you would be unconstrained in your choice of T . This might be acceptable if you can tell in client usage whether or not you have a proxy (which may defeat the purpose). If, as you say, you are still in the design phase, maybe you could instead adjust clients to match this structure.

Answer 2

If I understand correct, you want something like

public abstract class BaseClient<T> : T
{ ... }

This is not possible in .NET. Even if that was possible, at that level T does not offer any information (in any case it is guaranteed to be Object, an interface that you already have). If you restrict T to an interface then it would be odd. You can restrict any derived class to implement any interface you want by saying you implement them and leave all interface operations as abstract (in other words you already have this constraint).

If you want to derive from BaseClient a GeneralFoo where T is a concrete interface but its implementations can vary, then I would go for aggregate. Simply add a property of type T to BaseClient and if any derived class will want to restrict T can do so and use that property. The returned instance is guaranteed to implement the interface you constraint T to.

Hope it helps