bonne utilisation des interfaces

Version imprimable

bonjour,
j'essaie d'implémenter ma propre interface pour l'exemple suivant:
Je dois développer une classe qui va se connecter via diverses méthodes à un serveur, en FTP, web ou autre et y récupérer un fichier XML. J'aimerais créer une classe par type de connexion, toutes devraient implémenter la même interface.

voici mon début d'idée:
Code:

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 interface IHotFolder { int Status { get; set; } XmlDocument GetFile(); } class FTP : IHotFolder { public int Status { get; set; } public XmlDocument GetFile() { XmlDocument XMLDoc = new XmlDocument(); //Code à implémenter return XMLDoc; } } class WebConnection: IHotFolder { public int Status { get; set; } public XmlDocument GetFile() { XmlDocument XMLDoc = new XmlDocument(); //Code à implémenter return XMLDoc; } }
MA principale question est: comment utiliser pratiquement mon interface?
Mon but est que la classe qui va appeler ma connexion ne doit pas se préocuper du type de connexion, mais je ne vois pas comment faire, je me demande meme si une interface est justifiée pour mon exemple...

15/09/2009, 11h34
luunaz
Dans ta classe qui va appeler ta connexion tu crées une variable du type de l'interface que tu instancies avec la classe que tu souhaites.

Classe FTP:
Code:

1 2 IHotFolder hotFolder = new FTP(); XmlDocument xmlDoc = hotFolder.GetFile();
Classe WebConnection:
Code:

1 2 IHotFolder hotFolder = new WebConnection(); XmlDocument xmlDoc = hotFolder.GetFile();
Tu peux faire l'instanciation dans le constructeur de ta classe appelante ou créer une propriété que tu instancieras après la construction de ta classe appelante.
15/09/2009, 12h13
flo1981

ok, c'est bien ce que je pensais, mais ca ne semble pas répondre au besoin que j'aimerais implémenter.
En effet, le but serait que dans la classe appelante je n'aie pas besoin de préciser FTP ou WebConnection, j'aimerais pouvoir, utiliser un type de connexion ou l'autre, sans que la classe appelante se préoccupe de son implémentation.
L'idée est que dans un cas on utilise seulement la connection FTP et dans un autre cas seulement une connection Web. Un peu comme IDBConnection du framework, on peut utiliser un type de base de données ou l'autre..

Peut -être ne suis-je pas assez clair! lol :roll::roll:

en tout cas merci pour ton aide :ccool:

Je pense voir ce que tu veux dire. Dans ce cas là utiliser le même principe que les DbConnection, la factory.
Quelque chose de ce genre là:
Code:

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 Class MyHotFolderFactory { public static GetHotFolder(String method) { Switch (method) { case "Web": return new WebConnection(); break; case "FTP": return new FTP(); break; default: return new FTP(); break; } } } ****** IHotFolder hotFolder = MyHotFolderFactory.GetHotFolder("web"); XmlDocument xmlDoc = hotFolder.GetFile();
Ca ressemble un peu aux factory des DbConnection.

Par contre comment tu définies que dans un cas c'est du ftp et dans un autre c'est du web?

15/09/2009, 14h00
theMonz31

Salut

une factory te renvoie un objet qui correspond à ton interface, OK.

Mais cependant, il faut bien instancier un object Web ou FTP à un moment donné, donc, soit l'utilisateur est capable de fournir cette information à la factory, soit la factory est capable de dire quel objet il faut instancier. Et pour que la factory puisse dire celà, il te faut un "module décisionnel" qui te fasse celà... Soit la décision est manuelle et provient de l'utilisateur, soit elle vient d'un système qui regarde les communications disponibles, ou un profil utilisateur, ou autre élément lui permettant de choisir :)

Citation:
Envoyé par luunaz
Je pense voir ce que tu veux dire. Dans ce cas là utiliser le même principe que les DbConnection, la factory.
Quelque chose de ce genre là:
Code:

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 Class MyHotFolderFactory { public static GetHotFolder(String method) { Switch (method) { case "Web": return new WebConnection(); break; case "FTP": return new FTP(); break; default: return new FTP(); break; } } } ****** IHotFolder hotFolder = MyHotFolderFactory.GetHotFolder("web"); XmlDocument xmlDoc = hotFolder.GetFile();
Ca ressemble un peu aux factory des DbConnection.

Par contre comment tu définies que dans un cas c'est du ftp et dans un autre c'est du web?
C'est tout à fait mon idée!
en fait, le type de connexion devrait pouvoir être determiné dans un fichier de config, idéalement.

donc, en fait, entre ma classe qui va utiliser l'une des connexion, web ou ftp et l'interface, je place cette classe factory?

c'est ça ton idée?

en tout cas, merci pour la rapidité et le contenu de tes infos!
:D

15/09/2009, 14h16
Mehdi_ab

Bonjour,

Au faite le principe que tu veux utiliser s'appele IOC (injection des dépendance), t'as pas mal de framework qui peuvent te décharger du travail (swich,instanciation...) a citer par exemple : le framework Spring ou le policy injection block de l'entreprise library (personnellement je l'ai utilisé et ça marche bien !!)

t'as aussi le pattern ServiceLocator,bon c'est un peu le même principe de la factory mais à voir aussi

Code:

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
Class ClassX
{
IHotFolder hotFolder =  MyHotFolderFactory.GetHotFolder();
XmlDocument xmlDoc = hotFolder.GetFile();
}
 
Class MyHotFolderFactory
{
  public static GetHotFolder()
  {
    Switch (ConfigManager.GetConfig("ConnexionMode"))//Ici tu récupères l'information sur le mode de connexion que tu veux utiliser dans l'application
    {
      case "Web":
      return new WebConnection();
      break;
 
      case "FTP":
      return new FTP();
      break;
 
      default:
      return new FTP();
      break;
    }
  }
}

Avec ça quand tu utilises ta classe ClassX, ta connexion sera configurée et instanciée avec ce que tu as définis dans ton fichier de configuration.

15/09/2009, 14h23
Philippe Vialatte

Bon, coup de pub :http://philippe.developpez.com/artic...dedependances/

La plupart des conteneurs peuvent gérer ca en natif
15/09/2009, 14h28
Mehdi_ab

Ah oui c'est vrai, voila un excellent article de Mr Philippe (un autre coup de pub :p)

Citation:
Envoyé par luunaz
Code:

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 Class ClassX { IHotFolder hotFolder = MyHotFolderFactory.GetHotFolder(); XmlDocument xmlDoc = hotFolder.GetFile(); } Class MyHotFolderFactory { public static GetHotFolder() { Switch (ConfigManager.GetConfig("ConnexionMode"))//Ici tu récupères l'information sur le mode de connexion que tu veux utiliser dans l'application { case "Web": return new WebConnection(); break; case "FTP": return new FTP(); break; default: return new FTP(); break; } } }
Avec ça quand tu utilises ta classe ClassX, ta connexion sera configurée et instanciée avec ce que tu as définis dans ton fichier de configuration.
Super ce forum, je pose ma question le matin, et l'après-midi c'est résolu!
merci beaucoup!
Je tacherais de poser mon code une fois que j'ai terminé :ccool:

15/09/2009, 16h10
Maniak

Citation:

Envoyé par Mehdi_ab

Au faite le principe que tu veux utiliser s'appele IOC (injection des dépendance),

Juste histoire d'être pointilleux, IOC c'est pour Inversion of Control, qui n'est pas synonyme de Dependency Injection :)
16/09/2009, 10h00
Altess

Bonjour.

Effectivement, l'outil Spring semble répondre à tes attentes. De cette manière, tu ne verra aucune différence entre tes connections, du moins, aucune différence dans ton code.

Bref, le plus judicieux serait d'aller jeter un œil sur leur doc. Il me semble qu'un tuto C# disponible ici même parle de Spring, et de ses fonctionnalités, à travers des exemples relativement simples : http://tahe.developpez.com/dotnet/csharp/

Voilà.

Cordialement,
PKO