Generico inferenza di tipo in C#

Question

Diciamo che ci sono questi tipi generici in C#:

class Entity<KeyType> 
{ 
    public KeyType Id { get; private set; } 
    ... 
} 

interface IRepository<KeyType, EntityType> where EntityType : Entity<KeyType> 
{ 
    EntityType Get(KeyType id); 
    ... 
} 

e questi tipi di cemento:

class Person : Entity<int> { ... } 

interface IPersonRepository : IRepository<int, Person> { ... } 

Ora la definizione di PersonRepository è ridondante: il fatto che il KeyType di Person è int è indicato in modo esplicito, sebbene possa essere dedotto dal fatto che Person è un sottotipo di Entity<int>.

Sarebbe bello essere in grado di definire IPersonRepository in questo modo:

interface IPersonRepository : IRepository<Person> { ... } 

e lasciare che la figura del compilatore che il KeyType è int. È possibile?

Answer 1

Diciamo che vogliamo dichiarare

interface IPersonRepository : IRepository<Person> { } 

che avrebbe richiesto che ci sia una generica interfaccia con un tipo di parametro IRepository<EntityType>.

interface IRepository<EntityType> where EntityType : Entity<KeyType> 
{ 
    EntityType Get(KeyType id); 
} 

Alla fine della prima linea, si fa riferimento a una cosa chiamata KeyType, che non è stato dichiarato né definito. Non esiste un tipo chiamato "KeyType".

Questo potrebbe funzionare se:

interface IRepository<EntityType> where EntityType : Entity<int> 
{ 
    EntityType Get(int id); 
} 

O questo:

interface IRepository<EntityType> where EntityType : Entity<string> 
{ 
    EntityType Get(string id); 
} 

Ma non si può avere entrambe le definizioni contrastanti allo stesso tempo, naturalmente. Ovviamente, non sei contento di questo, perché vuoi essere in grado di definire la tua interfaccia IRpository in modo che funzioni anche con altri tipi di chiavi.

Bene, è possibile, se si rendono generico nel tipo di chiave:

interface IRepository<KeyType, EntityType> where EntityType : Entity<KeyType> 
{ 
    EntityType Get(KeyType id); 
} 

Esiste un approccio alternativo:

interface IRepository<KeyType> 
{ 
    EntityType<KeyType> Get(KeyType id); 
} 

Ora è possibile definire

class PersonRepository : IRepository<int> 
{ 
    public EntityType<int> Get(int id) { ... } 
} 

Ovviamente, non ne saresti felice, perché vorresti affermare che il metodo Get deve restituire un Person, non solo qualsiasi Entity<int>.

L'interfaccia generica con due parametri di tipo nell'unica soluzione. E infatti, c'è una relazione richiesta tra loro, come espressa nel vincolo. Ma non c'è ridondanza qui: specificare int per il parametro type non contiene abbastanza informazioni.

Se diciamo

class PersonRepository : IRepository<int, Person> 
{ 
    public Person Get(int id) { ... } 
} 

V'è infatti la ridondanza: specificando il parametro di tipo int è ridondante se è già stato specificato il parametro type Person.

Sarebbe possibile ottenere op con una sintassi che consenta di dedurre il KeyType. Ad esempio, Patrick Hoffman ha suggerito:

class PersonRepository : IRepository<EntityType: Person>. 
{ 
    public Person Get(int id) { ... } 
} 

Mentre teoricamente possibile, temo che questo sarebbe aggiungere un sacco di complessità alla specifica del linguaggio e il compilatore, per molto poco guadagno. In effetti, c'è qualche guadagno? Sicuramente non staresti salvando le battute! Confronta questi due:

// current syntax 
class PersonRepository : IRepository<int, Person> 
{ 
    public Person Get(int id) { ... } 
} 

// proposed syntax 
class PersonRepository : IRepository<EntityType: Person> 
{ 
    public Person Get(int id) { ... } 
} 

Il linguaggio è quello che è, e non sembra troppo male per me.

Answer 2

No, non è possibile scrivere quello, poiché non deduce il tipo (il compilatore no).

Dovrebbe essere possibile farlo (è necessario essere parte del team del compilatore C# per ottenerlo), poiché non è possibile altro valore che il valore di KeyType immetta nel parametro type per Entity. Non puoi inserire un tipo derivato o un tipo di classe base.

Come altri hanno commentato, potrebbe complicare ulteriormente il codice. Inoltre, questo funziona solo nel caso in cui Entity<T> sia una classe, quando è un'interfaccia non può inferire il tipo poiché può avere più implementazioni. (Forse è la ragione ultima per cui non hanno costruito questo in)

Answer 3

No, il sistema di tipo C# non è sufficientemente avanzato per esprimere quello che vuoi. La funzionalità necessaria è denominata di tipo più elevato che si trovano spesso in linguaggi funzionali fortemente tipizzati (Haskell, OCaml, Scala).

Lavorare la via del ritorno, si vuole essere in grado di scrivere

interface IRepository<EntityType<EntityKey>> { 
    EntityType<EntityKey> Get(KeyType id); 
} 

interface PersonRepository : IRepository<Person> { 
    Person Get(Int id); 
} 

ma in C# non c'è modo per esprimere l'EntityType tipo o, in altre parole, che il parametro tipo ha alcuni parametri generici e usa quel parametro generico nel tuo codice.

Nota a margine: il modello di deposito è il Male e deve morire in un incendio.