C# La chiamata è ambigua quando si passa un gruppo di metodi come delegato

Question

Speriamo che qualcuno possa spiegarmelo. Scusate se è una ripetizione, le parole chiave per spiegare quello che sto vedendo sono al di là di me per ora ..

qui è un codice che compila

class Program 
{ 
    static void Main(string[] args) 
    { 
     new Transformer<double, double>(Math.Sqrt); 
    } 
} 

class Transformer<Tin, Tout> 
{ 
    Func<Tin, Task<Tout>> actor; 
    public Transformer(Func<Tin, Tout> actor) 
    { 
     this.actor = input => Task.Run<Tout>(() => actor(input)); 
    } 
} 

e qui è un codice che non lo fa

class Program 
{ 
    static void Main(string[] args) 
    { 
     new Transformer<double, double>(Math.Sqrt); 
    } 
} 

public class Transformer<Tin, Tout> 
{ 
    Func<Tin, Task<Tout>> actor; 
    public Transformer(Func<Tin, Tout> actor) 
    { 
     this.actor = input => Task.Run<Tout>(() => actor(input)); 
    } 

    public Transformer(Func<Tin, Task<Tout>> actor) 
    { 
     this.actor = actor; 
    } 
} 

Aggiungendo il sovraccarico del costruttore, questo crea apparentemente ambiguità ma non sono sicuro del perché. Math.Sqrt non è sovraccarico e ha chiaramente un tipo di ritorno doppio, non Task < double>.

Ecco l'errore:

The call is ambiguous between the following methods or properties: 'ConsoleApplication1.Transformer<double,double>.Transformer(System.Func<double,double>)' and 'ConsoleApplication1.Transformer<double,double>.Transformer(System.Func<double,System.Threading.Tasks.Task<double>>)'

qualcuno può spiegare perché la scelta non è ovvio per il compilatore?

---

soluzione facile per coloro che hanno a cuore:

class Program 
{ 
    static void Main(string[] args) 
    { 
     new Transformer<double, double>(d => Math.Sqrt(d)); 
    } 
} 

Answer 1

Hai un leggero errore di interpretazione di come Func<Tin, Tout> opere. Date un'occhiata a the docs:

public delegate TResult Func<in T, out TResult>(
    T arg 
) 

Il primo argomento è un parametro e l'ultimo argomento è il tipo di ritorno.

Quando si guarda a questa versione semplificata del codice:

internal class Program 
{ 
    public static void Main(string[] args) 
    { 
     new MyClass<double, double>(Method); 
    } 

    private static double Method(double d) 
    { 
     throw new NotImplementedException(); 
    } 
} 


internal class MyClass<T, U> 
{ 
    public MyClass(Func<U, T> arg) 
    { 
    } 

    public MyClass(Func<U, Task<T>> arg) 
    { 
    } 
} 

Si noterà che entrambi gli argomenti prima specificano il double, che è un argomento, e quindi si differenziano per tipo di ritorno: il T vs Task<T>.

Tuttavia, come entrambi sappiamo: l'overloading viene eseguito in base al nome del metodo, al parametro arity e ai tipi di parametri. I tipi di ritorno sono completamente ignorati. Nel nostro caso ciò significa che abbiamo due Func<Tin, Tout> con double come argomento e T rispetto a Task<T> come tipo di reso.

commutazione gli argomenti intorno compila bene:

internal class MyClass<T, U> 
{ 
    public MyClass(Func<T, U> arg) 
    { 
    } 

    public MyClass(Func<Task<T>, U> arg) 
    { 
    } 
} 

Se ti aspetto in Visual Studio si noterà che questo metodo è ora in grigio, che ha un senso, perché l'argomento è di tipo Methoddouble e come tale corrisponderà sempre a T e non a Task<T>.

Quindi, al fine di verificare che sarebbe ora colpire il sovraccarico corretta se si passa in un altro, metodo asincrono, è possibile aggiungere in un secondo metodo:

private static double MethodAsync(Task<double> d) 
{ 
    throw new NotImplementedException(); 
} 

e chiamare utilizzando

new MyClass<double, double>(MethodAsync); 

Si noterà ora che viene eseguito il colpo asincrono Func<Task<T>, U>> (che è possibile verificare facendo semplicemente una stampa alla console dai costruttori).

---

In breve: si sta tentando di eseguire la risoluzione di sovraccarico su un tipo di reso, che ovviamente non è possibile.