Existe uma abordagem razoável para parâmetros de tipo “padrão” em C # genéricos?

Question

Em modelos C ++, pode-se especificar que um determinado parâmetro de tipo é um padrão. Ou seja, a menos que explicitamente especificado, ele usará tipo T.

Isso pode ser feito ou aproximada em C #?

Eu estou procurando algo como:

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

Assim que uma instância do tipo que não especifica explicitamente T2:

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

Seria essencialmente:

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

Finalmente eu estou olhando para um caso em que existe um modelo que é bastante amplamente utilizado, mas estou considerando expandir com um parâmetro de tipo adicional. Eu poderia subclasse, eu acho, mas eu estava curioso para saber se havia outras opções nesta veia.

Answer 1

Subclassing é a melhor opção.

Eu subclasse seu principal classe genérica:

class BaseGeneric<T,U>

com uma classe específica

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

Isto torna mais fácil para manter sua lógica em um só lugar (a classe base), mas também fácil de fornecer ambas as opções de uso. Dependendo da classe, provavelmente há um trabalho muito pouco extra necessário para fazer isso acontecer.

Answer 2

Uma solução é subclasses. Outro que eu usaria em vez disso, é métodos de fábrica (combinado com var palavra-chave).

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>();

No exemplo val2 acima é do tipo MyTemplate<int,string> e não um tipo derivado da mesma.

Um tipo class MyStringTemplate<T>:MyTemplate<T,string> não é do mesmo tipo que MyTemplate<T,string>. Isso poderia representar alguns problemas em determinados cenários. Por exemplo, você não pode lançar uma instância de MyTemplate<T,string> para MyStringTemplate<T>.

Answer 3

Você também pode criar uma sobrecarga classe como assim

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 # não suporta esse recurso.

Como você disse, você pode subclasse-lo (se ele não está selado, e duplicar todas as declarações do construtor), mas é uma coisa completamente diferente.

Answer 5

Infelizmente C # não suporta o que você está tentando fazer. Seria uma característica difícil de implementar dado que o tipo padrão para um parâmetro teriam de aderir às restrições genéricas e provavelmente criar dores de cabeça quando o CLR tentou garantir tipo de segurança.