¿Hay un enfoque razonable para los parámetros de tipo “por defecto” en C # genéricos?

Question

En las plantillas C ++, se puede especificar que un cierto parámetro tipo es un defecto. Es decir. menos que se especifique explícitamente, se utilizará el tipo T.

¿Se puede hacer una aproximación o en C #?

Estoy buscando algo como:

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

Para que una instancia del tipo que no se especifica explícitamente T2:

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

sería esencialmente:

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

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

Answer 1

La subclasificación es la mejor opción.

Me subclase de 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 de mantener su lógica en un solo lugar (la clase base), pero también es fácil de proporcionar ambas opciones de uso. Dependiendo de la clase, es probable que haya muy poco trabajo adicional necesario para que esto suceda.

Answer 2

Una solución es de subclases. Otro me gustaría utilizar en su lugar, es métodos de fábrica (en combinación 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 val2 es de tipo MyTemplate<int,string> y no un tipo derivado de ella.

Un tipo class MyStringTemplate<T>:MyTemplate<T,string> no es el mismo tipo que MyTemplate<T,string>. Esto podría plantear algunos problemas en ciertos escenarios. Por ejemplo no se puede convertir una instancia de MyTemplate<T,string> a MyStringTemplate<T>.

Answer 3

También puede crear una sobrecarga de clase como tal

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

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

Answer 4

C # no soporta esta característica.

Como usted ha dicho, puede subclase (si no está sellado, y duplicar todas las declaraciones del constructor), pero es una cosa completamente diferente.

Answer 5

Desafortunadamente C # no es compatible con lo que está tratando de hacer. Sería una característica difícil de implementar, dado que el tipo predeterminado para un parámetro tendría que atenerse a las limitaciones genéricas y lo más probable es crear dolores de cabeza cuando el CLR trató de garantizar seguridad de tipos.