Discussion :

[Baquardie]

Bonjour,

Je suis nouvelle en programmation C#. Je suis actuellement en train de suivre une formation de C# 2.0 sur la plate forme VS2005. J'ai deux sessions de suivie et il m'en reste une.

Lors de la dernière session nous avons appris les itérateurs. Arrivé au boulot j'essaie de mettre en pratique ce concept mais je n'y arrive pas parce que je ne comprend pas toutes ces histoires de IEnumerable et GetEnumerator etc.

Alors voilà, je vous place en contexte.

J'ai une classe qui s'appelle Produit

J'ai une classe qui s'appelle Donnéesqui elle s'occupe d'instancier la classe produit, de lire la database et de remplir une liste de produit.

Puis, dans mon WinForms, j'instancie une variable de Données.

Ce que j'ai besoin de faire, c'est de lire les produits qui répondent à un certain critère - disons dans notre cas, qu'il soit actif. Donc, j'ai besoin de Produit.Actif = True.

J'ai vu dans ma formation que lorsque les itérateurs sont bien implémentés, on peut faire un foreach sur notre objet afin de rechercher les instances qui répondent à notre critère.

Alors voilà ce que j'ai fait jusqu'à date :

Déclaration de ma classe Données :

Code :

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

public class Donnees : IEnumerable<CLS>

Puis je déclare une liste de produits :

Code :

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

private static List<Produit> _produit = new List<Produit>();

Puis dans ma classe Donnees je déclare ceci :

Code :

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
public IEnumerator<CLS> GetEnumerator()
        {
            return _produit.GetEnumerator();
        }
 
        IEnumerator IEnumerable.GetEnumerator()
        {
            return GetEnumerator();
        }
 
        public IEnumerable<Produit> ProduitActif()
        {
            foreach (Produit p in _produit)
                if (p.Actif == true)
                    yield return p;
 
        }

Dans mon winforms, je code comme cela :

Code :

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

1
2
3
4
5
6
Donnees _donnees = new Donnees()
foreach (Donnees i in _donnees)
{
//Ajout des données dans le combobox
cbProduit.Items.Add(i.ClientCLS[?].Code);
}

Je ne comprend pas comment faire l'appel correctement dans mon winforms. Je dois passer un indice, alors qu'avec mon foreach je n'ai pas cet indice... ???

Merci pour l'aide apporté!

[StormimOn]

Ce n'est peut être pas la réponse que tu attendais, mais suivant ce dont tu as besoin, les prédicats peuvent peut être te suffir. Un exemple

Code :

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

1
2
3
4
5
6
List<bool> l1 = new List<bool>();
l1.Add(true);
l1.Add(false);
 
List<bool> l2 = l1.FindAll(delegate(bool b) { return b; });
List<bool> l3 = l1.FindAll(delegate(bool b) { return !b; });

l2 contient uniquement les booléens à true et l3 ceux à false. On utilise en fait une méthode anonyme comme prédicat, le prédicat doit renvoyer true si l'élément est à prendre en compte, false sinon.

Pas toujours besoin de faire un itérateur donc, à moins que cela apporte quelque chose de plus par rapport aux prédicats. Je n'ai jamais eu à mettre en place d'itérateur jusqu'à présent, mais cela dépend de ce qu'on développe de toute façon ^^

L'inconvénient, c'est que l'on a plusieurs listes, celle contenant tous les éléments et celles filtrées. Suivant la taille des listes ce n'est peut être pas génial.

Cet aparté fait, ClientCLS correspond à quoi dans le code ? Si c'est une collection, et ca y ressemble, tu dois également la parcourir, avec un foreach imbriqué par exemple.

Par contre il manque du code ou j'ai du mal à comprendre. Tu définis un itérateur par défaut sur les produits qui te renvoie un objet de type CLS.

Code :

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

1
2
3
4
public IEnumerator<CLS> GetEnumerator()
{
    return _produit.GetEnumerator();
}

_produit.GetEnumerator(); renvoie un IEnumerator<Produit>, ce qui est normal puisque derrière on a une List<Produit>. Mais ce n'est pas ce que retourne la méthode. Produit dérive de CLS ? Et même si c'était le cas, je doute que cela passe à la compilation sans cast à ce moment.

Ensuite, dans le foreach tu devrais boucler sur des objets de type CLS, hors tu boucles sur des objets de type Donnees

Code :

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

1
2
3
4
5
foreach (Donnees i in _donnees)
{
    //Ajout des données dans le combobox
    cbProduit.Items.Add(i.ClientCLS[?].Code);
}

Soit j'ai pas pigé le principe des itérateurs, j'ai un doute quand même, soit il manque quelque chose pour la compréhension de l'ensemble

En oubliant le ClientCLS, voici en gros ce que tu veux je pense

Code :

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
public class Produit
{
    private bool _actif;
 
    public bool Actif
    {
        get { return _actif; }
    }
 
    public Produit(bool actif)
    {
        _actif = actif;
    }
}
 
public class Donnees : IEnumerable<Produit>
{
    private List<Produit> _produits;
 
    public Donnees()
    {
        // Quelques données pour l'exemple
        _produits = new List<Produit>();
        _produits.Add(new Produit(true));
        _produits.Add(new Produit(false));
    }
 
    public IEnumerator<Produit> GetEnumerator()
    {
        return _produits.GetEnumerator();
    }
 
    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }
 
    public IEnumerable<Produit> ProduitsActifs()
    {
        foreach (Produit p in _produits)
        {
            if (p.Actif) { yield return p; }
        }
    }
}

Et le parcours des produits actifs

Code :

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

1
2
3
4
Donnees d = new Donnees();
foreach (Produit p in d.ProduitsActifs())
{
}