2008-11-14 8 views
56

Je viens de passer en revue cette syntaxe dans certaines des questions de ce forum, mais Google et tout autre moteur de recherche tend à bloquer tout sauf les lettres et les chiffres dans la recherche, il est impossible de rechercher "=>".Que signifie la syntaxe '=>' dans C#?

Donc, quelqu'un peut-il me dire ce que c'est et comment il est utilisé?

+0

duplication possible de [C# Lambda expression, pourquoi devrais-je l'utiliser?] (http://stackoverflow.com/questions/167343/c-sharp-lambda-expression-why-should-i-use-this) – nawfal

Répondre

66

C'est l'opérateur lambda.

De C# 3 à C# 5, ceci a seulement été utilisé pour lambda expressions. Il s'agit essentiellement d'une forme plus courte de anonymous methods introduite dans C# 2, mais peut également être convertie en expression trees.

À titre d'exemple:

Func<Person, string> nameProjection = p => p.Name; 

équivaut à:

Func<Person, string> nameProjection = delegate (Person p) { return p.Name; }; 

Dans les deux cas, vous créez un délégué avec un Person paramètre, retourner le nom (comme une chaîne) de cette personne.

En C# 6, la même syntaxe est utilisée pour membres à corps d'expression, par ex.

// Expression-bodied property 
public int IsValid => name != null && id != -1; 

// Expression-bodied method 
public int GetHashCode() => id.GetHashCode(); 

Voir aussi:

(Et en effet de nombreuses questions semblables - essayez les lambda et lambda-expressions tags.)

+0

Étant donné que la question ne dit rien au sujet du cas précis, peut-être envisager de mettre à jour cette réponse contiendra-t-elle aussi la nouvelle syntaxe de membre de corps d'expression? –

+0

@ LasseV.Karlsen: Bien sûr, va faire ... –

+0

Nice :) Juste venu ici parce que cette question a été utilisée comme une cible pour la fermeture en double donc pensé que ce serait bien d'avoir 1 réponse au lieu d'aller à la chasse pour un autre un dans ces autres cas :) –

2

Au lieu d'utiliser la méthode anonyme comme ceci:

somevar.Find(delegate(int n) 
{ 
    if(n < 10) 
     return n; 
}); 

vous écrivez comme simplement ceci:

somevar.Find(n => n < 10); 

Il prendra le type de données en fonction de la valeur de retour.

0

Cela signifie essentiellement « va dans », comme un paramètre

MyObjectReference => MyObjectReference.DoSomething() 

Habituellement, vous les utiliser pour passer des fonctions dans les méthodes comme paramètres, ou dans les états LINQ

MyCollection.Where(myobj => myobj.Age>10) 

Par exemple.

14

Cela signifie génialité. Par exemple

x => x + 1 

représente une méthode qui prend x comme paramètre et renvoie le successeur de celui-ci.

button.Click += new EventHandler((sender, e) => methodInfo.Invoke(null, new object[] { sender, e })); 

affecte un gestionnaire d'événements à un bouton en invoquant une méthode qu'un MethodInfo contient.

7

est ici un exemple simple de msdn

delegate int del(int i); 
del myDelegate = x => x * x; 
int j = myDelegate(5); //j = 25 

Tout avant => sont les paramètres d'entrée, et tout ce qui est après l'expression. Vous pouvez avoir plusieurs paramètres d'entrée. Les Lambdas sont principalement utilisés avec Linq.

0

Cela fait partie de la syntaxe d'une expression lambda. Une expression lambda est essentiellement une forme abrégée d'un délégué ou d'une méthode anonyme. Pour illustrer, supposons que j'ai un tableau de chaînes correspondant aux lettres de l'alphabet. Je pourrais choisir les membres de ce tableau qui contenaient des valeurs supérieures à "E" avec l'expression LINQ suivante:

var someLetters = alphabet.Where (l => l> "E"); La partie de l'expression lambda à gauche du "=>" identifie le nom de la variable pour le test (qui est défini sur les membres individuels de l'alphabet) et la partie de l'expression lambda à la droite du "". => "identifie le traitement. Dans ce cas, le traitement génère une valeur booléenne que la logique Where utilise pour déterminer si chaque membre de l'alphabet est transmis au tableau someLetters.

7

C'est une autre forme de notation de fonction. Les éléments suivants sont à peu près équivalents:

// explicit function 
int MyFunc(int pParam) 
{ 
    return pParam; 
} 

// delegate function 
Func<int, int> MyFunc = delegate(int pParam) { return pParam; }; 

// lambda expression 
Func<int, int> MyFunc = x => x; 

Pensez une expression lambda en disant: « donné quelque chose, retourner quelque chose ». Dans l'exemple ci-dessus, la fonction x => x indique «donné x, return x». (Bien que les expressions lambda n'aient pas nécessairement besoin de retourner quelque chose, vous pouvez les lire comme "donné x, faire quelque chose avec x".)