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

Question

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

¿Se puede hacer esto o aproximar en C#?

Busco 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 estoy viendo un caso en el que hay una plantilla que es bastante amplia sed, pero estoy considerando expandirme con un parámetro de tipo adicional. Podría crear una subclase, supongo, pero tenía curiosidad si había otras opciones en este sentido.

Answer 1

Subclases es la mejor opción.

Me subclase su principal clase genérica:

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, probablemente se necesita muy poco trabajo adicional para que esto suceda.

Answer 2

C# no es compatible con esta característica.

Como dijiste, puedes crear una subclase (si no está sellada, y duplicar todas las declaraciones de los constructores) pero es algo completamente diferente.

Answer 3

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 cumplir con las restricciones genéricas y muy probablemente crearía dolores de cabeza cuando el CLR intentara garantizar la seguridad del tipo.

Answer 4

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 val2 anterior es de tipo MyTemplate<int,string>y no un tipo derivado de ella.

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

Answer 5

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>{}