Есть ли разумный подход к параметрам типа «по умолчанию» в C # Generics?

В шаблонах C ++ можно указать, что определенный параметр типа является значением по умолчанию. Т.е., если явно не указано иное, будет использоваться тип T.

Можно ли это сделать или приблизить на C #?

Я ищу что-то вроде:

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

Таким образом, экземпляр типа, который явно не указывает T2:

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

Было бы по существу:

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

В конечном итоге я рассматриваю случай, когда существует довольно широко используемый шаблон, но я рассматриваю возможность расширения с помощью дополнительного параметра типа. Думаю, я мог бы создать подкласс, но мне было любопытно, есть ли другие варианты в этом ключе.

Подклассификация - лучший вариант.

Я бы подклассифицировал ваш основной общий класс:

class BaseGeneric<T,U>

с определенным классом

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

Это упрощает хранение вашей логики в одном месте (базовый класс), но также упрощает предоставление обоих вариантов использования. В зависимости от класса, вероятно, потребуется совсем немного дополнительной работы, чтобы это произошло.

Одно из решений - создание подклассов. Другой, который я бы использовал вместо этого, - это фабричные методы (в сочетании с ключевым словом 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>();

В приведенном выше примере val2это тип, MyTemplate<int,string> а не производный от него тип.

Тип class MyStringTemplate<T>:MyTemplate<T,string>- это не тот же тип, что и MyTemplate<T,string>. В определенных сценариях это может вызвать некоторые проблемы. Например, вы не можете привести экземпляр MyTemplate<T,string>кMyStringTemplate<T> .

вы также можете создать класс Overload следующим образом

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

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

C # не поддерживает такую ​​функцию.

Как вы сказали, вы можете создать его подкласс (если он не запечатан, и продублировать все объявления конструктора), но это совершенно другое дело.

К сожалению, C # не поддерживает то, что вы пытаетесь сделать. Эту функцию было бы сложно реализовать, учитывая, что тип по умолчанию для параметра должен соответствовать общим ограничениям и, скорее всего, вызовет головную боль, когда среда CLR попытается обеспечить безопасность типов.