Warum verursacht dies den Fehler CS4011: Argumente vom Typ können nicht aus der Verwendung abgeleitet werden?

Question

Ich habe folgendes Beispiel.

class Program { 
    static void Main(string[] args) { 
     var varc = new C(); 
     // Error CS0411 
     var varf1b = varc.F1(t => new { City = t.City }, (t, v) => v + t.Status, (g, a) => new { City = g.City, Bigstatus = a }); 
     // compiles OK 
     var varf1a = varc.F1(t => new { City = t.City }, (C t, int v) => v + t.Status, (g, a) => new { City = g.City, Bigstatus = a }); 

     // now replace varc by an anonymous class -- how to solve it now? 
     var varanon = new { }; 

    } 
    } 

    public class C { 
    public string City; 
    public int Status; 
    } 

    public static class X { 
    public static T1 F1<T2, T3, T4, T1>(
     this T2 s, 
     Func<T2, T3> g, 
     Func<T2, T4, T4> a, 
     Func<T3, T4, T1> r) 
     where T2 : class where T3 : class where T1 : class { 
     return null; 
    } 
    } 

Der erste Aufruf löst den Fehler CS0411 aus. Ich kann das nicht mit der üblichen Methode beheben, die die Typargumente hinzufügt, weil sie anonyme Typen verwendet. Glücklicherweise scheint das Hinzufügen von Typen zu einem der Lambdas ausreichend zu sein, um den Compiler glücklich zu machen.

Warum ist das? Was genau macht das erste Beispiel fehl und das zweite gelingt?

Und zweitens gibt es eine Möglichkeit, den Funktionsaufruf zu schreiben, so wird dies nicht passieren, und der Benutzer ist nicht konfrontiert mit dem Einfügen von Typen in das Lambda?

Ja, andere haben ähnliche Fragen gestellt, aber was hier einzigartig ist, ist (a) die Verwendung von anonymen Typen (b) das Update durch Hinzufügen von Typen zum Lambda.

---

Editiert: das Problem mit der Lösung gegeben ist, dass es nicht mit anonymen Klassen verwendet werden kann, weil es keine Typanmerkung möglich ist.

Answer 1

Die Frage ist: Was ist der Typ von v?

Der Compiler leitet den Typ der Eingabe aus dem als Ausgabe verwendeten Ausdruck nicht ab. Der Compiler verwendet den abgeleiteten Typ der Eingabe, damit Sie einen gültigen Ausdruck für die Ausgabe schreiben können. So bedeutet (t, v) => 1 nicht, dass v vom Typ int

Dies wird der Compiler versuchen, Ihren ersten Versuch zu analysieren:

var varf1b = varc.F1(t => new { City = t.City }, (t, v) => v + t.Status, (g, a) => new { City = g.City, Bigstatus = a });   
        |   |     | |     | |       | 
        |   |     | |     | |       | 
       T2: C (varc)  |     | ?     | ?       | 
           |     |      |     T1: new { string City, ? Bigstatus } 
         T3: new { string City }  |      | 
               T2: C     | 
                    T3: new { string City } 

Dies wird der Compiler versuchen, Ihren zweiten Versuch zu analysieren:

var varf1b = varc.F1(t => new { City = t.City }, (C t, int v) => v + t.Status, (g, a) => new { City = g.City, Bigstatus = a });   
        |   |     |  |     | |       | 
        |   |     |  |     | |       | 
       T2: C (varc)  |     | T4: int    | T4: int     | 
           |     |       |     T1: new { string City, int Bigstatus } 
         T3: new { string City }  |       | 
                T2: C      | 
                      T3: new { string City } 

also varf1b ist vom Typ: T1: new { string City, int Bigstatus } und die Inferenz ist erfolgreich.

Ein einfacheres Beispiel:

private static void GenericMethod<T1>(Func<T1, T1> func) 
{ 
    // ... 
} 

GenericMethod((a) => 1); // CS0411, `a` is not inferred from the body of the method. 

GenericMethod<int>((a) => 1); // compiles 

GenericMethod((int a) => 1); // compiles 

Answer 2

Die Antwort, die ich jetzt sehe, ist, dass der Compiler keine Information hat, dass er die Art von T4 zu bestimmen, verwenden kann. Insbesondere kann es den Ausdruck nicht untersuchen und daraus einen Typ ableiten.

Um es zu beheben, benötigen wir ein Argument, das den Typ von T4 explizit festlegt. Hier ist eine Möglichkeit, es zu tun.

var varf1c = varc.F2(t => new { City = t.City }, 0, (t, v) => v + t.Status, (g, a) => new { City = g.City, Bigstatus = a }); 

public static T1 F2<T2, T3, T4, T1>(
    this T2 s, 
    Func<T2, T3> g, 
    T4 i, 
    Func<T2, T4, T4> a, 
    Func<T3, T4, T1> r) 
    where T2 : class where T3 : class where T1 : class { 
    return null; 
} 

Nun T4 ist mit dem Argumente literal 0 zuzugeordnet, aus dem der Compiler eine Art von int ableiten kann.