Perché la risoluzione di sovraccarico di C# non funziona tra Func <T,T> e Action <T>?

Question

Quindi, un metodo abbastanza comune estensione per 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; 
    } 
} 

Quando provo ad usare quella con, ad esempio, DbSet.Add:

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

... il compilatore si lamenta che ha il tipo di ritorno sbagliato, perché si aspetta un metodo di annullamento. Quindi, aggiungere un sovraccarico per Run che prende una Funz invece di Azione:

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

E ora il compilatore si lamenta che "La chiamata è ambigua tra i seguenti metodi ..."

Quindi la mia domanda è, in che modo l'overload di Action del metodo Run può causare ambiguità quando non è valido per il gruppo di metodi?

Answer 1

Questo è già stato spiegato da Eric e Jon nelle risposte a this question. Per farla breve - questo è il modo in cui funziona il compilatore C#; precisamente, quando si tratta di conversione metodo gruppo decidere cosa delegato che sarà convertita utilizza la risoluzione di sovraccarico, che non tiene tipi restituiti in conto:

Il principio è che la determinazione convertibilità metodo gruppo richiede la selezione di un metodo da un gruppo di metodi che utilizza la risoluzione di sovraccarico e la risoluzione di sovraccarico non considera i tipi di ritorno.

Nel tuo esempio compilatore vede sia Action<T> e Func<T, T> come migliore corrispondenza per Add. Ciò consente di aggiungere fino a due possibili scelte e, poiché richiede uno, viene emesso un errore appropriato.

Answer 2

sovraccarico prova nel modo giusto:

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

Answer 3

non posso rispondere perché ma per risolvere l'ambiguità si può lanciare in modo esplicito la funzione:

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

o utilizzare un lambda

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

Answer 4

Non so perché non possa risolverlo automaticamente, ma ecco due soluzioni alternative:

// 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)); 

Perché avete bisogno di questi metodi comunque? Cosa c'è di sbagliato con:

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

La leggibilità di questo è molto meglio. A meno che tu non abbia una buona ragione per aver bisogno del metodo Run, ti consiglio di non usarlo. Da quello che ho visto, non c'è una tale ragione, almeno per il sovraccarico di Action<T>.