¿Existe un enfoque razonable para los parámetros de tipo "predeterminados" en C # Generics?

En las plantillas de C ++, se puede especificar que un determinado parámetro de tipo sea predeterminado. Es decir, a menos que se especifique explícitamente, utilizará el tipo T.

¿Se puede hacer esto o aproximarlo en C #?

Estoy buscando algo como:

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

De modo que una instancia del tipo que no especifica explícitamente T2:

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

Sería esencialmente:

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

En última instancia, estoy viendo un caso en el que hay una plantilla que se usa bastante ampliamente, pero estoy considerando expandirme con un parámetro de tipo adicional. Podría subclase, supongo, pero tenía curiosidad por saber si había otras opciones en este sentido.

La subclasificación es la mejor opción.

Subclasearía su clase genérica principal:

class BaseGeneric<T,U>

con una clase específica

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

Esto hace que sea fácil mantener su lógica en un solo lugar (la clase base), pero también fácil proporcionar ambas opciones de uso. Dependiendo de la clase, probablemente se necesite muy poco trabajo adicional para que esto suceda.

Una solución es la subclasificación. Otro que usaría en su lugar son los métodos de fábrica (combinados con la palabra clave 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>();

En el ejemplo anterior val2es de tipo MyTemplate<int,string> y no derivado de él.

Un tipo class MyStringTemplate<T>:MyTemplate<T,string>no es del mismo tipo que MyTemplate<T,string>. Esto podría plantear algunos problemas en determinados escenarios. Por ejemplo, no puedes lanzar una instancia de MyTemplate<T,string>to MyStringTemplate<T>.

también puedes crear una clase Overload así

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

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

C # no admite dicha función.

Como dijiste, puedes subclasificarlo (si no está sellado y duplicar todas las declaraciones del constructor) pero es algo completamente diferente.

Desafortunadamente, C # no es compatible con lo que está intentando hacer. Sería una característica difícil de implementar dado que el tipo predeterminado para un parámetro tendría que adherirse a las restricciones genéricas y probablemente crearía dolores de cabeza cuando el CLR intentara garantizar la seguridad de tipos.