Pilotage lecteur bancaire via RAII

**Trunks** · 02/12/2009, 11h09

J'ai un lecteur de carte bancaire pour lequel on me fournit une DLL pour le piloter. J'aimerais en faire une classe RAII. Si un problème survient lors de la transaction, alors une exception est envoyée.

Voici un exemple très simplifié du problème:

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 CDistributorRAII
{
public:
	CDistributorRAII() {}
	~CDistributorRAII() { CloseSession(); Disconnect(); }
 
	void Connect() { if (!distributor_connect()) throw CConnectionException(); }
	void OpenSession() { if (!distributor_open_session()) throw CSessionException(); }
	void ProcessTransaction(float fAmount) { if (!distributor_process_transaction()) throw CTransactionException(); }
	bool CloseSession() { if (!distributor_close_session()) throw CSessionException(); }
	bool Disconnect() { if (!distributor_disconnect()) throw CConnectionException(); }
};
 
try
{
	CDistributor distributor;
 
	distributor.Connect();
	distributor.OpenSession();
	distributor.ProcessTransaction(49.90);
}
catch (CDistributorException &e)
{
	cerr << e.what() << endl;
}

Le destructeur ferme une session ainsi qu'une connexion (bien sûr si elles sont ouvertes, par soucis de visibilité, je ne l'ai pas intégré dans le code exemple). Ces fonctions peuvent renvoyer une erreur dans la DLL, j'aimerais donc pouvoir lancer une exception. Cependant, un destructeur ne doit jamais envoyer d'exception. D'où le problème.

Pour résoudre ce problème, je suppose que je dois faire des classes RAII pour une connection et une session?

**r0d** · 02/12/2009, 11h33

Pourquoi ne pas faire une fonction membre publique qui appelle CloseSession() et Disconnect()?
Autrement dit, sortir CloseSession() et Disconnect() du destructeur.

**Lavock** · 02/12/2009, 11h37

Si jamais la solution précédente ne te vas pas, tu as toujours le choix de gérer les erreurs à l'intérieur de ton destructeur, sans rien faire remonter...

**Trunks** · 02/12/2009, 12h08

Envoyé par r0d

Pourquoi ne pas faire une fonction membre publique qui appelle CloseSession() et Disconnect()?
Autrement dit, sortir CloseSession() et Disconnect() du destructeur.

Je ne veux pas appeler explicitement ces 2 fonctions, d'où l'idée de le mettre dans le destructeur. Ou s'ils sont appelés explicitement, alors bien sûr ne sera pas rappelé dans le destructeur.

J'ai fait la solution de Lavock, après tout, même si la fermeture de session ou déconnexion échoue, la transaction a quand même réussi au final.

**r0d** · 02/12/2009, 12h12

Envoyé par trunk

J'ai fait la solution de Lavock, après tout, même si la fermeture de session ou déconnexion échoue, la transaction a quand même réussi au final.

Je pense que c'est effectivement une bonne solution. Surtout que ce type de matériel est extrêment protégé. Je veux dire par là que tu n'as aucun risque de le laisser dans un état "dangereux". Tu utilise MDB pour la communication?

**Trunks** · 02/12/2009, 12h16

Envoyé par r0d

Je pense que c'est effectivement une bonne solution. Surtout que ce type de matériel est extrêment protégé. Je veux dire par là que tu n'as aucun risque de le laisser dans un état "dangereux". Tu utilise MDB pour la communication?

Qu'est-ce qu'un MDB?

**r0d** · 02/12/2009, 12h29

Envoyé par Trunks

Qu'est-ce qu'un MDB?

Donc non, tu n'utilises pas

MDB est un protocole de communication conçu pour les machines dites de "vending", mais en fait il s'utilise aussi souvent pour les machines "à carte" (distributeurs, etc.).

**Trunks** · 02/12/2009, 13h21

Envoyé par r0d

Donc non, tu n'utilises pas

MDB est un protocole de communication conçu pour les machines dites de "vending", mais en fait il s'utilise aussi souvent pour les machines "à carte" (distributeurs, etc.).

Effectivement ... je n'utilises pas sur aucun de mes 2 lecteurs bancaires (systèmes différents, Wynid pour la France, Banksys-Xenteo pour la Belgique)

Je communique juste avec une DLL en lui donnant des ordres via l'appel de fonctions.

**Lavock** · 02/12/2009, 14h17

J'ai dit traité l'erreur, pas l'ignorer >< !

**white_tentacle** · 02/12/2009, 14h59

Tu n'es pas RAII, là, mais purement RRIF.

D'ailleurs, je trouve ça un peu bizarre. Pourquoi vouloir laisser l'utilisateur appeler Connect() et OpenSession() ?

Et au final, ce qui intéresse l'utilisateur, c'est de savoir que la transaction s'est bien passée, non ? Soit le distributeur est capable de gérer plusieurs transactions sur la même connexion, et là, je comprends l'objet persistant, soit ce n'est pas le cas, et il ne devrait y avoir qu'une seule fonction visible de l'extérieur, ProcessTransaction(...), non ?

**Trunks** · 02/12/2009, 15h17

Envoyé par Lavock

J'ai dit traité l'erreur, pas l'ignorer >< !

Je ne l'ignore pas, je ne lance juste pas remonter d'exception.

Envoyé par white_tentacle

Tu n'es pas RAII, là, mais purement RRIF.

RRIF? Jamais vu ce terme, à quoi ça correspond?

Edit: Sur d'autres posts, j'ai vu que ça voulait dire Resource Release Is Finalization. Quelle est la différence avec le RAII?

Envoyé par white_tentacle

D'ailleurs, je trouve ça un peu bizarre. Pourquoi vouloir laisser l'utilisateur appeler Connect() et OpenSession() ?

Et au final, ce qui intéresse l'utilisateur, c'est de savoir que la transaction s'est bien passée, non ? Soit le distributeur est capable de gérer plusieurs transactions sur la même connexion, et là, je comprends l'objet persistant, soit ce n'est pas le cas, et il ne devrait y avoir qu'une seule fonction visible de l'extérieur, ProcessTransaction(...), non ?

Il s'agit d'une borne tactile. L'utilisateur choisit sa place de cinéma et paie sa place via sa carte bancaire. Mais il faut bien programmer la borne. C'est moi qui fait appel à ces fonctions, ça reste transparent pour l'utilisateur.

**3DArchi** · 02/12/2009, 15h40

Envoyé par Trunks

RRIF? Jamais vu ce terme, à quoi ça correspond?

Edit: Sur d'autres posts, j'ai vu que ça voulait dire Resource Release Is Finalization. Quelle est la différence avec le RAII?

En gros tu ne gères que la libération de ta ressource (RRIF), pas son acquisition (RAII).

Envoyé par Trunks

Il s'agit d'une borne tactile. L'utilisateur choisit sa place de cinéma et paie sa place via sa carte bancaire. Mais il faut bien programmer la borne. C'est moi qui fait appel à ces fonctions, ça reste transparent pour l'utilisateur.

En parlant d'utilisateur, je pense qu'il désignait l'utilisateur de ta classe c'est à dire une autre classe pas l'utilisateur final

Si je suis bien notre tentacule, l'idée est d'ouvrir ta connexion à la construction de l'objet, de la fermer à sa destruction, dès lors la seule autre opération visible est la demande d'une transaction.

**Trunks** · 02/12/2009, 15h54

Envoyé par 3DArchi

En gros tu ne gères que la libération de ta ressource (RRIF), pas son acquisition (RAII)..

Donc pour qu'elle soir RAII, il faudrait mettre la connexion et l'ouverture de session dans le constructeur?

Envoyé par 3DArchi

En parlant d'utilisateur, je pense qu'il désignait l'utilisateur de ta classe c'est à dire une autre classe pas l'utilisateur final

Si je suis bien notre tentacule, l'idée est d'ouvrir ta connexion à la construction de l'objet, de la fermer à sa destruction, dès lors la seule autre opération visible est la demande d'une transaction.

En effet, j'aurais qu'une seule connexion (au lancement du programme de la borne tactile), et qu'une seule déconnexion (à l'arrêt du programme de la borne), ainsi qu'une initialisation que je n'ai pas mis dans mon exemple car pas pertinent.
Cependant, il y aura une session par transaction (une session par carte bancaire).
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
Connexion
    Initialisation
    Ouverture de session
        Transaction
    Fermeture de session
    Ouverture de session
        Transaction
    Fermeture de session
    ...
    Ouverture de session
        Transaction
    Fermeture de session
Déconnexion

Donc je ne peux pas mettre la session dans le destructeur (ainsi que dans le constructeur d'ailleurs).

**3DArchi** · 02/12/2009, 16h01

Un pattern Etat me semble bien correspondre avec comme états : non-initialisé, initialisé, connecté (transaction ?) et comme transitions :
non-initialisé -> initialisé : à la construction
initialisé -> connecté : au début d'une transaction
connecté -> initialisé : à la fin de la transaction
initialisé -> non-initialisé : à la destruction.
La gestion des connexions/deconnexion/ouverture/fermeture de sessions se gérant dans les transitions.

**Trunks** · 02/12/2009, 16h42

Envoyé par 3DArchi

Un pattern Etat me semble bien correspondre avec comme états : non-initialisé, initialisé, connecté (transaction ?) et comme transitions :
non-initialisé -> initialisé : à la construction
initialisé -> connecté : au début d'une transaction
connecté -> initialisé : à la fin de la transaction
initialisé -> non-initialisé : à la destruction.
La gestion des connexions/deconnexion/ouverture/fermeture de sessions se gérant dans les transitions.

Je vais y jeter un oeil, merci

**Trunks** · 02/12/2009, 17h55

Envoyé par white_tentacle

Tu n'es pas RAII, là, mais purement RRIF.

D'ailleurs, je trouve ça un peu bizarre. Pourquoi vouloir laisser l'utilisateur appeler Connect() et OpenSession() ?

Et au final, ce qui intéresse l'utilisateur, c'est de savoir que la transaction s'est bien passée, non ? Soit le distributeur est capable de gérer plusieurs transactions sur la même connexion, et là, je comprends l'objet persistant, soit ce n'est pas le cas, et il ne devrait y avoir qu'une seule fonction visible de l'extérieur, ProcessTransaction(...), non ?

Finallement, je fais comme tu m'as dit.

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
class BANKSYSXENTEORAII_API CBanksysXenteoRAII
{
public:
	CBanksysXenteoRAII();
	~CBanksysXenteoRAII();
 
	bool ProcessTransaction(UINT iAmount);
 
private:
	void Connect();
	void Initialize();
	void OpenSession();
	void CloseSession();
	void Disconnect();
 
	static void __stdcall EventCallbackFunction(HPAYTYPE hPayType);
 
	HPAYTYPE m_hPayType;
 
	bool m_bConnected;
	bool m_bSessionOpened;
	bool m_bInitialized;
};

L'utilisateur n'aura qu'à créer une instance de CBanksysXenteoRAII, puis faire les transaction souhaitées. Les sessions sont gérées à l'intérieur de ProcessTransaction().

**Lavock** · 02/12/2009, 18h12

Mais alors, pourquoi une classe ? Au pire, un vielle objet purement statique si tu y tiens... m'enfin, le truc que tu nous décris, ça ma beaucoup plus l'air purement procédural...

**Arzar** · 02/12/2009, 23h27

Envoyé par Lavock

Mais alors, pourquoi une classe ? Au pire, un vielle objet purement statique si tu y tiens...

Tu n'as jamais entendu parlé du concept de RAII, ni jamais utilisé ifstream ?

**Lavock** · 03/12/2009, 10h20

Le rapport ???

Puis RAII, c'est un concept fort pratique pour des algorithme qui en ont besoin... Pourquoi le mettre en place si l'objet n'as pas de persistance ?? D'ailleur, pourquoi mettre en place un objet ?
C'est la définition même d'une fonction => un changement de bord ponctuelle.

C'est bien beau de vouloir mettre du DP partout... m'enfin faut-il encore que se soit utile...

Et oui, je sais ce que le RAII... Si effectivement, l'objet était persistant, fort utile : création de l'objet avec ouverture de connexion et de session, fermeture à la destruction. C'est pas comme si c'était d'une difficulté fondamental à mettre en place !

Au pire, ce sont les objets de la fonction qui en ont besoin... Mais je vois vraiment pas l'interet là... on va dire que dans l'absolue de l'absolue, on peut faire :

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
 
class BANKSYSXENTEORAII_API CBanksysXenteoRAII
{
public:
	static bool ProcessTransaction(UINT iAmount);
 
private:
 
	CBanksysXenteoRAII(); //throw execpt1 except2
	~CBanksysXenteoRAII();
	void Connect();
	void Initialize();
	void OpenSession();
	void CloseSession();
	void Disconnect();
 
	static void __stdcall EventCallbackFunction(HPAYTYPE hPayType);
 
	HPAYTYPE m_hPayType;
 
	bool m_bConnected;
	bool m_bSessionOpened;
	bool m_bInitialized;
};
 
static bool BANKSYSXENTEORAII_API::ProcessTransaction(UINT iAmount) {
     BANKSYSXENTEORAII_API b();
     //traitement
}
 
BANKSYSXENTEORAII_API::BANKSYSXENTEORAII_API() {
    //connection, intialisation, et ouverture de session
    //throw si pb
}
 
BANKSYSXENTEORAII_API::~BANKSYSXENTEORAII_API() {
   //fermeture session, deco
}

Mais encore une fois, je trouve que c'est s'embêter pour pas grand chose, mis à part avoir mis un pattern dans son code...

**white_tentacle** · 03/12/2009, 10h31

La connexion peut être persistante d'une transaction à l'autre, donc ça a du sens d'encapsuler ça dans un objet.

La méthode processTransaction ne faisant qu'ouvrir la session et la fermer, tout en gardant la connexion.

Pas vraiment besoin de RAII, cela dit.

Pilotage lecteur bancaire via RAII

C++

Discussions similaires

Partager

Partager