Дженерики, использующие общедоступные интерфейсы и параметры внутреннего типа

У меня такая ситуация:

// A public interface of some kind   
public interface IMyInterface {   
    int Something { get; set; }   
}   

// An internal class that implements the public interface.   
// Despite the internal/public mismatch, this works.   
internal class MyInternalConcrete : IMyInterface {   
    public int Something { get; set; }   
}   

// A generic class with an interface-restricted type parameter.
// Note that the constraint on T uses the *public* interface.
// The instance is *never* exposed as a public, or even protected member.
public class MyClass<T> where T : IMyInterface, new() {   
    T myInterfaceInstance;   

    public MyClass() {   
        myInterfaceInstance = new T();   
    }   
}   

// Attempting to implement concrete class... Inconsistent Accessibility Error!   
public class MySpecificClass : MyClass<MyInternalConcrete>   
{   
}  

При попытке реализовать MySpecificClass я получаю сообщение об ошибке:

Несогласованная доступность: базовый класс App1.MyClass менее доступен, чем класс App1.MySpecificT.

Странно то, что MyInternalConcrete, несмотря на то, что он внутренний, все же может реализовать общедоступный интерфейс. А поскольку он реализует интерфейс, то его следует использовать в качестве параметра типа для MyClass, поскольку T ограничен общедоступным интерфейсом, а не внутренним классом.

Я бы понял, что это не сработает, если MyClass предоставит T, так же, как он потерпел бы неудачу, если бы мы не использовали дженерики:

public class MyClass<T> where T : IMyInterface, new() {      
    T myInterfaceInstance;      

    public MyClass() {      
        myInterfaceInstance = new T();      
    }      

    // This will fail with an internal T - inconsistent accessibility!    
    public T Instance {      
        get { return myInterfaceInstance; }      
    }      
}

То же, что и выше, но без дженериков:

public class MyNonGenericClass {   
    MyInternalConcrete myInterfaceInstance;   

    public MyNonGenericClass() {   
        myInterfaceInstance = new MyInternalConcrete();   
    }   

    // This will fail - inconsistent accessibility! 
    // but removing it works, since the private instance is never exposed.   
    public MyInternalConcrete Instance {   
        get { return myInterfaceInstance; }   
    }   
}  

Является ли это ограничением универсальных шаблонов C # или я просто неправильно понимаю что-то фундаментальное о том, как работают универсальные шаблоны?

Я также разместил эту тему на MSDN, но меня увольняют, так как я не понимаю, о чем говорю. Верно ли мое беспокойство?