Czy istnieje rozsądne podejście do „domyślnych” parametrów typu w C # rodzajach generycznych?

W szablonach C ++ można określić, że określony parametr typu jest domyślny. To znaczy, o ile nie zostanie to wyraźnie określone, użyje typu T.

Czy można to zrobić lub przybliżyć w C #?

Szukam czegoś takiego:

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

Tak, że instancja typu, który nie określa jawnie T2:

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

Byłoby zasadniczo:

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

Ostatecznie patrzę na przypadek, w którym istnieje szablon, który jest dość szeroko stosowany, ale rozważam rozszerzenie o dodatkowy parametr typu. Chyba mógłbym podklasować, ale byłem ciekawy, czy w tym duchu są inne opcje.

Podklasy to najlepsza opcja.

Podklasowałbym twoją główną klasę ogólną:

class BaseGeneric<T,U>

z określoną klasą

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

Ułatwia to utrzymanie logiki w jednym miejscu (klasie bazowej), ale także zapewnia łatwe zapewnienie obu opcji użycia. W zależności od klasy prawdopodobnie potrzeba bardzo niewiele dodatkowej pracy, aby to się stało.

Jednym z rozwiązań jest tworzenie podklas. Innym, którego użyłbym zamiast tego, są metody fabryczne (w połączeniu ze słowem kluczowym 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>();

W powyższym przykładzie val2jest to typ, MyTemplate<int,string> a nie typ wyprowadzony z niego.

Typ class MyStringTemplate<T>:MyTemplate<T,string>nie jest tym samym typem, co MyTemplate<T,string>. Może to spowodować pewne problemy w niektórych scenariuszach. Na przykład nie możesz przesłać instancji MyTemplate<T,string>do MyStringTemplate<T>.

możesz także stworzyć taką klasę Overload

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

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

C # nie obsługuje takiej funkcji.

Jak powiedziałeś, możesz podklasować go (jeśli nie jest zapieczętowany i zduplikować wszystkie deklaracje konstruktora), ale to zupełnie inna sprawa.

Niestety C # nie obsługuje tego, co próbujesz zrobić. Byłaby trudna do zaimplementowania, biorąc pod uwagę, że domyślny typ parametru musiałby być zgodny z ogólnymi ograniczeniami i najprawdopodobniej spowodowałby ból głowy, gdy CLR próbowałby zapewnić bezpieczeństwo typu.