Não é possível usar o parâmetro ref ou out nas expressões lambda

Por que você não pode usar um parâmetro ref ou out em uma expressão lambda?

Encontrei o erro hoje e encontrei uma solução alternativa, mas ainda estava curioso por que esse é um erro em tempo de compilação.

CS1628 : Não é possível usar no parâmetro ref ou out 'parameter' dentro de um método anônimo, expressão lambda ou expressão de consulta

Aqui está um exemplo simples:

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

Os lambdas parecem alterar o tempo de vida das variáveis ​​que eles capturam. Por exemplo, a seguinte expressão lambda faz com que o parâmetro p1 viva mais que o quadro de método atual, pois seu valor pode ser acessado depois que o quadro de método não estiver mais na pilha

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

Outra propriedade das variáveis ​​capturadas é que as alterações na variável também são visíveis fora da expressão lambda. Por exemplo, as seguintes impressões 42

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

Essas duas propriedades produzem um certo conjunto de efeitos que voam na face de um parâmetro ref das seguintes maneiras

• Os parâmetros ref podem ter uma vida útil fixa. Considere passar uma variável local como um parâmetro ref para uma função.
• Os efeitos colaterais no lambda precisariam ser visíveis no próprio parâmetro ref. Tanto no método como no chamador.

Essas são propriedades um tanto incompatíveis e são uma das razões pelas quais elas não são permitidas nas expressões lambda.

Sob o capô, o método anônimo é implementado ao içar variáveis ​​capturadas (que é o objetivo do seu corpo de perguntas) e armazená-las como campos de uma classe gerada pelo compilador. Não há como armazenar um refou outparâmetro como um campo. Eric Lippert discutiu isso em uma entrada de blog . Observe que há uma diferença entre variáveis ​​capturadas e parâmetros lambda. Você pode ter "parâmetros formais" como os seguintes, pois não são variáveis ​​capturadas:

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

Você pode, mas deve definir explicitamente todos os tipos para

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

É inválido, no entanto

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

É válido

Como esse é um dos principais resultados para "C # lambda ref" no Google; Sinto que preciso expandir as respostas acima. A sintaxe de delegado anônimo mais antiga (C # 2.0) funciona e suporta assinaturas mais complexas (além de fechamentos). Os delegados anônimos e da Lambda, no mínimo, compartilharam a implementação percebida no back-end do compilador (se não forem idênticos) - e o mais importante, eles suportam fechamentos.

O que eu estava tentando fazer quando fiz a pesquisa, para demonstrar a sintaxe:

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

Lembre-se de que as Lambdas são processualmente e matematicamente mais seguras (devido à promoção do valor de referência mencionada anteriormente): você pode abrir uma lata de worms. Pense com cuidado ao usar esta sintaxe.

E talvez isso?

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