¿Por qué la resolución de sobrecarga de C# no funciona entre Func <T,T> y Acción <T>?

Question

Por lo tanto, un método bastante común para la extensión 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; 
    } 
} 

Cuando trato de usar que con, por ejemplo, DbSet.Add:

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

... el compilador se queja de que tiene el tipo de devolución incorrecto, porque está esperando un método vacío. Por lo tanto, añadir una sobrecarga de ejecución que toma un Func lugar de acción:

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

Y ahora el compilador se queja de que "La llamada es ambigua entre los métodos siguientes ..."

Así que mi pregunta es, ¿Cómo puede la sobrecarga de acción del método Run causar ambigüedad cuando no es válida para el grupo de métodos?

Answer 1

Esto ya ha sido explicado por Eric y Jon en las respuestas a this question. Para resumir, así es como funciona el compilador de C#; Precisamente, cuando se trata de la conversión de grupo Método de decidir qué delegado, este se convertirá a utiliza resolución de sobrecarga, que no toma tipos volver en cuenta:

El principio aquí es que la determinación de la convertibilidad grupo método requiere la selección de un método desde un grupo de métodos que usa resolución de sobrecarga, y la resolución de sobrecarga no considera los tipos de devolución.

En su ejemplo compilador ve tanto Action<T> y Func<T, T> como mejor partido de Add. Esto se suma a dos opciones posibles, y dado que requiere una, se emite un error apropiado.

Answer 2

sobrecarga try en forma correcta:

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

Answer 3

No puedo responder por qué sino para resolver la ambigüedad se puede convertir explícitamente su función:

invoice.Items.Run((Func<T,T>)db.InvoiceItems.Add); 

o utilizar un lambda

invoice.Items.Run(x => db.InvoiceItems.Add(x)); 

Answer 4

No sé por qué no puede resolverlo automáticamente, pero aquí hay dos soluciones:

// with T replaced with the actual type: 
invoice.Items.Run((Func<T, T>)db.InvoiceItems.Add); 
invoice.Items.Run(new Func<T, T>(db.InvoiceItems.Add)); 

¿Por qué necesita estos métodos de todos modos? ¿Qué pasa con:

foreach (var item in invoice.Items) 
    db.InvoiceItems.Add(item); 

La legibilidad de este es mucho mejor. A menos que tenga una buena razón para necesitar el método Run, recomendaría no usarlo. Por lo que he visto, no hay una razón, al menos para la sobrecarga Action<T>.