Ich suchte nach einem Muster, um auch die Spezialisierung von Vorlagen zu simulieren. Es gibt einige Ansätze, die unter bestimmten Umständen funktionieren können. Was ist jedoch mit dem Fall?
static void Add<T>(T value1, T value2)
{
//add the 2 numeric values
}
Es wäre möglich, die Aktion mit Anweisungen zu wählen, z if (typeof(T) == typeof(int)). Es gibt jedoch eine bessere Möglichkeit, die Spezialisierung realer Vorlagen mit dem Aufwand eines einzelnen virtuellen Funktionsaufrufs zu simulieren:
public interface IMath<T>
{
T Add(T value1, T value2);
}
public class Math<T> : IMath<T>
{
public static readonly IMath<T> P = Math.P as IMath<T> ?? new Math<T>();
//default implementation
T IMath<T>.Add(T value1, T value2)
{
throw new NotSupportedException();
}
}
class Math : IMath<int>, IMath<double>
{
public static Math P = new Math();
//specialized for int
int IMath<int>.Add(int value1, int value2)
{
return value1 + value2;
}
//specialized for double
double IMath<double>.Add(double value1, double value2)
{
return value1 + value2;
}
}
Jetzt können wir schreiben, ohne den Typ vorher kennen zu müssen:
static T Add<T>(T value1, T value2)
{
return Math<T>.P.Add(value1, value2);
}
private static void Main(string[] args)
{
var result1 = Add(1, 2);
var result2 = Add(1.5, 2.5);
return;
}
Wenn die Spezialisierung nicht nur für die implementierten Typen, sondern auch für abgeleitete Typen aufgerufen werden soll, könnte man einen InParameter für die Schnittstelle verwenden. In diesem Fall können die Rückgabetypen der Methoden jedoch nicht mehr vom generischen Typ Tsein.