Why doesn't C#'s overload resolution work between Func<T,T> and Action<T>? [duplicate]

Question

So, a fairly common extension method for IEnumerable, Run:

public static IEnumerable<T> Run<T>(this IEnumerable<T> source, Action<T> action)
{
    foreach (var item in source)
    {
        action(item);
        yield return item;
    }
}

When I try to use that with, for instance, DbSet.Add:

invoice.Items.Run(db.InvoiceItems.Add);
// NB: Add method signature is
// public T Add(T item) { ... }

... the compiler complains that it has the wrong return type, because it is expecting a void method. So, add an overload for Run that takes a Func instead of Action:

public static IEnumerable<T> Run<T>(this IEnumerable<T> source, Func<T, T> action)
{
    return source.Select(action).ToList().AsEnumerable();
}

And now the compiler complains that "The call is ambiguous between the following methods..."

So my question is, how can the Action overload of the Run method cause ambiguity when it is not valid for the method group?

Answer 1

This has already been explained by Eric and Jon in answers to this question. Long story short - this is how C# compiler works; precisely, when dealing with method group conversion deciding what delegate it will be converted to utilizes overload resolution, which does not take return types in account:

The principle here is that determining method group convertibility requires selecting a method from a method group using overload resolution, and overload resolution does not consider return types.

In your example compiler sees both Action<T> and Func<T, T> as best match for Add. This adds up to two possible choices, and since it requires one - appropriate error is issued.