Discussion :

[flo1981]

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 :

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
 
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...

[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 :

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

1
2
IHotFolder hotFolder =  new FTP();
XmlDocument xmlDoc = hotFolder.GetFile();

Classe WebConnection:

Code :

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

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.

[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

en tout cas merci pour ton aide

[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 :

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
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?

[flo1981]

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 :

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
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!

[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

[luunaz]

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
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.

[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