Signification de =>

Version imprimable

09/06/2016, 20h36
Guillaume1701

Signification de =>

Bonjour à tous,

Je viens vers vous car il m'est impossible de trouver une réponse sur internet.
Je suis à la recherche de la signification de "=>" dans une ligne comme celle-ci :

Code:

args.Node.SampleReceived += (node, sample) => Console.WriteLine("Sample recieved: {0}", sample);

Je devine ce que fais cette ligne mais j'aimerai une explication du pourquoi du comment :).

Je vous remercie d'avance

Cordialement

C'est du Lambda.

C'est une manière de faire, sinon tu peux écrire le code dans une autre méthode et simplement mettre le nom de ta méthode après le +=.

Exemples :
Code:

1 2 3 4 button1.Click += new System.EventHandler(this.button1_Click); button1.Click += this.button1_Click; button1.Click += delegate (object sender, EventArgs e) { ... }; button1.Click += (object sender, EventArgs e) => { ... };

09/06/2016, 21h39
ericlm128

Un peu de lecture
https://msdn.microsoft.com/fr-fr/library/bb397687.aspx
09/06/2016, 22h42
Pol63

c'est plus une méthode anonyme qu'une lambda

les paramètres => le code de la méthode (ou fonction) qui peut utiliser les paramètres ou non, mais cette méthode n'a pas de nom et est défini dans le corps d'un membre
10/06/2016, 07h51
ericlm128
Tu es sur Pol63 ?

Citation:

Le fait de définir la méthode directement au niveau du paramètre d’appel est ce qu’on appelle « utiliser une méthode anonyme ». Anonyme car la méthode n’a pas de nom. Elle n’a de vie qu’à cet endroit-là.
La syntaxe est un peu particulière, mais au lieu d’utiliser une variable de type delegate qui pointe vers une méthode, c’est comme si on écrivait directement la méthode.

Méthode anonyme
Code:

1 2 3 4 DelegateTri tri = delegate(int[] leTableau) { Array.Sort(leTableau); };
Expression lambda
Code:

1 2 3 4 5 6 DelegateTri tri = (leTableau) => { Array.Sort(leTableau); };
https://msdn.microsoft.com/fr-fr/library/0yw3tz5k.aspx
10/06/2016, 08h22
Pol63

Citation:

Envoyé par ericlm128

Tu es sur Pol63 ?

non, je sais bien que tout le monde appelle ca une lambda
mais bon pour moi lamba expressions c'est plus ce qu'il y a ici : https://msdn.microsoft.com/fr-fr/lib...vs.110%29.aspx
plus complexe à écrire mais qui permet de faire du code plus dynamique et plus performant que la reflection

et à part la très légère différence de syntaxe dans tes 2 exemples (tirés de "bibles" certes) je ne vois pas de différence, et je ne vois pourquoi on donnerait 2 noms à 2 choses "identiques"
un volontaire pour nous sortir du code IL et dire que ca n'a rien à voir ? :D
10/06/2016, 08h55
worm83

Bonjour,

Je me permet de mettre mon grain de sel.

Alors en fait une lambda c'est juste le fait d'utiliser l'opérateur '=>'. Cet opérateur à une signification mathématique en réalité cela correspond a une fonction, par exemple la transcription de f(y) = 2x s'écrirais y=> 2*x en c#.
Une lambda est techniquement une méthode anonyme, et est transtypé en delegate typé, ainsi un code du type ()=> 2*6, est forcement une Func<int>.

Citation:

Envoyé par ericlm128

Un peu de lecture
https://msdn.microsoft.com/fr-fr/library/bb397687.aspx
10/06/2016, 11h46
Sehnsucht

Citation:

Envoyé par worm83

ainsi un code du type ()=> 2*6, est forcement une Func<int>

Euh ouais mais non ; lambda expression ou méthode anonyme ça n'a pas de type ; c'est d'ailleurs pour cela qu'on peut pas utiliser var dessus et laisser l'inférence faire; y'a rien qui empêche de stocker ça dans un type délégué perso.

Quant au sujet initial je recommande la lecture d'un (de plusieurs) article d'Eric Lippert qui même s'il date un peu reste toujours pertinent.
Partie1
Partie2
Partie3

Bonjour à tous,

Ma première réponse sur ce forum. J'espère qu'elle sera à la hauteur :) Aussi, je vais parler peu, coder bien :]

Attention à ne pas confondre une expression linq ou le bonus syntaxique que représente var et un délegate.
Deux petits exemples utilisant var dans les contextes précités:

Code:

1
2
3
4
5
6
7
8
 
// Linq:
var unAutreExemplePlusBas = (from p in People
                                         where p.Name.StartsWith("B")
                                         select p.Name).Distinct().ToList();
 
// bonus syntaxique, n'a pas réellement d'importance. écrire var ou le type concret:
var name = "Bill Gates"; // revient à écrire string name = "Bill Gates";

Et voici un programme complet que je vous invite à utiliser en mode débug pour bien comprendre le fonctionnement :)

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
 
using System;
using System.Collections.Generic;
using System.Linq;
 
namespace ConsoleApplication1
{
    class Program
    {
 
        static void Main(string[] args)
        {
            #region exemple 1
            List<People> people = new List<People>();
            people.Add(new People() { Name = "Alica Milano1" });
            people.Add(new People() { Name = "Bill Gates" });
            people.Add(new People() { Name = "Bill Clinton" });
            people.Add(new People() { Name = "Boule et Bill" });
            people.Add(new People() { Name = "Steve Jobs" });
 
            // Type People (c'est la même chose que faire: List<People> startByB = people.Where(n => n.Name.StartsWith("B")).ToList();
            var startByB = people.Where(n => n.Name.StartsWith("B")).ToList();
 
            foreach (var p in startByB)
                Console.WriteLine("{0}", p.Name);
 
            #endregion
 
            #region example 2
 
            // int fonctionne, mais pas var, double, float, etc.
            Multiply myInt;
            myInt = (x, y) => { return x * y; };
            Console.WriteLine("'Multiply' _doit_ retourner un entier (voir ligne 48). Le calcul est donc une multiplication: 3*2 = {0}", myInt(3, 2));
            // On peut également s'abonner à un délegate, mais l'exemple n'a pas lieu d'être re-re-revu ici :)
            #endregion
 
            Console.ReadLine();
 
 
        }
    }
 
    // Exemple 1
    class People
    {
        public string Name { get; set; }
    }
    // Exemple 2
    delegate int Multiply(int x, int y); // Doit retourner un int comme le ferait la fonction suivante: public int Multiply(int x, int y)
}

J'espère qu'avec ceci vous comprendrez mieux. N'hésitez pas à pratiquer encore et encore ;)

10/06/2016, 14h32
worm83

Citation:

Envoyé par Sehnsucht

Euh ouais mais non ; lambda expression ou méthode anonyme ça n'a pas de type ; c'est d'ailleurs pour cela qu'on peut pas utiliser var dessus et laisser l'inférence faire; y'a rien qui empêche de stocker ça dans un type délégué perso.

Quant au sujet initial je recommande la lecture d'un (de plusieurs) article d'Eric Lippert qui même s'il date un peu reste toujours pertinent.
Partie1
Partie2
Partie3

Oui, ok je me suis mal exprimé ,tu as totalement raison, les délégués, au niveau de la CLI, sont des types nominatifs et non structurels ce qui fait que par exemple Func<int, bool> ne peut être converti en Predicate<int> explicitement (pas de transtypage). Ce que je voulais dire c'est qu'une lambda de type ()=> 2*6 bien que méthode anonyme,peut être typé en Func<int>.

D'ailleurs si les développeur de la CLI pouvais faire passer les délégué en type structurel ce serais quand même une bonne chose.

Au temps pour moi.

Edit : Il me semblait d'ailleurs que Eric Lippert avait annoncé il y a quelques temps que cela devrais être une prochaine feature de .Net, mais c'est jamais venu :(