Я не могу придумать причину, по которой c # не может теоретически скопировать ограничения. Но задокументированное поведение, заставляющее нас копировать (или дополнять) их явно, кажется, самый простой способ для удобства использования.
public class A{}
public class B : A {}
public class X<T> where T: A {}
public class Y<T> : X<T> where T: B { }
Обратите внимание, что в приведенном выше тексте мне не нужно было копировать явное ограничение на Y<T>, поскольку B равно всегда и A.
Теперь давайте посмотрим, что произойдет, если «компилятор автоматически скопирует ограничения». Допустим, я определяю Y<T> без ограничений, и компилятор размещает их автоматически. Я использую Y<T> в большом количестве кода. Затем я изменяю ограничения на объявление X<T>, чтобы включить новый интерфейс.
Ошибки компилятора для изменения объявления X<T> есть на сайтах, где я использую Y<T>!
При том, как в настоящее время работает компилятор c #, ошибки компилятора находятся в пределах X<T>, как я и ожидал, если бы я изменил его ломаным образом.
Так что, хотя это было бы удобно в некоторых сценариях, это также было бы несколько запутанным в других. Хотя оба подхода являются допустимыми, я бы предположил (заметьте, что я не в состоянии прочитать мысли команды разработчиков c #), что это был оценочный вызов, а не чисто технический.
Я говорю «не чисто технический», но я, конечно, могу представить некоторые интерфейсные сценарии, в которых было бы несколько проще проверить, что все ограничения выполнены, чем создавать простейшее ограничение, которое удовлетворяет всем требуемым унаследованным ограничениям.