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

Nei modelli C ++, è possibile specificare che un determinato parametro di tipo è un valore predefinito. Ad esempio, a meno che non sia specificato esplicitamente, utilizzerà il tipo T.

Può essere fatto o approssimato in C #?

Sto cercando qualcosa come:

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 esaminando un caso in cui esiste un modello che è abbastanza ampiamente utilizzato, ma sto considerando di espandere con un parametro di tipo aggiuntivo. Potrei sottoclassare, immagino, ma ero curioso se ci fossero altre opzioni in questo senso.

La sottoclasse è l'opzione migliore.

Sottoclassi la tua classe generica principale:

class BaseGeneric<T,U>

con una classe specifica

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

Ciò rende facile mantenere la logica in un posto (la classe base), ma anche facile fornire entrambe le opzioni di utilizzo. A seconda della classe, probabilmente è necessario molto poco lavoro extra per farlo accadere.

Una soluzione è la sottoclasse. Un altro che userei invece, sono i metodi di fabbrica (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 è lo stesso tipo di MyTemplate<T,string>. Ciò potrebbe porre alcuni problemi in determinati scenari. Ad esempio, non puoi lanciare un'istanza di MyTemplate<T,string>to MyStringTemplate<T>.

puoi anche creare una classe Overload 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>{}

C # non supporta questa funzionalità.

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

Sfortunatamente C # non supporta ciò che stai cercando di fare. Sarebbe una caratteristica difficile da implementare dato che il tipo predefinito per un parametro dovrebbe aderire ai vincoli generici e molto probabilmente creerebbe grattacapi quando il CLR cerca di garantire l'indipendenza dai tipi.