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 ?

[0xYg3n3]

Une expression is prend la valeur true si l'expression fournie n'est pas null, et que l'objet fourni peut être casté en type fourni sans entraîner la levée d'une exception.

En abusé ne doit pas être recommandé...

[djo.mos]

Je vois (j'ai posté avant ton edit).
Si tu comptes utiliser tes Classes uniquement sur des fichiers, alos tu peux te contenter du nom d'un fichier comme paramètre à Check() !
En tout cas, pour moi, c'est comme ça que j'aurais procédé, car proceder autrement serait contraire au paradigme POO ! j'explique :
En procedant comme tu le suggères, (passer la taille d'un fichier à Class1, son ext à Class2, etc.) tu t'accapares une partie de traitement qui aurait du être exécuté dans la Classe elle même !
Mais en passant uniquement le nom de fichier à toutes les Classes, déja, le traitement est simple et uniforme à l'extérieur, et c'est dans une implémentation particulière de Check() que l'on traite le nom pour calculer la taille ou extraire l'extension !) OH la la !
En C#, ça donne :

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
 
   Interface Critere {
    bool Check(string filename)
  }
 
  Class CritereTailleMax : Critere{
    private int tm = 0;
 
    public CritereTailleMax(int max){
      tm = max;
    }
 
    public bool Check(string filename){
       return (File.FileSize(filename) < tm);
    }
  }
 
  Class CritereExt : Critere{
    private string ext = "";
 
    public CritereExt(string ext){
      this.ext = ext;
    }
 
    public bool Check(string filename){
       return (Path.GetExtension(filename) == ext);
    }
  }
 
 ArrayList list = new ArrayList();
 Critere I = new CritereExt(".avi");
 list.Add(I);
 I = new CritereTailleMax(8000);
 list.Add(I);
 
 foreach(Critere c in list)
 {
    c.Check("d:\mo.djo");
 }

[0xYg3n3]

C'est très loin d'être aussi simple que cela.
Tant pis, je vais rester sur ma 1ère idée, même si il y a sûrement un moyen de faire beaucoup mieux.

Malheureusement on a pas le temps pour.
On est dans une logique de développement en masse, fiable et répondant à toutes les exigences des utilisateurs.

Merci quand même pour vos conseils

[Bluedeep]

C'est très loin d'être aussi simple que cela.
Tant pis, je vais rester sur ma 1ère idée, même si il y a sûrement un moyen de faire beaucoup mieux.

Malheureusement on a pas le temps pour.
On est dans une logique de développement en masse, fiable et répondant à toutes les exigences des utilisateurs.

Merci quand même pour vos conseils

Il y a plus simple.
Si la liste des classes que tu manipules est défini et que ce sont des classes auquels tu as accés, tu peux toujours implémenter dans chaque classe, ou dans une classe de base une interface suplémentaire avec une méthode renvoyant une valeur au sein d'un enum.

OU encore utiliser une classe de base avec un générique.

etc ....

[0xYg3n3]

Du coup j'ai implémenter une structure, comme je connais chacune des valeurs:
- nom fichier
- emplacement fichier
- extension fichier
- taille fichier
- read only ?
- etc

Par contre la méthode Check() de mes classes class1, class2, classN vérifie que le paramètre est bel et bien une structure.

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
struct FileInformation
{
    public ulong size;
    public string fileName;
    public string path;
    public string extension;
}
 
bool Class1.Check(object value)
{
    if (value is FileInformation)
    {
        FileInformation fi = (FileInformation)value;
        if (fi.size == this.size) { return true; }
    }
 
    return false;
}

En simplifiant au maximum le résultat est le suivant

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
ArrayList list = new ArrayList();
 
list.Add(new Class1(argument1, argument2));
list.Add(new Class2(argument1, argument2));
list.Add(new ClassN(argument1, argument2));
 
/***************************AILLEURS DANS LE CODE******************************/
 
foreach (IMonInterface monObject in list)
{
    FileInformation fileInformation = new FileInformation();
    // affectation des différents champs avec les différentes valeurs
 
    if (monObject.Check(fileInformation) == false) { return false; }  // Une règle n'est pas respectée, on sort
}

Bien sûr les bouts de code mlis sur ce forum schématise énormément.