C# общая перегрузка - компилятор не может определить правильный вызов

Question

Я не понимаю, почему компилятор не может решить правильную перегрузку для использования здесь. (код ниже) Существует только одна версия Add(), которая подходит - BigFoo является IFoo и не реализует IEnumerable, где T является IFoo. Но он настаивает на том, чтобы сообщать о двусмысленности. Есть идеи? Я попытался добавить второй общий тип параметра - Добавить где T: IFoo, где U: IEnumerable. Но тогда перегрузка полностью игнорируется даже для законного использования.

Я знаю, что могу обойти это с помощью литья и определения параметров типового типа, но в этот момент я победил цель перегрузки. Вы можете подвергнуть сомнению перегрузку, но семантика мне кажется верной - поведение, которое я реализую в своем классе, используется как для Add(), так и для добавления объекта в качестве отдельной записи в коллекции. (Второй Add() не должен быть AddRange().)

namespace NS 
{ 
    interface IFoo { } 

    class BigFoo : IFoo, IEnumerable<int> 
    { 
    public IEnumerator<int> GetEnumerator() 
    { 
     throw new NotImplementedException(); 
    } 
    IEnumerator IEnumerable.GetEnumerator() 
    { 
     throw new NotImplementedException(); 
    } 
    } 

    class FooContainer 
    { 
    public void Add(IFoo item) { } 
    public void Add<T>(IEnumerable<T> group) where T : IFoo { } 
    } 

    class DemoClass 
    { 
    void DemoMethod() 
    { 
     BigFoo bigFoo = new BigFoo(); 
     FooContainer fooContainer = new FooContainer(); 
     // error CS0121: The call is ambiguous between the following methods or properties: 
     // 'NS.FooContainer.Add(NS.IFoo)' and 
     // 'NS.FooContainer.Add<int>(System.Collections.Generic.IEnumerable<int>)' 
     fooContainer.Add(bigFoo); 
    } 
    } 
} 

Answer 1

Generic разрешение перегрузки не принимать во внимание ограничения, поэтому он считает версию Add<T> применимой, выводя T=int.

Оба метода применимы, и ни один из них не определен лучше другого, поскольку нет никакого преобразования между IEnumerable<int> и IFoo. В то время как общие методы считаются «менее конкретными», чем не общие методы, это становится актуальным только тогда, когда типы параметров идентичны после замены аргумента типа, которые они не в этом случае.

Answer 2

Компилятор должен быть достаточно умным, чтобы признать, что BigFoo не может быть отлит до IEnumerable<IFoo>, но это не так. Он просто видит, что это IEnumerable<T>, и чувствует, что это потенциальный кандидат на перегрузку (хотя выбранный вами предел, который вы определили, устанавливает, что T должен быть IFoo и int не может быть отлит до IFoo). Хотя это неудобно, дело не в этом. Просто бросить bigFoo в IFoo и компилятор будет счастлив:

fooContainer.Add((IFoo)bigFoo); 

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

public void Add<T, U>(U group) 
    where T : IFoo 
    where U : IEnumerable<T> 
{ 
} 

В любом случае, у вас есть более типизация, вторые устраняют решения необходимость бросить вызовы Add, но вам придется явно объявить тип на звонки в родовом оных (который заканчивает тем более код:

fooContainer.Add<IFoo, IEnumerable<IFoo>>(enumerableFoo); 

Answer 3

В FooContainer во втором «Добавить» вы сдерживаете T типа IFoo. BigFoo реализует интерфейс IFoo, поэтому он подходит к определению Add Add (хотя это и не реально, потому что он не реализует IEnumable <IFoo>).

Я не уверен, что я полностью то, что вы хотите понять, но я подозреваю, что это:

public void Add<T>(T group) where T : IEnumerable<IFoo> { } 

, который позволит вам добавить любой объект T, где T является перечислимым множеством объектов IFoo.

Это то, что вы хотели?

С уважением, Ричард

Answer 4

Проблема здесь состоит в том, что общие ограничения типа полностью игнорировали компилятором (он смотрит только на типы параметров). Что касается компилятора, то передаваемый аргумент IEnumerable<T> также может быть IEnumerable<IFoo>.

Для получения полной информации по этому вопросу см. Раздел . 25.6.4 Вывод аргументов типа из C# Language Specification. Обратите внимание, что упоминание об использовании ограничений типа не упоминается.

Answer 5

Интересно .... Просто попробовал выборку. Дженерики продолжают держать меня на ногах.

//1 - First preference 
public void Add(BigFoo item) { Console.WriteLine("static BigFoo type Add"); } 
//2 - Second Preference 
public void Add<T>(T item) { Console.WriteLine("Generic Add"); } 
//3 - Third preferences 
public void Add(IFoo item) { Console.WriteLine("static IFoo interface Add"); } 
//4 - Compiles if 1-4 exist. Compile error (ambiguity) if only 3-4 exist. Compile error (cannot convert int to IFoo) if only 4 exists 
public void Add<T>(IEnumerable<T> group) where T : IFoo { }