Дженерики, наследование и отказавшее разрешение метода компилятора C#

Как объяснил Эрик Липперт, компилятор выбирает метод DoStuff (IEnumerable ), где Tother: T {} , потому что он выбирает методы до проверки ограничений. Поскольку строка может выполнять IEnumerable <> , компилятор сопоставляет ее с методом этого дочернего класса. Компилятор работает правильно , как описано в спецификации C #.

Требуемый порядок разрешения методов может быть установлен путем реализации DoStuff как метода расширения . Методы расширения проверяются после методов базового класса, поэтому он не будет пытаться сопоставить строку с DoStuff IEnumerable , пока после он попытался сопоставить его с DoStuff .

Следующий код демонстрирует желаемый порядок разрешения метода, ковариацию и наследование. Скопируйте / вставьте его в новый проект.

Этот самый большой недостаток , о котором я могу думать, заключается в том, что вы не можете использовать base в методах переопределения, но я думаю, что есть есть способы обойти это (спросите, если вам интересно).

using System;
using System.Collections.Generic;

namespace MethodResolutionExploit
{
    public class BaseContainer<T> : IEnumerable<T>
    {
        public void DoStuff(T item) { Console.WriteLine("\tbase"); }
        public IEnumerator<T> GetEnumerator() { return null; }
        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { return null; }
    }        
    public class Container<T> : BaseContainer<T> { }
    public class ContainerChild<T> : Container<T> { }
    public class ContainerChildWithOverride<T> : Container<T> { }
    public static class ContainerExtension
    {
        public static void DoStuff<T, Tother>(this Container<T> container, IEnumerable<Tother> collection) where Tother : T
        {
            Console.WriteLine("\tContainer.DoStuff<Tother>()");
        }
        public static void DoStuff<T, Tother>(this ContainerChildWithOverride<T> container, IEnumerable<Tother> collection) where Tother : T
        {
            Console.WriteLine("\tContainerChildWithOverride.DoStuff<Tother>()");
        }
    }

    class someBase { }
    class someChild : someBase { }
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("BaseContainer:");
            var baseContainer = new BaseContainer<string>();
            baseContainer.DoStuff("");

            Console.WriteLine("Container:");
            var container = new Container<string>();
            container.DoStuff("");
            container.DoStuff(new List<string>());

            Console.WriteLine("ContainerChild:");
            var child = new ContainerChild<string>();
            child.DoStuff("");
            child.DoStuff(new List<string>());

            Console.WriteLine("ContainerChildWithOverride:");
            var childWithOverride = new ContainerChildWithOverride<string>();
            childWithOverride.DoStuff("");
            childWithOverride.DoStuff(new List<string>());

            //note covariance
            Console.WriteLine("Covariance Example:");
            var covariantExample = new Container<someBase>();
            var covariantParameter = new Container<someChild>();
            covariantExample.DoStuff(covariantParameter);

            // this won't work though :(
            // var covariantExample = new Container<Container<someBase>>();
            // var covariantParameter = new Container<Container<someChild>>();
            // covariantExample.DoStuff(covariantParameter);

            Console.ReadKey();
        }
    }
}

Вот результат:

BaseContainer:
        base
Container:
        base
        Container.DoStuff<Tother>()
ContainerChild:
        base
        Container.DoStuff<Tother>()
ContainerChildWithOverride:
        base
        ContainerChildWithOverride.DoStuff<Tother>()
Covariance Example:
        Container.DoStuff<Tother>()

Вы видите какие-либо проблемы с этой работой?

Компилятор попытается сопоставить параметр с IEnumerable . Тип String реализует IEnumerable , поэтому он предполагает, что T является "char".

После этого компилятор проверяет другое условие «where OtherT: T», и это условие не выполняется. Отсюда ошибка компилятора.

Моя УГАДАЯ, и это предположение, потому что я действительно не знаю, заключается в том, что он сначала смотрит в производный класс, чтобы разрешить вызов метода (потому что ваш объект является объектом производного типа ). Если и только если это невозможно, он переходит к рассмотрению методов базовых классов, чтобы решить эту проблему. В вашем случае, поскольку он МОЖЕТ разрешить его с помощью перегрузки

DoStuff <Tother>(IEnumerable<Tother> collection)

, он попытался втиснуть его в это. Таким образом, он МОЖЕТ разрешить это в том, что касается параметра, но тогда он сталкивается с препятствием в ограничениях. В этот момент он уже решил вашу перегрузку, поэтому дальше не смотрит, а просто выдает ошибку. Имеет смысл?

Я думаю, это как-то связано с тем фактом, что char - это тип значения, а string - ссылочный тип. Похоже, вы определяете

TOther : T

, а char не является производным от строки.

Я не совсем понимаю, чего вы пытаетесь достичь, что мешает вам использовать только два метода, DoStuff (элемент T) и DoStuff (коллекция IEnumerable )?