Impossible d'utiliser un paramètre ref ou out dans les expressions lambda

Question

Pourquoi ne peut-on pas utiliser un paramètre ref ou out dans une expression lambda ?

J'ai rencontré cette erreur aujourd'hui et j'ai trouvé une solution de contournement mais j'étais quand même curieux de savoir pourquoi c'est une erreur de compilation.

CS1628: Impossible d'utiliser le paramètre 'parameter' en ref ou out à l'intérieur d'une méthode anonyme, d'une expression lambda ou d'une expression de requête

Voici un exemple simple :

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

Answer 1

Les lambdas donnent l'impression de changer la durée de vie des variables qu'elles capturent. Par exemple, l'expression lambda suivante fait en sorte que le paramètre p1 persiste plus longtemps que le cadre de méthode actuel, car sa valeur peut être consultée après que le cadre de méthode ne soit plus sur la pile

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

Une autre propriété des variables capturées est que les modifications apportées aux variables sont également visibles en dehors de l'expression lambda. Par exemple, le code suivant affiche 42

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

Ces deux propriétés produisent un certain ensemble d'effets qui vont à l'encontre d'un paramètre ref de la manière suivante:

• Les paramètres ref peuvent avoir une durée de vie fixe. Considérez le passage d'une variable locale en tant que paramètre ref à une fonction.
• Les effets secondaires dans la lambda doivent être visibles sur le paramètre ref lui-même. À la fois à l'intérieur de la méthode et chez l'appelant.

Ces propriétés sont quelque peu incompatibles et sont l'une des raisons pour lesquelles elles sont interdites dans les expressions lambda.

Answer 2

Sous le capot, la méthode anonyme est implémentée en élevant les variables capturées (c'est de cela que traite le corps de votre question) et en les stockant en tant que champs d'une classe générée par le compilateur. Il n'y a aucun moyen de stocker un paramètre ref ou out en tant que champ. Eric Lippert en a discuté dans une entrée de blog. Notez qu'il y a une différence entre les variables capturées et les paramètres de lambda. Vous pouvez avoir des "paramètres formels" comme les suivants car ils ne sont pas des variables capturées :

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

Answer 3

Vous le pouvez mais vous devez définir, de façon explicite, tous les types ainsi

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

Est invalide, cependant

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

Est valide

Answer 4

Comme il s'agit de l'un des principaux résultats pour "C# lambda ref" sur Google, je pense que je dois développer les réponses ci-dessus. La syntaxe des délégués anonymes plus ancienne (C# 2.0) fonctionne et prend en charge des signatures plus complexes (ainsi que des fermetures). Les lambdas et les délégués anonymes ont au moins une implémentation perçue partagée dans le backend du compilateur (s'ils ne sont pas identiques) - et surtout, ils prennent en charge les fermetures.

Ce que j'essayais de faire quand j'ai fait la recherche, pour démontrer la syntaxe :

public static ScanOperation CreateScanOperation(
    PrattTokenDefinition tokenDefinition)
{
    var oldScanOperation = tokenDefinition.ScanOperation; // Les fermetures continuent de fonctionner.
    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;
        };
}

Gardez simplement à l'esprit que les Lambdas sont plus sûrs sur le plan procédural et mathématique (en raison de la promotion de la valeur ref mentionnée précédemment) : vous pourriez ouvrir une boîte de Pandore. Réfléchissez bien avant d'utiliser cette syntaxe.

Answer 5

Et peut-être ceci?

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