Gibt es einen vernünftigen Ansatz für Standardparameter in C # Generics?

In C ++ - Vorlagen kann angegeben werden, dass ein bestimmter Typparameter ein Standard ist. Das heißt, wenn nicht ausdrücklich angegeben, wird Typ T verwendet.

Kann dies in C # durchgeführt oder angenähert werden?

Ich suche so etwas wie:

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

Damit eine Instanz des Typs, die nicht explizit angibt T2:

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

Wäre im Wesentlichen:

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

Letztendlich betrachte ich einen Fall, in dem es eine Vorlage gibt, die ziemlich weit verbreitet ist, aber ich denke darüber nach, sie um einen zusätzlichen Typparameter zu erweitern. Ich könnte eine Unterklasse bilden, aber ich war neugierig, ob es in diesem Sinne andere Optionen gibt.

Unterklassen sind die beste Option.

Ich würde Ihre generische Hauptklasse unterordnen:

class BaseGeneric<T,U>

mit einer bestimmten Klasse

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

Dies macht es einfach, Ihre Logik an einem Ort (der Basisklasse) zu halten, aber auch beide Verwendungsoptionen bereitzustellen. Abhängig von der Klasse ist wahrscheinlich nur sehr wenig zusätzliche Arbeit erforderlich, um dies zu erreichen.

Eine Lösung ist die Unterklasse. Eine andere, die ich stattdessen verwenden würde, sind Factory-Methoden (kombiniert mit dem Schlüsselwort 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>();

Im obigen Beispiel val2handelt es sich um einen Typ MyTemplate<int,string> und nicht um einen davon abgeleiteten Typ.

Ein Typ class MyStringTemplate<T>:MyTemplate<T,string>ist nicht der gleiche Typ wie MyTemplate<T,string>. Dies kann in bestimmten Szenarien zu Problemen führen. Zum Beispiel können Sie keine Instanz von MyTemplate<T,string>to umwandeln MyStringTemplate<T>.

Sie können auch eine solche Klassenüberladung erstellen

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

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

C # unterstützt eine solche Funktion nicht.

Wie Sie sagten, können Sie es in Unterklassen unterteilen (wenn es nicht versiegelt ist und alle Konstruktordeklarationen duplizieren), aber es ist eine ganz andere Sache.

Leider unterstützt C # nicht, was Sie versuchen zu tun. Die Implementierung wäre schwierig, da der Standardtyp für einen Parameter die allgemeinen Einschränkungen einhalten müsste und höchstwahrscheinlich Kopfschmerzen verursachen würde, wenn die CLR versuchte, die Typensicherheit zu gewährleisten.