Polymorphism - Delegates & Events

Version imprimable

13/06/2008, 17h01
ragnarokr

Polymorphism - Delegates & Events

Bonjour à tous,

Mon problème est assez simple: j'aurais aimé avoir des exemples très simples sur le polymorphisme et sur les delegates et evenements.
Je n'en ai pas besoin dans l'instant mais ça me trotte dans la tête, j'aimerais vraiment comprendre.

J'ai fais quelque recherches mais les exemples ne m'ont pas permis de comprendre... :oops:

Je fais principalement du C# en ce moment.

Merci
13/06/2008, 17h26
tomlev

http://msdn.microsoft.com/fr-fr/libr...52(VS.80).aspx
http://msdn.microsoft.com/fr-fr/libr...71(VS.80).aspx
http://msdn.microsoft.com/fr-fr/libr...fh(VS.80).aspx
16/06/2008, 15h10
ragnarokr

Merci Tomlev
J'étais déjà allé faire un tour sur msdn mais, pour être franc, je ne suis pas très fan des exemples msdn.
Pour le polymorphisme, l'exemple n'est pas explicite et pour les delegate/event, il n'y en a même pas... :(

Disons, que si quelqu'un a un exemple très simple qui trainerait parmi ses projets ou qu'il connait un très bon lien, je suis preneur :)

Je comprend vite qd on m'explique longtemps... :oops:

En gros, le polymorphisme est le mécanisme grâce auquel une méthode sera appelée selon le type de l'objet.

Prenons un exemple :
Cas 1 : méthode non-polymorphe
- la classe A définit une méthode non-virtuelle HelloWorld1 :
Code:

1 2 3 4 5 6 7 public class A { public void HelloWorld1() { Console.WriteLine("Hello World 1 from A"); } }
- la classe B hérite de A et redéfinit HelloWorld :
Code:

1 2 3 4 5 6 7 public class B : A { public new void HelloWorld1() { Console.WriteLine("Hello World 1 from B"); } }
Si tu déclares une variable de type A et que tu appelles HelloWorld1, c'est toujours la méthode de A qui sera appelée quel que soit le type réel de l'objet instancié. Pour appeler la méthode HelloWorld1 de B, il faut forcément passer par une variable de type B :
Code:

1 2 3 4 5 6 7 A x = new A(); x.HelloWorld1(); // affiche "Hello World 1 from A" x = new B(); x.HelloWorld1(); // affiche aussi "Hello World 1 from A" B y = new B(); y.HelloWorld1(); // affiche "Hello World 1 from B"
Cas 2: méthode polymorphe
- la classe A définit une méthode virtuelle HelloWorld2 :
Code:

1 2 3 4 5 6 7 public class A { public virtual void HelloWorld2() { Console.WriteLine("Hello World 2 from A"); } }
- la classe B hérite de A et redéfinit HelloWorld2 :
Code:

1 2 3 4 5 6 7 public class B : A { public override void HelloWorld2() { Console.WriteLine("Hello World 2 from B"); } }
Si tu déclares une variable de type A et que tu appelles HelloWorld2, c'est la méthode de A ou de B qui sera appelée selon le type réel de l'objet instancié. :
Code:

1 2 3 4 5 6 7 A x = new A(); x.HelloWorld2(); // affiche "Hello World 2 from A" x = new B(); x.HelloWorld2(); // affiche "Hello World 2 from B" B y = new B(); y.HelloWorld2(); // affiche "Hello World 2 from B"
J'espère que c'est à peu près clair, dis moi si tu ne comprends pas

Pour les delegates, un exemple simple :

Déclaration du delegate :

Code:

public delegate double Operation(double x, double y);

Utilisation:

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
 
public double Calcul(double x, double y, char operateur)
{
    Operation op;
    switch(operateur)
    {
        case '+':
            op = Addition;
            break;
        case '-':
            op = Soustraction;
            break;
        case '*':
            op = Multiplication;
            break;
        case '/':
            op = Division;
            break;
        default:
            op = null;
            break;
    }
 
    if (op != null)
        return op(x, y);
    else
        return 0;
}
 
public double Addition(double x, double y)
{
    return x + y;
}
 
public double Soustraction(double x, double y)
{
    return x - y;
}
 
public double Multiplication(double x, double y)
{
    return x * y;
}
 
public double Division(double x, double y)
{
    return x / y;
}

Les events, c'est le même principe, sauf que tu peux assigner plusieurs méthodes au délégué :

Code:

1
2
button1.Click += button1_Click;
button1.Click += button1_Click2;

Les méthodes button1_Click et button1_Click2 seront toutes les 2 appelées quand l'évènement sera déclenché.

16/06/2008, 16h29
ragnarokr

Parfait tes exemples, c'est exactement ce que je cherchais :D
- Vraiment pratique les delegates.
- Le polymorphisme, je m'étais compliqué les choses. Par contre, je n'arrive pas réellement à voir dans quelle situation ça peut servir. Je n'arrive pas à m'imaginer un cas concret :?
16/06/2008, 16h38
tomlev
Citation:

Envoyé par ragnarokr

- Le polymorphisme, je m'étais compliqué les choses. Par contre, je n'arrive pas réellement à voir dans quelle situation ça peut servir. Je n'arrive pas à m'imaginer un cas concret :?

Ca sert tout le temps ! sans le polymorphisme, la programmation objet perd tout son sens...
Par exemple, prenons un exemple concret : la méthode OnPaint de la classe Control, qui dessine le contrôle. Elle est virtuelle, et redéfinie dans chacune des classes héritées de Control (Button, TextBox, etc...). Avec le polymorphisme, pas besoin de connaître le type réel du contrôle pour appeler la bonne "version" de OnPaint: il suffit de l'appeler sur une variable de type Control, c'est la bonne qui sera appelée automatiquement selon le type de contrôle

En gros, plutôt que de faire :
Code:

1 2 3 4 5 6 7 8 foreach (Control ctl in this.Controls) { if (ctl is Button) ((Button)ctl).OnPaint(e); else if (ctl is TextBox) ((TextBox)ctl).OnPaint(e); else if .... }
(en testant tous les contrôles possibles, si bien que ce code doit être modifié si de nouveaux types de contrôle sont créés)

Il suffit de faire :
Code:

1 2 3 4 foreach (Control ctl in this.Controls) { ctl.OnPaint(e); }
Ici, peut importe le nombre de types de contrôle existant, ou si on en crée des nouveaux : ça marchera aussi bien pour les nouveaux

(évidemment mon exemple de code est très théorique, ça n'est sans doute pas vraiment comme ça que l'affichage des contrôles est géré, mais ça utilise le même principe)