Esiste un approccio ragionevole ai parametri di tipo "predefinito" in C# Generics?

Question

Nei modelli C++, è possibile specificare che un determinato parametro di tipo è un valore predefinito. Cioè se non specificato esplicitamente, utilizzerà il tipo T.

Questo può essere fatto o approssimato in C#?

Sto cercando qualcosa di simile:

public class MyTemplate<T1, T2=string> {} 

In modo che un'istanza del tipo che non specifica esplicitamente T2:

MyTemplate<int> t = new MyTemplate<int>(); 

Sarebbe essenzialmente:

MyTemplate<int, string> t = new MyTemplate<int, string>(); 

In definitiva sto osservando un caso in cui esiste un modello che è abbastanza ampio sed, ma sto valutando l'espansione con un parametro di tipo aggiuntivo. Potrei sottoclassi, immagino, ma ero curioso di sapere se c'erano altre opzioni in questo senso.

Answer 1

La sottoclasse è l'opzione migliore.

avrei sottoclasse vostra principale classe generica:

class BaseGeneric<T,U>

con una specifica classe

class MyGeneric<T> : BaseGeneric<T, string>

Ciò rende più semplice per mantenere la logica in un unico luogo (la classe base) , ma anche facile da fornire entrambe le opzioni di utilizzo. A seconda della classe, c'è probabilmente molto poco lavoro extra necessario per fare in modo che ciò accada.

Answer 2

C# non supporta tale funzione.

Come hai detto, puoi creare una sottoclasse (se non è sigillata e duplicare tutte le dichiarazioni del costruttore) ma è una cosa completamente diversa.

Answer 3

Sfortunatamente C# non supporta ciò che si sta tentando di fare. Sarebbe una caratteristica difficile da implementare dato che il tipo predefinito per un parametro dovrebbe rispettare i vincoli generici e molto probabilmente creerebbe mal di testa quando il CLR cercava di garantire la sicurezza del tipo.

Answer 4

Una soluzione è una sottoclasse. Un altro che vorrei usare, invece, sono i metodi factory (combinati con la parola chiave var).

public class MyTemplate<T1,T2> 
{ 
    public MyTemplate(..args..) { ... } // constructor 
} 

public static class MyTemplate{ 

    public static MyTemplate<T1,T2> Create<T1,T2>(..args..) 
    { 
     return new MyTemplate<T1, T2>(... params ...); 
    } 

    public static MyTemplate<T1, string> Create<T1>(...args...) 
    { 
     return new MyTemplate<T1, string>(... params ...); 
    } 
} 

var val1 = MyTemplate.Create<int,decimal>(); 
var val2 = MyTemplate.Create<int>(); 

Nell'esempio sopra val2 è di tipo MyTemplate<int,string>e non un tipo derivato da esso.

Un tipo class MyStringTemplate<T>:MyTemplate<T,string> non è dello stesso tipo di MyTemplate<T,string>. Ciò potrebbe causare alcuni problemi in alcuni scenari. Ad esempio, non è possibile trasmettere un'istanza di MyTemplate<T,string> a MyStringTemplate<T>.

Answer 5

è anche possibile creare un sovraccarico di classe in questo modo

public class MyTemplate<T1, T2> { 
    public T1 Prop1 { get; set; } 
    public T2 Prop2 { get; set; } 
} 

public class MyTemplate<T1> : MyTemplate<T1, string>{}