Der Parameter ref oder out kann nicht in Lambda-Ausdrücken verwendet werden

Warum können Sie in einem Lambda-Ausdruck keinen ref- oder out-Parameter verwenden?

Ich bin heute auf den Fehler gestoßen und habe eine Problemumgehung gefunden, war aber immer noch neugierig, warum dies ein Fehler beim Kompilieren ist.

CS1628 : Der Parameter 'parameter' in ref oder out kann nicht in einer anonymen Methode, einem Lambda-Ausdruck oder einem Abfrageausdruck verwendet werden

Hier ist ein einfaches Beispiel:

private void Foo()
{
    int value;
    Bar(out value);
}

private void Bar(out int value)
{
    value = 3;
    int[] array = { 1, 2, 3, 4, 5 };
    int newValue = array.Where(a => a == value).First();
}

Lambdas scheinen die Lebensdauer der von ihnen erfassten Variablen zu ändern. Beispielsweise bewirkt der folgende Lambda-Ausdruck, dass der Parameter p1 länger als der aktuelle Methodenrahmen lebt , da auf seinen Wert zugegriffen werden kann, nachdem sich der Methodenrahmen nicht mehr auf dem Stapel befindet

Func<int> Example(int p1) {
  return () => p1;
}

Eine weitere Eigenschaft erfasster Variablen ist, dass Änderungen an der Variablen auch außerhalb des Lambda-Ausdrucks sichtbar sind. Zum Beispiel die folgenden Drucke 42

void Example2(int p1) {
  Action del = () => { p1 = 42; }
  del();
  Console.WriteLine(p1);
}

Diese beiden Eigenschaften erzeugen eine Reihe von Effekten, die auf folgende Weise einem ref-Parameter entgegenwirken

• ref-Parameter können eine feste Lebensdauer haben. Überlegen Sie, ob Sie eine lokale Variable als ref-Parameter an eine Funktion übergeben möchten.
• Nebenwirkungen im Lambda müssten auf dem ref-Parameter selbst sichtbar sein. Sowohl innerhalb der Methode als auch im Aufrufer.

Dies sind etwas inkompatible Eigenschaften und einer der Gründe, warum sie in Lambda-Ausdrücken nicht zulässig sind.

Unter der Haube wird die anonyme Methode implementiert, indem erfasste Variablen (worum es in Ihrem Fragetext geht) angehoben und als Felder einer vom Compiler generierten Klasse gespeichert werden. Es gibt keine Möglichkeit, einen refoder outParameter als Feld zu speichern . Eric Lippert hat es in einem Blogeintrag besprochen . Beachten Sie, dass es einen Unterschied zwischen erfassten Variablen und Lambda-Parametern gibt. Sie können "formale Parameter" wie die folgenden haben, da diese keine erfassten Variablen sind:

delegate void TestDelegate (out int x);
static void Main(string[] args)
{
    TestDelegate testDel = (out int x) => { x = 10; };
    int p;
    testDel(out p);
    Console.WriteLine(p);
}

Sie können aber Sie müssen explizit alle Typen so definieren

(a, b, c, ref d) => {...}

Ist jedoch ungültig

(int a, int b, int c, ref int d) => {...}

Ist gültig

Da dies eines der Top-Ergebnisse für "C # lambda ref" bei Google ist; Ich denke, ich muss die obigen Antworten erweitern. Die ältere (C # 2.0) anonyme Delegatensyntax funktioniert und unterstützt komplexere Signaturen (sowie Schließungen). Lambdas und anonyme Delegierte haben zumindest die wahrgenommene Implementierung im Compiler-Backend geteilt (wenn sie nicht identisch sind) - und vor allem unterstützen sie Schließungen.

Was ich bei der Suche versucht habe, um die Syntax zu demonstrieren:

public static ScanOperation<TToken> CreateScanOperation(
    PrattTokenDefinition<TNode, TToken, TParser, TSelf> tokenDefinition)
{
    var oldScanOperation = tokenDefinition.ScanOperation; // Closures still work.
    return delegate(string text, ref int position, ref PositionInformation currentPosition)
        {
            var token = oldScanOperation(text, ref position, ref currentPosition);
            if (token == null)
                return null;
            if (tokenDefinition.LeftDenotation != null)
                token._led = tokenDefinition.LeftDenotation(token);
            if (tokenDefinition.NullDenotation != null)
                token._nud = tokenDefinition.NullDenotation(token);
            token.Identifier = tokenDefinition.Identifier;
            token.LeftBindingPower = tokenDefinition.LeftBindingPower;
            token.OnInitialize();
            return token;
        };
}

Denken Sie daran, dass Lambdas prozedural und mathematisch sicherer sind (aufgrund der bereits erwähnten Referenzwertförderung): Sie könnten eine Dose Würmer öffnen. Überlegen Sie genau, wenn Sie diese Syntax verwenden.

Und vielleicht das?

private void Foo()
{
    int value;
    Bar(out value);
}

private void Bar(out int value)
{
    value = 3;
    int[] array = { 1, 2, 3, 4, 5 };
    var val = value; 
    int newValue = array.Where(a => a == val).First();
}