Apakah ada pendekatan yang masuk akal untuk parameter tipe "default" di C # Generics?

Dalam template C ++, seseorang dapat menentukan bahwa parameter tipe tertentu adalah default. Yaitu kecuali ditentukan secara eksplisit, itu akan menggunakan tipe T.

Bisakah ini dilakukan atau diperkirakan di C #?

Saya mencari sesuatu seperti:

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

Sehingga contoh dari tipe yang tidak secara eksplisit menentukan T2:

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

Pada dasarnya:

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

Pada akhirnya saya melihat kasus di mana ada template yang cukup banyak digunakan, tetapi saya sedang mempertimbangkan untuk memperluas dengan parameter tipe tambahan. Saya bisa membuat subkelas, saya rasa, tapi saya penasaran apakah ada pilihan lain dalam hal ini.

Subclassing adalah opsi terbaik.

Saya akan membuat subclass kelas generik utama Anda:

class BaseGeneric<T,U>

dengan kelas tertentu

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

Ini membuatnya mudah untuk menyimpan logika Anda di satu tempat (kelas dasar), tetapi juga mudah untuk menyediakan kedua opsi penggunaan. Bergantung pada kelasnya, mungkin hanya ada sedikit pekerjaan tambahan yang diperlukan untuk mewujudkannya.

Salah satu solusinya adalah subclassing. Satu lagi yang akan saya gunakan sebagai gantinya, adalah metode pabrik (digabungkan dengan kata kunci 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>();

Dalam contoh di atas val2adalah tipe MyTemplate<int,string> dan bukan tipe yang diturunkan darinya.

Tipe class MyStringTemplate<T>:MyTemplate<T,string>bukan tipe yang sama dengan MyTemplate<T,string>. Ini bisa menimbulkan beberapa masalah dalam skenario tertentu. Misalnya, Anda tidak dapat mentransmisikan instance MyTemplate<T,string>ke MyStringTemplate<T>.

Anda juga dapat membuat kelas Overload seperti itu

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

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

C # tidak mendukung fitur seperti itu.

Seperti yang Anda katakan, Anda dapat membuat subkelasnya (jika tidak disegel, dan menduplikasi semua deklarasi konstruktor) tetapi itu adalah hal yang sama sekali berbeda.

Sayangnya C # tidak mendukung apa yang Anda coba lakukan. Ini akan menjadi fitur yang sulit untuk diterapkan mengingat tipe default untuk parameter harus mematuhi batasan umum dan kemungkinan besar akan membuat pusing saat CLR mencoba memastikan keamanan tipe.