Question

I have an inelegant solution for what I need, but am looking for an elegant solution to replace it.

The following code doesn’t compile, but represents what I would like to do:

interface IWebService
{
}

abstract class BaseClient<T>
{
}

class SpecializedClient : BaseClient<IWebService>
{
}

class ClientHelper<T> where T : BaseClient<*>
{
}

Where the T in ClientHelper<T> is any class that extends BaseClient regardless of the templated type passed in.

The inelegant solution I found is:

class ClientHelper<T, U> where T : BaseClient<U> {}

The reason this becomes inelegant is my project ends up with a class similar to:

class MyClass<A, B, C, D, E, F, G> where A  : MyBaseClass<B, C, D, E, F, G>

All the way down to the base class that takes a single type. Is this simply the cost of having a complex inheritance tree of generic classes or is there a simpler way to do this while retaining type restrictions on the templated types?

Answer 1

Your “inelegant” solution is the right one if the public interface of BaseClient exposes it’s generic type parameter in any way.

So assuming BaseClient is not as you defined it:

abstract class BaseClient<T>
{
   //Something about T here
}

Then T is part of the public interface contract of BaseClient, and therefore part of the public interface contract of ClientHelper (again, assuming that BaseClient<U> is exposed via the interface of ClientHelper).

On the other hand, let’s assume it actually is as your example puts it:

abstract class BaseClient<T>
{
   //Nothing about T here
}

In that case, you can do:

interface IBaseClient
{
   //Nothing about T here
}

abstract class BaseClient<T> : IBaseClient
{ 
    // Whatever you like here
}

and ClientHelper becomes:

class ClientHelper<T> where T : IBaseClient
{
}