Fonction membre statique

Bonjour,

J'ai un composant qui utilise une classe importée. L'interface de la classe était de type COM.
Le classe en question génère des évènements. Mon composant doit les récupérer, mettre en forme les messages et renvoyer le tout dans un autre évènement.
Seulement, j'ai un gros problème que je ne sais pas résoudre.
La classe est écrite en C# et l'évènement est un delegate.
J'ai créé une fonction intermédiaire pour pouvoir utiliser ce delegate mais je doit envoyer une information pour que la classe puisse appeler ma fonction.
Voici un exemple d'appel que j'ai dans C++Builder :

Code:

---

ClasseExterne->OnActioncallbackWrapper((long)&BackFromActioncallbackWrapper);

---

Et voici comment ma fonction est implanté :

Code:

---

1 2 3 4 5 6 7

void TMonComp::BackFromActioncallbackWrapper(IAsyncResult* asyncResult_in) VARIANT value; asyncResult_in->get_AsyncState(&value); if (FOnAction) { (FOnAction)(this, VarToStr(value)); }

---

Et dans l'entête :

Code:

---

static void BackFromAtioncallbackWrapper(IAsyncResult* asyncResult_in);

---

Le problème :
- Si je laisse la foncion en static, elle n'a plus accès au pointeur this et je ne peut pas remonter l'information dans l'évènement.:calim2:
- Si j'enlève le mot static, j'ai l'erreur suivante :

Citation:

---

[BCC32 Erreur] TMonComp.cpp(85): E2031 Impossible de transtyper de 'void (* (_closure )(IAsyncResult *))(IAsyncResult *)' en 'long'

---

:cry:

Quelqu'un à une idée lumineuse ?

Merci

J'ai pu avancé mais je bloque toujours.

J'ai un nouveau type d'évènement : (.h)

Code:

---

1 2 3 4 5

typedef void __fastcall (__closure *TNotifyString)(UnicodeString Text);   ...   static TNotifyString FOnAction;

---

Et j'ai donc modifié le code : (.cpp)

Code:

---

1 2 3 4 5 6 7 8 9

void TMonComp::BackFromAtioncallbackWrapper(IAsyncResult* asyncResult_in) { VARIANT value; asyncResult_in->get_AsyncState(&value); if (FOnAction) { (FOnAction)(VarToStr(value)); } }

---

Seulement, j'ai une erreur lors de l'édition des liens :

Citation:

---

[ILINK32 Erreur] Error: 'TMonComp::FOnAction' externe non résolu, référencé depuis C:\DOCUMENTS AND SET...\DEBUG\TMONCOMP.OBJ

---

J'ai vu dans la FAQ C++ qu'il faut initialiser les membres static pour corriger cette erreur :

Code:

---

1 2 3 4 5

//--------------------------------------------------------------------------- void __fastcall TMonComp::foo(UnicodeString Text) { // }

---

J'ai essayé ces 2 lignes et cela ne corrige pas l'erreur, j'en ai 3 autres :

Code:

---

1 2	TSpeech::FOnAction = (TNotifyString)&foo; TSpeech::FOnAction = NULL;

---

Citation:

---

[BCC32 Erreur] TMonComp.cpp(15): E2303 Nom de type attendu
[BCC32 Erreur] TMonComp.cpp(15): E2356 Mauvaise correspondance de type dans la redéclaration de 'TMonComp::FOnAction'
[BCC32 Erreur] TMonComp.h(24): E2344 Déclaration plus récente de 'TMonComp::FOnAction'

---

Une idée ?

J'ai pu identifier plus précisément le problème.
Il intervention quand j'utilise le TNotifyString (qui est en static) dans la fonction static.
Si j'utilise cette donnée membre dans une autre fonction, il n'y a aucun problème.

Donc, je me retrouve avec une fonction static d'une classe qui provoque une erreur de lieur quand elle accède à une donnée static de sa propre classe.

:cry:
Je coule.

Dois-je plutôt demander dans le forum c++ si ce n'est pas une erreur spécifique de C++Builder ? Parce que je n'en sais rien.

Hello,

Et avec ceci ??

Code:

---

1 2 3

TNotifyString TSpeech::FOnAction = (TNotifyString)&foo; ou TNotifyString TSpeech::FOnAction = NULL;

---

Je n'ai pas très bien compris ton problème: tu as une classe C++ qui récupère un événement généré par une classe C# reçue depuis une interface COM. C'est bien ça?

Tu aimerais que chaque instance de la classe C# appelle la fonction TMonComp::BackFromAtioncallbackWrapper de l'instance de TMonComp correspondante? Ou as-tu une seule instance de TMonComp qui répond à tous les événements de toutes les instance de la classe C#?

Si tu t'oriente vers une solution avec une fonction statique, cela semble signifier que tu utilises la même fonction de traitement C++ pour toutes les instances de la classe C# (le second cas de mon raisonnement compliqué ci-dessus). Dans ce cas, tu devrais aussi pouvoir travailler avec une fonction et une variables globales:

.h:

Code:

---

1 2	extern TMonComp* FActionObject; void BackFromAtioncallbackWrapper(IAsyncResult* asyncResult_in);

---

.cpp

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12

TMonComp* FActionObject=NULL; // Initialisation de l'objet à appeler   // Cette fonction ne sert qu'à appeler le callback de l'instance void BackFromAtioncallbackWrapper(IAsyncResult* asyncResult_in) { VARIANT value; asyncResult_in->get_AsyncState(&value); if (FActionObject) { FActionObject->CallbackFunction(VarToStr(value)); } }

---

Et dans ton TMonComp.h

Code:

---

1 2 3 4 5 6 7

class TMonComp {   public: void CallbackFunction(UnicodeString Text);   };

---

TMonComp.cpp

Code:

---

1 2 3 4

void TMonComp::CallbackFunction(UnicodeString Text) { ... }

---

Il faut ensuite que tu assignes une instance de TMonComp à FActionObject pour qu'elle puisse traiter le message. Ici, j'
J'espère avoir apporté un peu d'eau à ton moulin ;-)

Merci de votre aide.

@totoche76 : Ça ne fonctionne pas. Une histoire d'erreur de transtypage.
De toute façon, maintenant l'erreur se produit au moment de lier (ilink32) et est provoqué par cette partie du code :

Code:

---

1 2 3 4 5 6 7 8 9

void TMonComp::BackFromAtioncallbackWrapper(IAsyncResult* asyncResult_in) { VARIANT value; asyncResult_in->get_AsyncState(&value); if (FOnAction) // provoque l'erreur { (FOnAction)(VarToStr(value)); // et la aussi } }

---

J'utilise FOnAction dans une autre fonction et cela ne pose pas de problème. FOnAction et BackFromAtioncallbackWrapper sont static et devrait pouvoir se voir.
En gros, je peux remplir la donnée mais je ne peux pas l'utiliser quand j'en ai besoin.

@Patrick Seuret :
Il peut y avoir plusieurs instance de mon composant. Le fait d'indiquer un évènement va donc appeler une fonction de la librairie C# qui va ajouter l'évènement à la liste des évènements devant être lancé. Donc, peu importe que l'évènement ou la fonction dans le composant soit statique ou non puisqu'une fois rempli, l'évènement est dans la liste.

Seulement, pour appeler la fonction en question, il me faut impérativement une fonction que la librairie C# puisse appelé a travers le wrapper COM. Et je ne peut pas utiliser une fonction standard d'une classe à cause du pointeur this qu'il ne peut pas remplir. D'ailleurs, j'ai pas le choix à ce niveau.
Je n'ai pas tout à fait compris ta solution avec une fonction globale.
Tu veux dire qu'il faudrait qu'il y ai une fonction extérieure à ma classe qui soit utilisé et qui utiliserai une instance du composant ?
Comment faire dans ce cas pour être sûr qu'il utilise le composant que je veux et non pas un autre ?

Merci de votre aide

Citation:

---

Envoyé par gandf

Comment faire dans ce cas pour être sûr qu'il utilise le composant que je veux et non pas un autre ?

---

C'est justement la question: si tu as plusieurs instances de ton composant, tu vas avoir de la peine à traiter un événement avec une fonction statique puisque par définition elle est partagée par toutes les instances. Je pensais donc que tu n'avais qu'une seule instance de TMonComp, c'est pourquoi je proposais de mettre une fonction globale (hors de la classe) qui utilise un pointeur global sur l'unique instance de TMonComp.

Si ce n'est pas le cas, tu vas devoir trouver un système pour définir une fonction différente pour chaque instance de ton TMonComp et transmettre cette fonction comme delegate à la classe C#.

Si tu connais le nombre maximum d'instance et qu'il est suffisament faible, tu peux créer autant de fonctions (globales ou statique, c'est kif-kif): la fonction1 appelle l'instance1 (enregistrée dans un tableau global par exemple), la fonction2 l'instance2, etc.
A l'utilisation, il te faudra:
1) mettre en place un système "n" qui te permet de savoir quelle est la prochaine fonction libre (un compteur ou un tableau des positions libres),
2) sauver le pointeur de l'instance "n" correspondant dans le tableau à la position "n"
3) tranmettre l'adresse de la fonction "n" à ton instance C#
4) mettre à jour ton système de disponibilités (point 1)
C'est un peu lourdaud mais ça devrait marcher si tu n'as pas 10'000 instances! En plus il faut gérer si tu as des instances qui doivent être retirées de la liste (tableau des positions libres ou réorganisation de la liste selon ce que ta classe C# te permet)

En fait l'idéal serait de créer des "fonctions" dynamiquement (comme pour les instances), mais je ne pense pas que ce soit possible directement en C++.

Normalement, mon composant n'est utilisé qu'une seule fois dans une application.
Mais si cela se produit, le code c# indique qu'il ne peut pas utiliser les ressources et le composant fonctionne à l'état désactivé. C'est à dire que tout ce qu'il peut faire c'est d'essayer de relancer l'initialisation du code c# jusqu'à ce qu'il dispose de ressource.
Donc, on peut utiliser plusieurs fois le composant mais un seul fonctionnera. D'ailleurs, je fais toujours le test avant de lancer quelque chose en rapport avec le code c# :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12

void __fastcall TMonComp::SetOnAction(TNotifyString OnAction) { if (FActivated == false) // 1er test { return; } if (CodeCSharp != NULL) // 2ème test { FOnAction = OnAction; CodeCSharp->OnActioncallbackWrapper((long)&FOnAction); } }

---

Sachant que le code c# est dans un assembly et qu'il peut être utiliser par un autre programme (on ne sais jamais), c'est lui qui se charge d'indiquer si les ressources qu'il utilise sont disponibles.

L'important n'est pas que la fonction ne soit qu'une seule fois dans toutes les instance c'est juste qu'elle puisse être appelé par le code c#. Que la fonction soit globale ou static n'est pas important. Au final, Il faut que le wrapper puisse le transmettre au delegate et que le delegate puisse l'appeler. C'est pour ça que j'ai la fonction suivante :

Code:

---

static void BackFromActioncallbackWrapper(IAsyncResult* asyncResult_in);

---

Elle peut être appelée et en retour elle renvoie les données à l'évènement indiqué par l'utilisateur du composant. Si une autre instance du composant essaie d'indiquer un évènement, il sera rejeté par le "setter" de la propriété de l'évènement en question.

Si je ne me trompe pas, une fonction globale ne peut pas faire l'affaire. En effet, soit, elle ne peut soit pas accéder aux membres de la classe, soit elle y accède et dans ce cas j'ai le problème du paramètre supplémentaire non pris en charge.

Je ne sais pas si j'explique bien alors voici une image pour illustrer :
http://www.flyonsoft.com/images/static.png
C'est un peut plus compliqué que ce schéma parce que j'ai du rajouter des fonctions que j'ai nommé wrapper pour que tout puisse fonctionner en parfaite harmonie dans le code c#.

Donc la question demeure : Pourquoi ai-je un problème de lieur quand une fonction static accède à une donnée static de sa propre classe ?
Je ne connais pas assez bien les subtilités qu'engendre l'utilisation de membres et de fonction static pour résoudre le problème et je ne vois pas comment utiliser une fonction qui ne soit pas static.


Pour rappel, le code qui provoque le problème de lieur :

Code:

---

1 2 3 4 5 6 7 8 9

void TMonComp::BackFromAtioncallbackWrapper(IAsyncResult* asyncResult_in) { VARIANT value; asyncResult_in->get_AsyncState(&value); if (FOnAction) // provoque l'erreur { (FOnAction)(VarToStr(value)); // et la aussi } }

---

Et le code d'erreur :

Code:

---

[ILINK32 Erreur] Error: 'TMonComp::FOnAction' externe non résolu, référencé depuis C:\DOCUMENTS AND SET...\DEBUG\TMONCOMP.OBJ

---

C'est bien la configuration que j'avais en tête dans mon premier mail.

Je ne sais pas pourquoi le linker t'embête... Je reviens donc sur mon idée de départ:
1) déclarer une variable globale qui est un pointeur sur ton instance de TMonComp
2) Assigner le contenu de cette variable en même temps que tu assignes le delegate à la classe C#

Tu devrais pouvoir utiliser la variable globale depuis ta fonction (qu'elle soit globale ou static).

Exemple (écrit à la sauvage sans tester):

.h

Code:

---

1 2 3 4 5 6 7

class TMonComp { public: static void CallbackFunction(); void HelloWorld(); };   extern TMonComp* toto;

---

.cpp

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14

TMonComp* toto;   void TMonComp::CallbackFunction() {   if (toto) toto->HelloWorld();   };   void TMonComp::HelloWorld() {   printf("Hello world");   };

---

Application:

Code:

---

1 2 3 4 5

... TMonComp myComp; toto=&myComp; library->SetResource(&TMonComp::CallbackFunction);

---

Je comprend vite mais il faut m'expliquer longtemps :ccool:

Cela à l'air ne fonctionner. En tout cas plus de problème de lieur et tout compile.

Je fais toutes les modifications pour tester :
Je modifie tous les évènements, je recrée le composant et ensuite je pourrais le tester en modifiant mon programme.

Un grand merci