C # Generics'te "varsayılan" tür parametrelere makul bir yaklaşım var mı?

C ++ şablonlarında, belirli bir tür parametresinin varsayılan olduğu belirtilebilir. Yani, açıkça belirtilmedikçe, T tipini kullanacaktır.

Bu C # ile yapılabilir veya yaklaştırılabilir mi?

Şunun gibi bir şey arıyorum:

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

Böylece, açıkça belirtmeyen türden bir örnek T2:

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

Esasen şunlar olabilir:

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

Nihayetinde oldukça yaygın olarak kullanılan bir şablonun olduğu bir duruma bakıyorum, ancak ek bir tür parametresi ile genişletmeyi düşünüyorum. Sanırım alt sınıf yapabilirim, ama bu damarda başka seçenekler olup olmadığını merak ediyordum.

Alt sınıflandırma en iyi seçenektir.

Ana genel sınıfınızı alt sınıflara ayırırdım:

class BaseGeneric<T,U>

belirli bir sınıfla

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

Bu, mantığınızı tek bir yerde (temel sınıf) tutmanızı ve aynı zamanda her iki kullanım seçeneğini de sağlamanızı kolaylaştırır. Sınıfa bağlı olarak, bunun gerçekleşmesi için muhtemelen çok az ekstra çalışma gerekir.

Çözümlerden biri alt sınıflamadır. Bunun yerine kullanacağım bir diğer yöntem fabrika yöntemleridir (var anahtar sözcüğü ile birlikte).

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>();

Yukarıdaki örnekte val2tiptedir MyTemplate<int,string> ve ondan türetilen bir tip değildir .

Bir tür class MyStringTemplate<T>:MyTemplate<T,string>, ile aynı türde değildir MyTemplate<T,string>. Bu, belirli senaryolarda bazı sorunlar yaratabilir. Örneğin siz bir örneğini döküm olamaz MyTemplate<T,string>için MyStringTemplate<T>.

bunun gibi bir sınıf Aşırı Yüklemesi de oluşturabilirsiniz.

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

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

C # böyle bir özelliği desteklemez.

Dediğin gibi, alt sınıflara ayırabilirsin (eğer mühürlenmemişse ve tüm yapıcı bildirimlerini çoğaltabilirsin) ama bu tamamen farklı bir şey.

Maalesef C # yapmaya çalıştığınız şeyi desteklemiyor. Bir parametrenin varsayılan türünün genel kısıtlamalara uyması gerektiği ve CLR tip güvenliğini sağlamaya çalıştığında büyük olasılıkla baş ağrısı yaratacağı düşünüldüğünde, uygulanması zor bir özellik olacaktır.