Discussion :

[Trunks]

Bonjour,

Je viens demander un conseil pour savoir quel est selon vous le meilleur moyen d'implémenter mon projet qui permet de gérer plusieurs types de cartes bancaires.

J'ai 2 types de lecteurs de cartes bancaires:
- Wynid
- Banksys-Xenteo

J'ai donc une classe mère CCardReader qui sert d'interface, et 2 classes filles qui implémentent cette dernière, CWynidCardReader et CBanksysXenteoCardReader.

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
 
class CCardReader  
{
public:
	CCardReader();
	virtual ~CCardReader();
 
	// Opérations
	virtual int Connect() const = 0;
	virtual int Initialize() const = 0;
	virtual int OpenSession() const = 0;
	virtual int ProcessTransaction() const = 0;
	virtual int CloseSession() const = 0;
	virtual int Disconnect() const = 0;
 
	virtual TCHAR* GetName() const = 0;
};
 
class CWynidCardReader : public CCardReader { /* Lecteur de carte Wynid */ };
 
class CBanksysXenteoCardReader: public CCardReader { /* Lecteur de carte Banksys-Xenteo */ };

Dans mon application MFC, j'ai un menu déroule me demandant de choisir l'un de ces lecteurs. Je dois donc créer une instance de lecteur de cartes bancaires de manière dynamique via l'opérateur new() vu que le programme ne connait le type de lecteur qu'une fois le programme exécuté.

Ce qui donne:

Code :

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

1
2
3
4
5
6
7
8
 
class CTestCardReaderDlg : public CDialog
{
// ...
 
private:
	CCardReader* m_lpCardReader;
};

Pour rendre l'application plus résistante, j'utile l'idiome RAII sur la classe CCardReader.

Ce qui 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
40
41
42
43
44
45
46
47
48
class CCardReaderRAII  
{
public:
	CCardReaderRAII(CCardReader* lpCardReader = NULL);
	~CCardReaderRAII();
 
	// Attache/Détache un CCardReader
	void Attach(CCardReader* lpCardReader);
	// Pas nécessaire car fait par le destructeur
	void Detach();
 
	// Opérations
	int Connect() const;
	int Initialize() const;
	int OpenSession() const;
	int ProcessTransaction() const;
	int CloseSession() const;
	int Disconnect() const;
 
	TCHAR* GetName() const;
 
private:
	CCardReader* m_lpCardReader;
};
 
 
class CTestCardReaderDlg : public CDialog
{
// ...
 
private:
	CCardReaderRAII m_cardReaderRAII;
};
 
// Détermine le type de lecteur de carte
switch (nIndex)
{
	case WYNID:
		m_cardReaderRAII.Attach(new CWynidCardReader);
		return TRUE;
 
	case BANKSYS_XENTEO:
		m_cardReaderRAII.Attach(new CBanksysXenteoCardReader);
		return TRUE;
 
	default: /* CB_ERR */
		return FALSE;
}

J'aimerais également appliquer le RAII pour les fonctions de connexion (déconnexion automatique), d'ouverture de session (fermeture de session automatique) afin de prévenir une éventuelle erreur.

Quel serait le meilleur moyen? Refaire une classe RAII pour ces fonctions afin de gérer ça dans le constructeur et destructeur? Comment procéder?
Y aurait-il une autre approche qui serait meilleure?

Merci d'avance

[Trunks]

Je vais m'inspirer de cette partie de la FAQ => http://cpp.developpez.com/faq/cpp/?p...POINTEURS_raii

[3DArchi]

Salut,
A priori, de ce que je comprend tu as 2 ressources à gérer : le pointeur et la connexion de la carte. Donc tu devrais avoir 2 classes distinctes pour gérer chacune de ces ressources : un pointeur intelligent pour le pointeur et un CCardReaderRAII pour gérer la connexion. Non ?

[Trunks]

Effectivement, je pourrais utiliser un pointeur intelligent (std::auto_ptr) pour gérer le pointeur sur CCardReader à la place de créer une classe CCardReaderRAII qui fait le même travail.

Il me reste 2 ressources à gérer:
- La connexion/déconnexion
- L'ouverture/fermeture de session

Pour ces 2 ressources, je pense qu'il faut faire une classe RAII.

[3DArchi]

Effectivement, je pourrais utiliser un pointeur intelligent (std::auto_ptr) pour gérer le pointeur sur CCardReader à la place de créer une classe CCardReaderRAII qui fait le même travail.

Il me reste 2 ressources à gérer:
- La connexion/déconnexion
- L'ouverture/fermeture de session

Pour ces 2 ressources, je pense qu'il faut faire une classe RAII.

Normalement, chaque classe RAII ne gère qu'une seule ressource. Donc, il t'en faudrait 2. Mais en même temps, ta session doit être contenue dans ta connexion. ?

[Trunks]

Normalement, chaque classe RAII ne gère qu'une seule ressource. Donc, il t'en faudrait 2. Mais en même temps, ta session doit être contenue dans ta connexion. ?

J'utilise une DLL externe qui a des fonctions distinctes:
- connexion()
- initialisation()
- ouverture_session()
- fermeture_session()
- deconnexion()

Je fais appel à ces fonctions que j'encapsule dans une nouvelle interface afin de mieux gérer les ressources.
Bien sûr, chaque lecteur de carte a sa propre implémentation. D'où je pense qu'il faut gérer 2 ressources, chaque fonction étant susceptible de planter.

[koala01]

Salut,

Si j'ai bien compris (et, si je pose la question, c'est pour te permettre de me contredire ), il n'y aura jamais, à un insant T, qu'un seul type de lecteur branché

Une question intelligente à laquelle tu risque d'avoir du mal à répondre serait "envisages-tu que les type de lecteurs de cartes soit appelés à se multiplier dans un futur suffisamment proche que pour ta version de l'application doive encore être en mesure d'évoluer de ce coté

Si je prévois quelques difficultés pour apporter la réponse à cette question, c'est parce que j'ai bien conscience qu'il n'y a sans doute pas des nouveaux types de lecteurs de cartes qui apparaissent tous les jours...

Par contre, ce dont je suis sur, c'est que, au rythme auquel évolue la technique, il est difficile de prévoir de quoi demain sera fait (quel sera l'état de la technique d'ici 2 ou 3 ans ou ... 10)...

Si la réponse à ces deux questions venait à être "oui", je te conseillerais volontiers de sortir "la grosse artillerie", avec fabrique, éventuellement prototypes, manager potentiellement sous la forme de singleton , et tout l'toutim...

L'idée étant de faciliter au maximum les évolutions futures: lorsqu'un nouveau type de lecteur de cartes apparait, tu le fait dériver de CCardReader, tu l'inscrit dans la fabrique, tu le rajoute dans le menu déroulant de l'interface graphique, et merci bonsoir: un petit coup de compilation et le tour est joué

(bon, je l'admets, c'est la version "optimiste )

Si tu estimes que l'évolution arrivera bien après la durée de vie de ton application, un truc beaucoup plus simple peut suffir:

un "CardReaderManager, auquel tu demande de créer et de détruire les instances réelles descendant de CCardReader et avec lequel communique ton IHM

[Trunks]

Salut,

Si j'ai bien compris (et, si je pose la question, c'est pour te permettre de me contredire ), il n'y aura jamais, à un insant T, qu'un seul type de lecteur branché

Effectivement, un seul à la fois

Une question intelligente à laquelle tu risque d'avoir du mal à répondre serait "envisages-tu que les type de lecteurs de cartes soit appelés à se multiplier dans un futur suffisamment proche que pour ta version de l'application doive encore être en mesure d'évoluer de ce coté

Si je prévois quelques difficultés pour apporter la réponse à cette question, c'est parce que j'ai bien conscience qu'il n'y a sans doute pas des nouveaux types de lecteurs de cartes qui apparaissent tous les jours...

Par contre, ce dont je suis sur, c'est que, au rythme auquel évolue la technique, il est difficile de prévoir de quoi demain sera fait (quel sera l'état de la technique d'ici 2 ou 3 ans ou ... 10)...

Si la réponse à ces deux questions venait à être "oui", je te conseillerais volontiers de sortir "la grosse artillerie", avec fabrique, éventuellement prototypes, manager potentiellement sous la forme de singleton , et tout l'toutim...

L'idée étant de faciliter au maximum les évolutions futures: lorsqu'un nouveau type de lecteur de cartes apparait, tu le fait dériver de CCardReader, tu l'inscrit dans la fabrique, tu le rajoute dans le menu déroulant de l'interface graphique, et merci bonsoir: un petit coup de compilation et le tour est joué

(bon, je l'admets, c'est la version "optimiste )

Si tu estimes que l'évolution arrivera bien après la durée de vie de ton application, un truc beaucoup plus simple peut suffir:

un "CardReaderManager, auquel tu demande de créer et de détruire les instances réelles descendant de CCardReader et avec lequel communique ton IHM

Justement, le lecteur belge vient de changer. Avant c'était Banksys, et maintenant c'est Banksys-Xenteo. De plus, je pense qu'en Espagne et Italie, on utilise encore un autre type de lecteur. Donc je dirais qu'il est plus qu'envisageable que de nouveaux lecteurs apparaissent.

Je vais donc regarder du côté de la fabrique. Il est tant d'utiliser des design patterns.

Toutefois, j'aimerais juste savoir comment gérer les 2 ressources cités au dessus. En créant une classe où j'utilise la ressource dans le constructeur et la libère dans le destructeur selon l'idiome RAII?