Разрешение перегрузки метода с использованием динамического аргумента

Проблема здесь в выводе типа. Компилятор пытается выяснить, какую перегрузку использовать на основе аргумента, но он также пытается выяснить, какой тип аргумента основан на выбранной перегрузке. В случае M(() => DynamicObject()) процесс выглядит примерно так:

1. Аргумент метода — лямбда с нулевыми параметрами. Это дает нам все три перегрузки как возможности.
2. Тело лямбды возвращает dynamic. Поскольку существует неявное преобразование из dynamic в любой другой тип, теперь мы знаем, что все три перегрузки хороши.
3. Попробуйте выбрать лучшую перегрузку. В большинстве случаев «лучший» означает наиболее производный тип. Поскольку и int, и string происходят от object, перегрузки с int и string считаются лучшими.
4. Теперь у нас есть две «лучшие» перегрузки, что означает, что компилятор не может выбрать одну из них. Компиляция не работает.

Теперь о возможных решениях вашей проблемы:

1. Сделайте тип лямбды явным, используя приведение или типизированную локальную переменную:

   M((Func<dynamic>)(() => DynamicObject()));
   

   or

   Func<dynamic> f = () => DynamicObject();
   M(f);
   

2. Переименуйте динамическую перегрузку во что-то вроде DynamicM. Таким образом, вам не придется иметь дело с разрешением перегрузки.

3. Это кажется мне несколько неправильным: убедитесь, что перегрузка dynamic является единственной, которая подходит, путем приведения к object:

   M(() => (object)DynamicObject())
   

Из определения в MSDN:

динамический

Динамический тип в большинстве случаев ведет себя как объект типа. Однако операции, содержащие выражения динамического типа, не разрешаются и не проверяются компилятором. Компилятор упаковывает информацию об операции, и эта информация позже используется для оценки операции во время выполнения. В рамках этого процесса переменные типа dynamic компилируются в переменные типа object. Следовательно, тип dynamic существует только во время компиляции, а не во время выполнения.

Таким образом, динамический не существует при компиляции, потому что ему нужно преобразовать его в назначение *type*, и поэтому он не может его разрешить. Что такое тип назначения?

На самом деле, если вы сделаете что-то вроде этого:

static void M(Func<int> f) { }
static void M(Func<string> f) { }
static void M(Func<object> f) { } // could be also declared like dynamic here, works by the way

static object DynamicObject()
{
    return new object();
}

static void Test()
{
    M(() => 0);
    M(() => "");
    M(() => DynamicObject());
}

Он прекрасно работает так, как вы хотите, так как object присутствует как тип уже во время компиляции, в отличие от типа dynamic, который необходимо преобразовать.