Discussion :

[trihanhcie]

Bonjour,

J'aimerais avoir une classe / interface parent qui me permette de faire les choses suivantes :

Code :

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

1
2
3
4
5
6
7
 
Var class = new GenericClass<System1>()
List<Blablabla> result = class.Getsomething() // Returns a list of Blablabla as the method is defined in system1
 
 
Var class1 = new GenericClass<System2>()
List<Toto> result = class1.Getsomething() //Returns a list of Toto as the method is defined in system2;

J'espere avoir ete clair...

Merci !

[zhouyu]

Salut.
Si System1 et System2 ont les mêmes méthodes mais des implémentations différentes, soit tu fais une interface qui décrit les méthodes à implémenter, soi tu fais une classe parente abstraite pour tes classes System1 et System2.

Si tu as quelques méthodes identiques ( c'est à dire avec la même implémentation) je te conseille la classe abstraite qui te permet d'implémenter ces méthodes pour ne pas avoir à faire la même chose dans tes 2 classes.

Ex :

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
 
//avec une interface
public interface ISystem{
   void M1();
   void M2();
   int M3();
}
 
public class System1 : ISystem{
   //tes méhodes et donnéees...
   //l'implémentation de l'interface
   void M1() { ... };
   void M2() { ... };
   int M3() { ... };
}
 
//pareil pour System2

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
 
//avec une classe abstraite
public absctract class ASystem{
   void M1_commune() { .... };//tu ecris deja ta methode commune dans la classe
   abstract void M2();
   abstract int M3();
}
 
public class System1 : ASystem{
   //tes méhodes et donnéees...
   //l'implémentation des methodes abstraites
   // M1 deja defini dans ta classe mère
   void M2() { ... };
   int M3() { ... };
}

Tu dois appliquer ce meme principe si tu veux des retour de fonction different pour une meme methode.

tu as une classe mère A.
B herite de A.
C herite de A.

dans System 1 :
public A myMethod() { return new B(); }
dans System 2 :
public A myMethod() { return new C(); }

Tu as des retour différent mais grasse au polymorphisme tu peux utiliser la meme méthode.

Pour ta liste tu met un retour de type List<A> mais tu peux renvoyer List<B> ou List<C> par exemple.

J'espère avoir été clair :p .

[trihanhcie]

Je pense que cela correspond pas tout a fait a ce que je cherche a faire.

mmm je pense que c pas tres clair en fait ou j ai mal compris...
En fait je voudrais appeler de A ( la classe mere) les methodes de B ou C.
Pq? Parce que "fonctionnellement", les methodes que je vais definir dans B ou C vont implementer une meme fonctionnalite comme GetUsers() mais le getusers dans B va par exemple appeler un webservice tandis que le GetUsers() dans C
va se connecter a une base de donnees, etc etc.

C est pour cela que j'aurai voulu une classe generique (ici A) qui me permette de faire qq chose comme A<B>.GetUsers() => retourne l implementation de GetUsers de B. A<C>.GetUsers() => retourne l implementation de C de GetUsers.

Je pense que je vais de voir rajouter un parametre genre un string pour savoir quelle classe enfant je vais implementer...

[zhouyu]

Tu vas te compliquer à faire une classe générique alors que l'héritage suffit
C'est ce que je t'ai expliqué un peu maladroitement apparemment ^^.

Je reprend ton exemple avec la méthode getUsers().

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
 
//interface
//elle va définir els méthodes que tes classes doivent implémenter
//peu importe comment tant qu'on peu utiliser ces méthodes
//ici l'interface représenterai ta classe A, commune à B et C ;)
public interface MonInterface{
   Users getUsers();
}
 
//tes classes B et C
 
public class ClasseB : monInterface
{
 
   //tes méthodes etc...
   //l'implémentation de l'interface
   public Users getUsers()
   {
      //tu écris ta méthode comme bon te semble
   }
}
 
public class ClasseC : monInterface
{
   //Comme pour B
   //tes méthodes etc...
   //l'implémentation de l'interface
   public Users getUsers()
   {
      //tu écris ta méthode comme bon te semble
   }
}

Tes 2 classes auront une implémentation différente de getUsers() mais tu pourras faire une liste de MonInterface et lui ajouter des variables de type ClasseB et ClasseC puisque ces 2 classes implémentent l'interface MonInterface.
Ex :

Code :

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

1
2
3
4
5
6
7
8
 
List<MonInterface> list = new List<MonInterface>();
list.add(new ClasseB());
list.add(new ClasseC());
foreach(MonInterface i in list)
{
   i.getUsers();//puisque les membres de la liste implémentent MonInterface, ils ont tous la méthode getUsers()
}

J'espère avoir été plus clair, en tout cas les classes génériques ne sont pas à utiliser ici ça va te compliquer le code plus qu'autre chose.

[trihanhcie]

ca y est ca commence a faire tilt...
mais c est encore le matin ici
Alors je vais peut etre poser mon probleme autrement.

Suppose que tu as un webservice WCF (c'est le plus simple )

Imagine que l'utilisateur va choisir un systeme qui va lui permettre de recuperer tous les utilisateurs de ce systeme uniquement.
Suppose maintenant que le nombre de systemes est amene a evoluer a savoir qu'il pourrait tres bien y a voir un jour 100 systemes.

D'ou l'idee que j avais d avoir une classe qui englobe chacun des systemes et qui les appelle... peut etre est-ce une mauvaise idee?
Je voulais eviter de faire qq chose dans le genre

Code :

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

1
2
3
4
5
6
7
8
9
if (system == system1)
{
 //appel du getuser de la classe system1
}
if (system == system2)
{
 
 //appel du getuser de la classe system2
}

mais plutot quelque chose comme

IInterface.GetUser(system)

et ensuite du cote service, a partir du system (qu il soit un string, id peu importe pour le moment), je sois capable de creer une instance du dit systeme et de retourner le getuser implemente par le systeme choisi...

Desole je pense que j'ai tres mal explique mon probleme au depart...

PS : Je suis sur un clavier anglais, un peu complique d utiliser les accents

[chrisdot]

J'a pas tout compris en détail, mais connais-tu les patterns fabriques de classe et fabriques de classe abstraites?
Je pense que ça pourrait coller, ou tout au moins t'inspirer...

[giova_fr]

il pourrait tres bien y a voir un jour 100 systemes

Bienvenue dans le monde merveilleux des design paterns
Si tu veux que ton code puisse évluer dans le bon sens tu dois :

1)faire de l'inversion de dépendance avec une interface comme zhouyu te l'expliquait.

Tu met l'interface dans une assembly (disons interface.dll)
Et tu mets tes classes A B C D chacune dans une autre assembly a.dll b.dll c.dll

interface.dll ne changera jamais



2)faire une factory qui selon le systeme choisi, ira chercher la bonne dll pour construire un IInterface

Tu pourra apres, sans toucher une seule ligne de code dans ton logiciel, rajouter d'autres systeme.

[trihanhcie]

ah voila c est deja plus ce que je cherchais le factory pattern
je me souvenais plus du nom exact... Je pense que ca correspond a ce que je cherche !
Merci a tous, je laisse ouvert le post en cas de probleme.

[trihanhcie]

Hello,

Je reviens un peu sur le probleme...
Apres lecture plus attentive c'est en effet plutot l'injection de dependance que je cherche. la classe abstraite revient a ce que zhouyu a fait avec les classes abstraites dont pas exactement ce que je cherche. C est parti pour Unity!