Czy wyrażenie lambda w języku C # może mieć więcej niż jedną instrukcję?

Czy wyrażenie lambda języka C # może zawierać więcej niż jedną instrukcję?

(Edytuj: jak wspomniano w kilku poniższych odpowiedziach, to pytanie pierwotnie dotyczyło „wierszy”, a nie „stwierdzeń”).

Pewnie:

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

(Zakładam, że naprawdę mówisz o wielu instrukcjach, a nie o wielu wierszach).

Możesz użyć wielu instrukcji w wyrażeniu lambda przy użyciu nawiasów klamrowych, ale tylko składnię, która nie używa nawiasów klamrowych, można przekształcić w drzewo wyrażeń:

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

W wyrażeniu lambda możesz umieścić dowolną liczbę nowych linii; C # ignoruje znaki nowej linii.

Prawdopodobnie chciałeś zapytać o wiele stwierdzeń .

Wiele instrukcji może być umieszczonych w nawiasach klamrowych.

Zobacz dokumentację .

Od C # 7:

Instrukcja jednowierszowa:

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

Oświadczenie wielowierszowe:

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

chociaż są to nazywane funkcjami lokalnymi, wydaje mi się, że wygląda to nieco czyściej niż poniższe i faktycznie jest takie samo

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

Z wyrażeń lambda (przewodnik programowania w języku C #) :

Treść wyrażenia lambda może składać się z dowolnej liczby instrukcji; jednak w praktyce jest ich zazwyczaj nie więcej niż dwa lub trzy.

Z c # 7.0 możesz również używać w ten sposób

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

Powiedzmy, że masz klasę:

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

Dzięki C # 7.0 w tej klasie możesz to zrobić nawet bez nawiasów klamrowych:

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

i

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

byłby taki sam jak:

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

Może to być również pomocne, jeśli chcesz napisać zwykłą metodę lub konstruktor w jednym wierszu lub gdy potrzebujesz więcej niż jednej instrukcji / wyrażenia do spakowania w jedno wyrażenie:

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

lub

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

lub

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

Więcej o dekonstrukcji krotek w dokumentacji .