Restrizione di tipo ereditato generico in C#

Question

Ho una soluzione poco elegante per quello che mi serve, ma sono alla ricerca di una soluzione elegante per sostituirla.

Il seguente codice non viene compilato, ma rappresenta ciò che vorrei fare:.

interface IWebService 
{ 
} 

abstract class BaseClient<T> 
{ 
} 

class SpecializedClient : BaseClient<IWebService> 
{ 
} 

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

Qualora la T in ClientHelper<T> è ogni classe che estende BaseClient indipendentemente dal tipo su modelli passato in

La soluzione poco elegante che ho trovato è:

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

La ragione per questo diventa poco elegante è il mio proge ct termina con una classe simile a:

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

Tutto il percorso fino alla classe base che accetta un singolo tipo. È semplicemente il costo di avere un albero di ereditarietà complesso di classi generiche o esiste un modo più semplice per farlo mantenendo le restrizioni di tipo sui tipi di modelli?

Answer 1

La soluzione "inelegante" è quella giusta se l'interfaccia pubblica di BaseClient espone il suo parametro di tipo generico in alcun modo.

Quindi, supponendo BaseClient è non come definito che:

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

Poi T è parte del contratto interfaccia pubblica di BaseClient, e quindi parte del contratto interfaccia pubblica di ClientHelper (ancora una volta, partendo dal presupposto che BaseClient<U> viene esposto tramite l'interfaccia di ClientHelper).

D'altra parte, supponiamo che in realtà è come il tuo esempio dice:

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

In questo caso, si può fare:

interface IBaseClient 
{ 
    //Nothing about T here 
} 

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

e ClientHelper diventa:

class ClientHelper<T> where T : IBaseClient 
{ 
} 

Answer 2

Un'opzione sembra essere:

interface IWebService 
{ 
} 

interface IClient<out T> 
{ 
} 

abstract class BaseClient<T> : IClient<T> 
{ 
} 

class SpecializedClient : BaseClient<IWebService> 
{ 
} 

class ClientHelper<T> where T : IClient<object> 
{ 
} 

Tuttavia ciò funzionerà solo se si BaseClient restituisce solo T e non lo accetta mai.