Ограничения типа в интерфейсе применяются к базовому классу

Конечно, данный код может быть скомпилирован и безопасно запущен:

Когда экземпляр Something имеет тип Something или BaseClass, компилятор разрешает любой тип для T, а когда тот же экземпляр имеет тип ISomething, он разрешает только типы, наследующие Foo. В обоих случаях вы получаете статическую проверку и безопасность во время выполнения, как обычно.

На самом деле описанный выше сценарий в точности происходит, когда вы реализуете ISomething явно. Итак, давайте посмотрим, какие аргументы мы можем привести за и против текущего положения дел.

За:

• предлагаемое решение не будет применимо ко всем случаям; это зависит от точных сигнатур метода (является ли аргумент типа ковариантным? контравариантным? инвариантным?)
• не требуется, чтобы спецификация была дополнена новым текстом, указывающим, как обрабатываются такие случаи.
• это делает код самодокументируемым — вам не нужно заучивать указанный текст; текущих правил относительно явной реализации интерфейса достаточно
• это не требует затрат на разработку для команды компилятора C # (документация, реализация функций, тестирование и т. д.)

Против:

• вам нужно напечатать больше

Принимая во внимание вышеизложенное и, кроме того, тот факт, что это не повседневный сценарий, ИМХО вывод, который нужно сделать, ясен: это может быть неплохо иметь, но это, конечно, не гарантирует, что вы будете лезть из кожи вон. реализовать это.

Попробуйте использовать композицию вместо наследования для реализации Something:

public class Something : ISomething
{
    private readonly BaseClass inner = ...;

    void DoSomething<T>() where T : Foo
    {
        inner.DoSomething<T>();
    }
}

Вы можете получить то, что хотите, с кодом ниже. Включив параметр типа в определение интерфейса, вы можете сделать его ковариантным, что, по-видимому, удовлетворит компилятор. Класс Base остается нетронутым, и вы можете затенить реализацию Base и реализовать интерфейс с помощью одного метода.

class Program
{
    static void Main()
    {
        var something = new Something<Foo>();
        var baseClass = (BaseClass)something;
        var isomething = (ISomething<Foo>)something;

        var baseResult = baseClass.DoSomething<Bar>();
        var interfaceResult = isomething.DoSomething<Bar>();
        var result = something.DoSomething<Bar>();
    }
}

class Foo 
{
}

class Bar : Foo
{
}

class BaseClass
{
    public T DoSomething<T>()
    {
        return default(T);
    }
}

interface ISomething<out T> where T : Foo
{
    T DoSomething<T>();
}

class Something<T> : BaseClass, ISomething<T> where T : Foo
{
    public new T DoSomething<T>()
    {
        return default(T);
    }
}

Или, если вы действительно не хотите указывать Foo в экземпляре

class Program
{
    static void Main()
    {
        var something = new Something();
        var baseClass = (BaseClass)something;
        var isomething = (ISomething)something;

        var baseResult = baseClass.DoSomething<Bar>();
        var interfaceResult = isomething.DoSomething<Bar>();
        var result = something.DoSomething<Bar>();
    }
}

class Foo 
{
}

class Bar : Foo
{
}

class BaseClass
{
    public T DoSomething<T>()
    {
        return default(T);
    }
}

interface ISomething
{
    T DoSomething<T>;
}

interface ISomething<S> : ISomething where S : Foo
{
    new R DoSomething<R>() where R : Foo;
}

class Something : BaseClass, ISomething
{
    public new T DoSomething<T>()
    {
        return default(T);
    }
}