Discussion :

[0xYg3n3]

J'ai une ArrayList contenant divers objets de différents type (Class1, Class2,..., ClassN)
avec un traitement spécifique pour chacun d'entre eux.

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
ArrayList list = new ArrayList();
 
list.Add(new Class1(argument1, argument2));
list.Add(new Class2(argument1, argument2));
list.Add(new ClassN(argument1, argument2));
 
foreach (object monObject in list)
{
    if (monObject is Class1)
    {
        // Traitement pour un objet de type Class1
    }
    if (monObject is Class2)
    {
        // Traitement pour un objet de type Class2
    }
    if (monObject is ClassN)
    {
        // Traitement pour un objet de type ClassN
    }
}

J'aimerais trouvé un moyen un peu plus astucieux que le bout de code qui suit

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
if (monObject is Class1)
{
    // Traitement pour un objet de type Class1
}
if (monObject is Class2)
{
    // Traitement pour un objet de type Class2
}
if (monObject is ClassN)
{
    // Traitement pour un objet de type ClassN
}

[The_badger_man]

Pourquoi tu n'utilise pas les listes génériques avec une liste par type d'objet ?

[0xYg3n3]

Parce qu'il faut gérer une liste par type d'objets.
L'avantage d'une ArrayList est de gérer qu'une seule liste.

Le seul problème réside dans le type d'objets se trouvant dans la liste.
Quoique ta solution reste très interessante.

[djo.mos]

Une solution possible mais pas toujours applicable serait de dériver tes classes Class1..ClassN d'une seule classe Mere et d'utiliser le polymorphisme.
exemple:

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
 
class Mere {
  public virtual void Exec(params) {}
}
 
class Class1: Mere {
  public override void Exec(params) {
    //traitement pour la classe Class1
  }
}
 
:
:
:
 
class ClassN: Mere {
  public override void Exec(params) {
    //traitement pour la classe ClassN
  }
}
 
ArrayList list = new ArrayList();
Mere m = new Class1();
list.Add(m);
m = new Class2();
list.Add(m);
m = new ClassN();
list.Add(m);
 
foreach(Mere mere in list){
  mere.Exec(params);
}

Ainsi, tu te débarrasses du pas élégant

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
if (monObject is Class1)
    {
        // Traitement pour un objet de type Class1
    }
    if (monObject is Class2)
    {
        // Traitement pour un objet de type Class2
    }
    if (monObject is ClassN)
    {
        // Traitement pour un objet de type ClassN
    }

tout en gardant le même fonctionnement.

Mais comme je l'ai déja dit, il faut que tu concois tes classes de sorte qu'elles puissent être dérivées d'une classe mère qui contient l'interface de tout le traitement (ici la méthode Exec()).

[0xYg3n3]

Toutes mes classes Class1, ClassN dérivent d'une interface qui contient le prototype d'une unique méthode

Code :

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

public bool Check(object value)

Cependant la class1 ne sait que checker un entier avec un entier.
La class2 ne sait que checker une string avec une string...

Pour donner plus de détails, je développe un composant listant les fichiers d'un disque durs.
On peut fixer des règles pour ne récupérer que des fichiers souahités.

Exemple de règle:
- taille du fichier
- extension du fichier

Admettons que class1 check la taille du fichier et class2 check l'extension du fichier.
Le paramètre donné à la méthode check de chacune de ces 2 classes est forcément différent.

C'est pourquoi la solution de savoir de quel type est l'objet contenu dans la liste me semble être la bonne.
Du moins tant que les règles ne sont pas trop nombreuses (au delà de 5 règles ça devient illisible).

Et peux être sujettis a de nombreux check (c#) fais lors de l'executions.

[djo.mos]

C'est déja ça de gagné !
Cependant, je ne saisis pas ta dernière remarque !
Peux tu expliquer STP ?