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

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

Isso pode ser feito ou aproximado em C #?

Estou procurando algo como:

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

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

Em última análise, estou olhando para um caso em que há um modelo que é amplamente usado, mas estou pensando em expandir com um parâmetro de tipo adicional. Eu poderia fazer uma subclasse, eu acho, mas estava curioso se havia outras opções nessa linha.

Subclassificar é a melhor opção.

Eu criaria uma subclasse de sua classe genérica principal:

class BaseGeneric<T,U>

com uma classe específica

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

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

Uma solução é a subclasse. Outro que eu usaria, são os métodos de fábrica (combinados com a palavra-chave 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>();

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

Um tipo class MyStringTemplate<T>:MyTemplate<T,string>não é igual a MyTemplate<T,string>. Isso pode 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>.

você também pode criar uma classe Overload como esta

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

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

C # não oferece suporte a esse recurso.

Como você disse, você pode criar uma subclasse (se não estiver lacrada e duplicar todas as declarações do construtor), mas é uma coisa completamente diferente.

Infelizmente, C # não oferece suporte ao que você está tentando fazer. Seria um recurso difícil de implementar, dado que o tipo padrão de um parâmetro teria que aderir às restrições genéricas e provavelmente criaria dores de cabeça quando o CLR tentasse garantir a segurança do tipo.