Impossibile utilizzare il parametro ref o out nelle espressioni lambda

Perché non puoi usare un parametro ref o out in un'espressione lambda?

Oggi ho riscontrato l'errore e ho trovato una soluzione alternativa, ma ero ancora curioso di sapere perché si tratta di un errore di compilazione.

CS1628 : Impossibile utilizzare nel parametro ref o out 'parametro' all'interno di un metodo anonimo, espressione lambda o espressione di query

Ecco un semplice esempio:

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

Le lambda hanno l'aspetto di cambiare la durata delle variabili che catturano. Ad esempio la seguente espressione lambda fa sì che il parametro p1 viva più a lungo del frame del metodo corrente poiché è possibile accedere al suo valore dopo che il frame del metodo non è più nello stack

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

Un'altra proprietà delle variabili acquisite è che le modifiche alla variabile sono visibili anche all'esterno dell'espressione lambda. Ad esempio, le seguenti stampe 42

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

Queste due proprietà producono un certo insieme di effetti che volano di fronte a un parametro ref nei modi seguenti

• i parametri ref potrebbero avere una durata fissa. Considera di passare una variabile locale come parametro ref a una funzione.
• Gli effetti collaterali nella lambda dovrebbero essere visibili sul parametro ref stesso. Sia all'interno del metodo che nel chiamante.

Queste sono proprietà alquanto incompatibili e sono uno dei motivi per cui non sono consentite nelle espressioni lambda.

Sotto il cofano, il metodo anonimo viene implementato sollevando le variabili catturate (che è ciò di cui tratta il corpo della domanda) e memorizzandole come campi di una classe generata dal compilatore. Non è possibile memorizzare un parametro refo outcome campo. Eric Lippert ne ha discusso in un post di blog . Si noti che esiste una differenza tra variabili acquisite e parametri lambda. È possibile avere "parametri formali" come il seguente come sono variabili non catturati:

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

Puoi ma devi definire esplicitamente tutti i tipi in questo modo

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

Non è valido, tuttavia

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

È valido

Poiché questo è uno dei migliori risultati di "ref # lambda C" su Google; Sento di aver bisogno di espandere le risposte di cui sopra. La sintassi del delegato anonimo (C # 2.0) precedente funziona e supporta firme più complesse (nonché chiusure). Almeno i delegati Lambda e anonimi hanno condiviso l'implementazione percepita nel backend del compilatore (se non sono identici) - e, soprattutto, supportano le chiusure.

Quello che stavo cercando di fare quando ho fatto la ricerca, per dimostrare la sintassi:

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

Ricorda solo che Lambdas è proceduralmente e matematicamente più sicuro (a causa della promozione del valore di riferimento menzionata in precedenza): potresti aprire una lattina di worm. Pensa attentamente quando usi questa sintassi.

E forse questo?

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