Discussion :

[ragnarokr]

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...

Je fais principalement du C# en ce moment.

Merci

[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

[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...

[tomlev]

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 C# :

Sélectionner tout - Visualiser dans une fenêtre à part

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 C# :

Sélectionner tout - Visualiser dans une fenêtre à part

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 C# :

Sélectionner tout - Visualiser dans une fenêtre à part

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 C# :

Sélectionner tout - Visualiser dans une fenêtre à part

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 C# :

Sélectionner tout - Visualiser dans une fenêtre à part

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 C# :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[tomlev]

Pour les delegates, un exemple simple :

Déclaration du delegate :

Code C# :

Sélectionner tout - Visualiser dans une fenêtre à part

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

Utilisation:

Code C# :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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é.

[ragnarokr]

Parfait tes exemples, c'est exactement ce que je cherchais
- 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

[tomlev]

- 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 C# :

Sélectionner tout - Visualiser dans une fenêtre à part

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 C# :

Sélectionner tout - Visualiser dans une fenêtre à part

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)