Une expression lambda C # peut-elle avoir plus d'une instruction?

Une expression lambda C # peut-elle inclure plusieurs instructions?

(Modifier: comme indiqué dans plusieurs des réponses ci-dessous, cette question portait à l'origine sur les «lignes» plutôt que sur les «déclarations».)

Sûr:

List<String> items = new List<string>();

var results = items.Where(i => 
            {
                bool result;

                if (i == "THIS")
                    result = true;
                else if (i == "THAT")
                    result = true;
                else
                    result = false;

                return result;
            }
        );

(Je suppose que vous parlez vraiment de plusieurs déclarations plutôt que de plusieurs lignes.)

Vous pouvez utiliser plusieurs instructions dans une expression lambda en utilisant des accolades, mais seule la syntaxe qui n'utilise pas d'accolades peut être convertie en une arborescence d'expression:

// Valid
Func<int, int> a = x => x + 1;
Func<int, int> b = x => { return x + 1; };        
Expression<Func<int, int>> c = x => x + 1;

// Invalid
Expression<Func<int, int>> d = x => { return x + 1; };

Vous pouvez mettre autant de nouvelles lignes que vous le souhaitez dans une expression lambda; C # ignore les nouvelles lignes.

Vous vouliez probablement poser des questions sur plusieurs déclarations .

Plusieurs instructions peuvent être entourées d'accolades.

Consultez la documentation .

Depuis C # 7:

Déclaration sur une seule ligne:

int expr(int x, int y) => x + y + 1; 

Déclaration multiligne:

int expr(int x, int y) { int z = 8; return x + y + z + 1; };

bien que ce soient des fonctions locales, je pense que cela semble un peu plus propre que les suivants et est effectivement le même

Func<int, int, int> a = (x, y) => x + y + 1;

Func<int, int, int> b = (x, y) => { int z = 8; return x + y + z + 1; };

Func<string, bool> test = (name) => 
{
   if (name == "yes") return true;
   else return false;
}

À partir d' expressions Lambda (Guide de programmation C #) :

Le corps d'une instruction lambda peut être constitué de n'importe quel nombre d'instructions; cependant, en pratique, il n'y en a généralement pas plus de deux ou trois.

Avec c # 7.0, vous pouvez également utiliser comme ça

Public string ParentMethod(int i, int x){
    int calculation = (i*x);
    (string info, int result) InternalTuppleMethod(param1, param2)
    {
        var sum = (calculation + 5);
        return ("The calculation is", sum);
    }
}

Disons que vous avez une classe:

    public class Point
    {
        public int X { get; set; }
        public int Y { get; set; }
    }

Avec le C # 7.0 à l'intérieur de cette classe, vous pouvez le faire même sans accolades:

Action<int, int> action = (x, y) => (_, _) = (X += x, Y += y);

et

Action<int, int> action = (x, y) => _ = (X += x, Y += y);

serait le même que:

Action<int, int> action = (x, y) => { X += x; Y += y; };

Cela peut également être utile si vous devez écrire une méthode régulière ou un constructeur sur une ligne ou lorsque vous avez besoin de plusieurs instructions / expressions à regrouper dans une seule expression:

public void Action(int x, int y) => (_, _) = (X += x, Y += y);

ou

public void Action(int x, int y) => _ = (X += x, Y += y);

ou

public void Action(int x, int y) => (X, Y) = (X + x, Y + y);

Plus d'informations sur la déconstruction des tuples dans la documentation .