C# Call jest niejednoznaczne podczas przekazywania grupy metod jako delegat

Question

Mam nadzieję, że ktoś może mi to wyjaśnić. Przepraszam, jeśli jest to powtarzać, słowa kluczowe, aby wyjaśnić, co widzę są poza mną teraz ..

tu jest jakiś kod, który kompiluje

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

i tu jest jakiś kod, który nie

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; 
    } 
} 

Dodanie przeciążenia konstruktora powoduje najwyraźniej niejasności, ale nie jestem pewien dlaczego. Math.Sqrt nie jest przeciążony i wyraźnie ma typ powrotu double, a nie Task < double>.

Tutaj jest błąd:

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>>)'

Może ktoś wyjaśnić, dlaczego wybór nie jest oczywisty dla kompilatora?

---

łatwe obejście dla tych, którzy dbają:

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

Answer 1

mieć nieznaczny błędnej interpretacji tego, jak Func<Tin, Tout> prac. Spójrz na the docs:

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

Pierwszy argument jest parametrem i ostatni argument jest typem powrotu.

Kiedy patrzysz na tej uproszczonej wersji kodu:

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) 
    { 
    } 
} 

Można zauważyć, że oba argumenty najpierw określić double, co jest argumentem, a następnie różnią Zwraca typ: z T vs Task<T>.

Jednak, jak oboje wiemy: przeciążanie odbywa się na podstawie nazwy metody, arytmetyczności parametru i typów parametrów. Typy zwrotu są całkowicie ignorowane. W naszym przypadku oznacza to, że mamy dwa argumenty: Func<Tin, Tout> z double jako argument oraz vs Task<T> jako typ zwracany.

Przełączanie argumenty wokół kompiluje dobrze:

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

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

Jeśli będziesz wyglądać w Visual Studio można zauważyć, że metoda ta jest obecnie nieaktywna, co ma sens, ponieważ argument jest typu Methoddouble i jako taki zawsze będzie pasował T, a nie Task<T>.

Więc w celu sprawdzenia, że ​​to teraz hit poprawnego przeciążenie jeśli przechodzą w inny, asynchroniczny metody, można dodać w drugim sposobem:

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

i wywołać ją przy użyciu

new MyClass<double, double>(MethodAsync); 

Teraz zauważysz, że trafienie asynchroniczne Func<Task<T>, U>> (które możesz sprawdzić, wykonując proste drukowanie na konsoli od konstruktorów).

---

W skrócie: próbujesz wykonać rozdzielczość przeciążania dla typu zwrotu, co oczywiście nie jest możliwe.