Чому компілятор C # скаржиться на те, що "типи можуть об'єднуватися", коли вони походять від різних базових класів?

Мій поточний некомпілюючий код подібний до цього:

public abstract class A { }

public class B { }

public class C : A { }

public interface IFoo<T>
{
    void Handle(T item);
}

public class MyFoo<TA> : IFoo<TA>, IFoo<B>
    where TA : A
{
    public void Handle(TA a) { }
    public void Handle(B b) { }
}

Компілятор C # відмовляється компілювати це, посилаючись на таке правило / помилку:

'MyProject.MyFoo <TA>' не може реалізувати як 'MyProject.IFoo <TA>', так і "MyProject.IFoo <MyProject.B>", оскільки вони можуть уніфікувати для деяких підстановок параметрів типу

Я розумію, що означає ця помилка; якщо TAвзагалі може бути що-небудь, то технічно це також може бути таким, Bщо внесе неоднозначність щодо двох різних Handleреалізацій.

Але ТА не може бути нічим. Виходячи з ієрархії типів, TA це не може бути B- принаймні, я не думаю, що може. TAповинен походити з A, що не походить з B, і, очевидно, у C # /. NET немає успадкування декількох класів.

Якщо я видалю загальний параметр і замінюю TAна C, або навіть A, він компілюється.

То чому я отримую цю помилку? Це помилка або загальна неінтелектуальна інформація компілятора, чи щось ще мені не вистачає?

Чи є якесь обхідне рішення, або мені просто доведеться повторно реалізувати MyFooзагальний клас як окремий не-загальний клас для кожного можливого TAпохідного типу?

Це наслідок розділу 13.4.2 специфікації C # 4, який говорить:

Якщо будь-який можливий побудований тип, створений з C, після заміни аргументів типу на L призведе до того, що два інтерфейси в L будуть ідентичними, тоді оголошення C є недійсним. Декларації обмежень не враховуються при визначенні всіх можливих побудованих типів.

Зверніть увагу, що там є друге речення.

Отже, це не помилка компілятора; правильний компілятор. Можна стверджувати, що це недолік мовної специфікації.

Взагалі кажучи, обмеження ігноруються майже у кожній ситуації, коли факт повинен бути виведений щодо загального типу. Обмеження в основному використовуються для визначення ефективного базового класу загального параметра типу, і мало що інше.

На жаль, це іноді призводить до ситуацій, коли мова є надмірно суворою, як ви виявили.

Взагалі, поганий запах коду - реалізовувати "однаковий" інтерфейс двічі, певним чином відрізняючись лише загальними аргументами типу. Це дивно, наприклад, мати class C : IEnumerable<Turtle>, IEnumerable<Giraffe>- що таке C , що і послідовність черепах, і послідовність жирафів, в той же час ? Чи можете ви описати те, що ви тут намагаєтесь зробити? Може бути кращий шаблон для вирішення справжньої проблеми.

Якщо насправді ваш інтерфейс точно такий, як ви описуєте:

interface IFoo<T>
{
    void Handle(T t);
}

Тоді багаторазове успадкування інтерфейсу представляє ще одну проблему. Ви можете обґрунтовано вирішити зробити цей інтерфейс противаріантним:

interface IFoo<in T>
{
    void Handle(T t);
}

Тепер припустимо, що маєте

interface IABC {}
interface IDEF {}
interface IABCDEF : IABC, IDEF {}

І

class Danger : IFoo<IABC>, IFoo<IDEF>
{
    void IFoo<IABC>.Handle(IABC x) {}
    void IFoo<IDEF>.Handle(IDEF x) {}
}

А тепер все стає по-справжньому божевільним ...

IFoo<IABCDEF> crazy = new Danger();
crazy.Handle(null);

Яку реалізацію Handle викликають ???

Дивіться цю статтю та коментарі, щоб отримати більше думок з цього питання:

http://blogs.msdn.com/b/ericlippert/archive/2007/11/09/covariance-and-contravariance-in-c-part-ten-dealing-with-ambiguity.aspx

Очевидно, це було за задумом, як обговорювалося в Microsoft Connect:

• Дозволити реалізувати той самий загальний інтерфейс для більш ніж одного параметра типу у загальному класі за певних умов

І обхідний шлях полягає у визначенні іншого інтерфейсу як:

public interface IIFoo<T> : IFoo<T>
{
}

Потім застосуйте це замість цього:

public class MyFoo<TA> : IIFoo<TA>, IFoo<B>
    where TA : A
{
    public void Handle(TA a) { }
    public void Handle(B b) { }
}

Тепер він компілюється чудово, моно .

Ви можете сховати його під радаром, якщо покладете один інтерфейс на базовий клас.

public interface IFoo<T> {
}

public class Foo<T> : IFoo<T>
{
}

public class Foo<T1, T2> : Foo<T1>, IFoo<T2>
{
}

Я підозрюю, що це працює, тому що якщо типи "об'єднують", зрозуміло, що реалізація похідного класу виграє.

Дивіться мою відповідь на те саме питання тут: https://stackoverflow.com/a/12361409/471129

Певною мірою це можна зробити! Я використовую метод диференціації, замість того, щоб класифікатор (и) обмежував типи.

Це не уніфікує, насправді це може бути краще, ніж якби це сталося, тому що ви можете дратувати окремі інтерфейси.

Дивіться мій пост тут, із повністю робочим прикладом в іншому контексті. https://stackoverflow.com/a/12361409/471129

В основному, що ви робите, це додаєте інший параметр типу до IIndexer , щоб він став IIndexer <TKey, TValue, TDifferentiator>.

Тоді ви, використовуючи його двічі, передаєте "Перший" першому використанню, а "Другий" - другому

Отже, клас Test стає: class Test<TKey, TValue> : IIndexer<TKey, TValue, First>, IIndexer<TValue, TKey, Second>

Таким чином, ви можете зробити new Test<int,int>()

де Перший та Другий є тривіальними:

interface First { }

interface Second { }

Я знаю, що з моменту публікації потоку минув деякий час, але для тих, хто за допомогою цієї пошукової системи переходить до цієї теми. Зверніть увагу, що нижче "Base" означає базовий клас для TA та B.

public class MyFoo<TA> : IFoo<Base> where TA : Base where B : Base
{
    public void Handle(Base obj) 
    { 
       if(obj is TA) { // TA specific codes or calls }
       else if(obj is B) { // B specific codes or calls }
    }

}

Припускаючи зараз ...

Чи не можуть бути оголошені A, B і C у зовнішніх збірках, де ієрархія типів може змінитися після компіляції MyFoo <T>, що спричинить хаос у світ?

Просте обхідне рішення - просто застосувати Handle (A) замість Handle (TA) (і використовувати IFoo <A> замість IFoo <TA>). За допомогою Handle (TA) і так неможливо зробити набагато більше, ніж методи доступу з A (через обмеження A: TA).

public class MyFoo : IFoo<A>, IFoo<B> {
    public void Handle(A a) { }
    public void Handle(B b) { }
}

Хм, а що з цим:

public class MyFoo<TA> : IFoo<TA>, IFoo<B>
    where TA : A
{
    void IFoo<TA>.Handle(TA a) { }
    void IFoo<B>.Handle(B b) { }
}