Salut,
Information :
Pour un projet en cours j'ai implémenté dans une classe existante une méthode event() et un liste contenant des action à faire.

En gros, pour certain Event une action est crée et sera traitée par une autre méthode ProcessAction().

Actuellement vu, le nombre d'event et d'action possible voila ce que je fait


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
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
 
enum e_EventType
{
    EVENT_PLAYER_LEAVE           ,
    EVENT_GROUP_LEAVE            ,
    EVENT_PLAYER_LOG_ON         ,
    EVENT_PLAYER_LOG_OFF        ,
    ...
};
 
struct s_ActionMsg
{
    e_ActionType        Action;
    OGuid               Guid;
    uint32              Uint32Value;
    uint32              Uint32Value2;
	...
    s_LfgActionMsg(e_ActionType action, OGuid guid, uint32 uvalue = 0, uint32 uvalue2 = 0)
    {
        Action = action;
        Guid = guid;
        Uint32Value = uvalue;
        Uint32Value2 = uvalue2;
    }
    s_ActionMsg(e_ActionType action, uint32 uvalue = 0, uint32 uvalue2 = 0)
    {
        Action = action;
        Uint32Value = uvalue;
        Uint32Value2 = uvalue2;
    }
	...
};
 
class myclass
{ 
    ...
    Event(e_EventType eventType, OGuid guid=OGuid(), uint32 uintValue1 = 0, uint32 uintValue2 = 0);
    ...
    ProcessAction();
}
 
// dans le code
 
 
void myclass::Event(e_EventType eventType, Guid guid, uint32 uintValue1, uint32 uintValue2)
{
    switch (eventType)
    {
    case EVENT_PLAYER_LOG_ON :
        {
            ....
            break;
        }
 
    case EVENT_PLAYER_LOG_OFF :
        {
            s_ActionMsg* actionMsg = new s_ActionMsg(ACTION_REMOVE_PLAYER, guid, 15);
            m_ActionMsgList.Add(actionMsg);
            break;
        }
 
    case EVENT_PLAYER_LEAVE :
        {
            s_ActionMsg* actionMsg = new s_ActionMsg(ACTION_REMOVE_PLAYER, guid);
            m_ActionMsgList.Add(actionMsg);
            break;
		}
		...
	}
}
La methode ProcessAction est en fait un thread à part.
Tout fonctionne mais ce n'est pas beau...
1 : Lorsque j'appelle la fonction Event.
J'ai reussi à me limitter à 4 paramettre jusqu'ici. Mais si je dois appeler Event et transmettre un nouveau type de donnée je devrais l'ajouter...
Je ne pense pas que "Event(e_EventType eventType, OGuid guid=OGuid(), uint32 uintValue1 = 0, uint32 uintValue2 = 0, char* nchar=NULL);" soit plus propres...
Je pourrais appeler Event avec le pointeur d'un structure ce serais plus propre mais...
L'appel de Event se fait naturelement en dehors de la classe, je devrais donc definir une structure utilisable dans tout le programme pour l'Event.
Mais aussi je me confrontrerai au même problème que ce qui suis...

2 : La structure s_ActionMsg.
J'ai bien aimé l'utilisation de constructeur forcé, ca me fait un code très propre et lisible.
Malheureusement je me heurte au même problèmes que précedement. A chaque nouveau type de donnée dont j'ai besoin je devrais l'ajouté à la structure.
C'est pas bien grave quand on utilise 4 variable avec des type de données standard comme dans l'exemple mais dans la pratique ce n'est pas le cas.
J'ai une 10 aines de possibilité avec quelques classes complexe dont j'ai besoin d'une copie integrale dans le message. (appel au constructeur)
Si j'ai besoin d'une action qui ne necessite pas de paramettre, j'aimerais eviter que lors du "new" les autres classes soient créee pour rien.

Bref ce type d'implementation est limité que me conseillé vous comme piste?