parameter - use generic type c#

¿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, utilizará el tipo T.

¿Se puede hacer esto o aproximarse en C #?

Estoy buscando algo como:

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

Para 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 bastante utilizada, pero estoy considerando ampliarla 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

C # no es compatible con dicha función.

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

Answer 2

Lamentablemente, C # no es compatible con lo que estás 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 3

Subclases es la mejor opción.

Subclase tu 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 es fácil proporcionar ambas opciones de uso. Dependiendo de la clase, probablemente se necesita muy poco trabajo adicional para que esto suceda.

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

Una class MyStringTemplate<T>:MyTemplate<T,string> 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 puedes crear una clase Overload como tal

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

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