Syntaxe:
- Expression lambda : (paramètres) => expression
- Déclaration Lambda : { instruction conditionnelle1 instruction2 … }
Exemple 1:
Créez la liste des 'engrais' qui contient cinq chaînes. Utilisez l'expression lambda qui renvoie toutes les chaînes de la liste.
en utilisant Système ;en utilisant System.Linq ;
en utilisant System.Collections.GenericSystem.Collections.Generic ;
classe LambdaExpressionExample {
statique public annuler Principal ( )
{
// Créer une liste d'engrais
Liste des engrais = nouveau Liste ( ) ;
les engrais . Ajouter ( 'Urée' ) ;
les engrais . Ajouter ( 'azote' ) ;
les engrais . Ajouter ( 'potassium' ) ;
les engrais . Ajouter ( 'Phosphate di-ammonique' ) ;
les engrais . Ajouter ( 'phosphore' ) ;
// Utilisez LambdaExpression pour sélectionner tous les engrais
était résultat = les engrais . Sélectionner ( entrée1 => entrée1 ) ;
pour chaque ( était je dans résultat )
{
Console . WriteLine ( je ) ;
}
}
}
Sortir:
Explication:
1. Créez une liste de types de chaînes nommés 'engrais'. Ajoutez cinq chaînes à cette liste.
2. Utilisez l'expression lambda pour sélectionner tous les engrais. Ici, l'expression est utilisée avec l'opérateur 'Select'. L'expression est entrée1 => entrée1. Ensuite, nous utilisons la boucle 'foreach' pour afficher les chaînes renvoyées par l'expression lambda.
Exemple 2 :
Utilisez l'expression lambda pour sélectionner les engrais qui incluent 'Phosphate'.
en utilisant Système ;en utilisant System.Linq ;
en utilisant System.Collections.GenericSystem.Collections.Generic ;
classe LambdaExpressionExample {
statique public annuler Principal ( )
{
// Créer une liste d'engrais
Liste des engrais = nouveau Liste ( ) ;
les engrais . Ajouter ( 'Urée' ) ;
les engrais . Ajouter ( 'azote' ) ;
les engrais . Ajouter ( 'ortho - Phosphate' ) ;
les engrais . Ajouter ( 'Phosphate di-ammonique' ) ;
les engrais . Ajouter ( 'phosphore' ) ;
// Utilisez LambdaExpression pour sélectionner les engrais qui incluent - 'Phosphate'
était résultat = les engrais . Où ( entrée1 => entrée1 . Contient ( 'Phosphate' ) ) ;
pour chaque ( était je dans résultat )
{
Console . WriteLine ( je ) ;
}
}
}
Sortir:
Il y a deux chaînes qui incluent 'Phosphate' en eux.
Explication:
1. Créez une liste de types de chaînes nommés 'engrais'. Ajoutez cinq chaînes à cette liste.
2. Ici, l'expression est utilisée avec l'opérateur 'Où'. L'expression est inp1 => inp1.Contains(“Phosphate”). Ensuite, nous utilisons la boucle 'foreach' pour afficher les chaînes renvoyées par l'expression lambda.
Exemple 3 :
Prenons une liste (order_quantity) contenant trois commandes. Spécifiez l'expression lambda pour ajouter 5 à chaque commande.
en utilisant Système ;en utilisant System.Linq ;
en utilisant System.Collections.GenericSystem.Collections.Generic ;
classe LambdaExpressionExample {
statique public annuler Principal ( )
{
// Créer une liste de quantités
Liste order_quantity = nouveau Liste ( ) ;
quantité_commande . Ajouter ( 5 ) ;
quantité_commande . Ajouter ( 7 ) ;
quantité_commande . Ajouter ( 8 ) ;
// Utilisez LambdaExpression à 5 pour chaque commande.
était résultat = quantité_commande . Sélectionner ( entrée1 => entrée1 + 5 ) ;
pour chaque ( était je dans résultat )
{
Console . WriteLine ( je ) ;
}
}
}
Sortir:
La liste [5,7,8] est transformée en [10,12,13].
Explication:
1. Créez la liste des grandeurs de type Entier.
2. Nous sélectionnons d'abord les commandes, puis ajoutons 5 à chaque commande. Ainsi, l'opérateur 'Sélectionner' est utilisé. L'expression est entrée1 => entrée1 + 5.
Exemple 4 :
Créez une source de données de liste de type Event (avec trois attributs - Event_Name, Event_Status et Event_Budget) et renvoyez les enregistrements avec Event_Budget supérieur à 5000.
en utilisant Système ;en utilisant System.Linq ;
en utilisant System.Collections.GenericSystem.Collections.Generic ;
// Crée une classe nommée - 'Event_Source' avec 5 événements.
public classe Source_événement
{
public statique annuler Principal ( )
{
// Liste des événements
Événements IList = nouveau Liste ( ) {
nouveau Événement ( ) { Nom de l'événement = 'Camp technique' ,Event_Status = 'Prévu' ,Event_Budget = 10000 } ,
nouveau Événement ( ) { Nom de l'événement = 'Camp marketing' ,Event_Status = 'Complété' ,Event_Budget = 5000 } ,
nouveau Événement ( ) { Nom de l'événement = 'Autre' ,Event_Status = 'Prévu' ,Event_Budget = 1000 } ,
nouveau Événement ( ) { Nom de l'événement = 'Politique' ,Event_Status = 'Prévu' ,Event_Budget = 13000 } ,
nouveau Événement ( ) { Nom de l'événement = 'Finance' ,Event_Status = 'Complété' ,Event_Budget = 20000 } ,
} ;
//Event_Budget supérieur à 5000.
était résultat = événements . Où ( entrée1 => entrée1 . Event_Budget > 5000 ) ;
pour chaque ( était je dans résultat ) {
Console . WriteLine ( 'NOM: ' + je . Nom de l'événement + ' STATUT: ' + je . Statut_événement + ' BUDGET: ' + je . Event_Budget ) ;
}
}
}
public classe Événement {
public chaîne Nom de l'événement { obtenir ; ensemble ; }
public chaîne Statut_événement { obtenir ; ensemble ; }
public entier Event_Budget { obtenir ; ensemble ; }
}
Sortir:
Il y a trois enregistrements dans la liste 'événements' avec Event_Budget supérieur à 5000.
Explication:
1. Tout d'abord, nous créons une classe 'Event' avec trois attributs.
2. Ensuite, nous créons une liste de cinq événements.
3. Utilisation du inp1 => inp1.Event_Budget > 5000 expression lambda, nous sélectionnons les enregistrements avec Event_Budget supérieur à 5000.
Exemple 5 :
Utilisez le code précédent et modifiez l'expression lambda. Renvoie les événements avec le Event_Name qui se termine par 'Camp' et avec le Event_Status qui est 'Planifié'.
//Expression Lambda - Event_Name se termine par 'Camp' et Event_Status est 'Planifié'.était résultat = événements . Où ( entrée1 => entrée1 . Nom de l'événement . Se termine par ( 'Camp' ) && entrée1 . Statut_événement == 'Prévu' ) ;
pour chaque ( était je dans résultat ) {
Console . WriteLine ( 'NOM: ' + je . Nom de l'événement + ' STATUT: ' + je . Statut_événement + ' BUDGET: ' + je . Event_Budget ) ;
}
Sortir:
Il n'y a qu'un seul enregistrement qui satisfait aux deux conditions.
Explication:
Ici, nous spécifions deux conditions dans l'expression lambda. L'opérateur && (et) est utilisé pour rendre les deux conditions vraies. La première condition utilise la méthode EndsWith() pour vérifier si une chaîne se termine par la chaîne donnée. La deuxième condition utilise l'opérateur 'Comparaison' (==) pour vérifier si les deux valeurs sont égales ou non.
Conclusion
En C #, l'expression lambda prend les expressions/instructions conditionnelles comme son corps sans nom. Nous devons spécifier les paramètres. Ensuite, les expressions lui sont affectées. Fondamentalement, ceux-ci sont utilisés pour filtrer les enregistrements de la source de données donnée, transformer les éléments et sélectionner les éléments de la source/séquence de données. Dans ce guide, nous avons abordé les cinq exemples différents qui sélectionnent, filtrent et transforment les éléments à l'aide de l'expression lambda.