Peut un C# expression lambda ont plus qu'une seule déclaration?

Peut un C# lambda expression comprend plus qu'une seule déclaration?

(Edit: Comme mentionné dans plusieurs réponses ci-dessous, à cette question initialement posée à propos de "lignes" plutôt que des "déclarations".)

Oui, vous pouvez utiliser plusieurs lignes. Je ne me sens pas bien en faire une réponse complète.
quoi ne pas faire une réponse... vous avez raison!
Parce que c'est une question oui / non, je n'ai pas l'impression que c'est digne de la rep, il serait de générer à partir de upvotes.

InformationsquelleAutor paseena | 2011-04-13

c#lambda

177

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

InformationsquelleAutor RQDQ

27

Vous pouvez mettre autant de retours à la ligne que vous le souhaitez dans une expression lambda; C# ignore les sauts de ligne.

Vous avez probablement destiné à poser au sujet de plusieurs états.

Plusieurs instructions peuvent être enveloppés dans des accolades.

Voir le la documentation.
- Ne serait-il pas plus exact de dire que C# traite tous les espaces, y compris les retours à la ligne, de la même manière? Ça sonne un peu faux de dire qu'il ignore les sauts de ligne - il semble juste des bandes complètement, et vous pourriez diviser un mot-clé à travers un retour à la ligne ou quelque chose.
InformationsquelleAutor SLaks
26

(Je suis en supposant que vous êtes réellement en train de parler de plusieurs états, plutôt que de plusieurs lignes.)

Vous pouvez utiliser plusieurs instructions dans une lambda expression à l'aide d'accolades, mais uniquement la syntaxe qui permet de ne pas utiliser l'appareil peut être converti 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; };
```
- Je suis en train d'essayer de comprendre pourquoi Func permettre d'accolades et d'Expression n'est pas ce qui. De toute façon Expression sera respecté comme Func, Est-il possible d'ajouter plusieurs lignes, la logique de l'Expression de l'Arbre? Si non, Pourquoi il y a restriction de qui?
- L'Expression sera respecté comme Func" Pas toujours. La plupart du temps, il n'est jamais compilé un délégué, à tout juste examiné en tant que données. L'Expression des arbres .NET 4.0 ne le gain de la possibilité d'inclure plusieurs déclarations via Expression.Bloc, mais le C# langue ne supporte pas que. Il pourrait, mais qui aurait besoin de plus de la conception/mise en œuvre/travail de test.
InformationsquelleAutor Jon Skeet

Depuis C# 7:

Unique instruction de la ligne:

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

Multiligne déclaration:

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

bien que ceux-ci sont appelés aux fonctions locales, je pense que cela est un peu plus propre que les autres et c'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; };

InformationsquelleAutor BigChief

4
```
Func<string, bool> test = (name) => 
{
   if (name == "yes") return true;
   else return false;
}
```
- Func<string, bool> test = nom => nom=="oui";
- Le régime est en train de démontrer le multi-ligne format demandé par la question, pas divertissant golf suggestions. Pour mettre en œuvre votre code sage serait de faire un "pas de réponse"!
InformationsquelleAutor Polity
3

De Les Expressions Lambda (Guide De Programmation C#):

Le corps d'une déclaration lambda peut
se composent d'un certain nombre de déclarations;
cependant, dans la pratique, il y a
en général pas plus de deux ou trois.

InformationsquelleAutor jfs

Avec c# 7.0
Vous pouvez l'utiliser comme ça aussi

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

InformationsquelleAutor jigar prajapati

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 les accolades:

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

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

serait la même chose que:

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

Ce pourrait également être utile si vous avez besoin d'écrire l'régulièrement une méthode ou d'un constructeur dans une ligne ou lorsque vous avez besoin de plus d'une déclaration d'expression, pour être emballé dans une expression:

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

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

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

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

InformationsquelleAutor Konard

Vous devez vous connecter pour publier un commentaire.