Bonjour tout le monde.
Dans le cadre de mon stage je dois réaliser une interface c# qui doit communiquer avec un logiciel embarqué réalisé en c++.  
Pour faire communiquer les deux, j'ai choisi de faire une Dll en c++ afin que les deux programmes puissent lire/écrire dessus et par ce biais, s'échanger des données.
Les deux programmes lisent/utilisent bien la dll, il n'y a pas d'accroc là dessus. En revanche; les modifications de l'un des programme sur la dll, n'est pas perçue par l'autre et vice et versa. J'en déduis donc qu'il y a deux instances en mémoire de cette dll, alors qu'il n'en faudrait qu'une.
 
Je précise que j'ai lié les deux programmes (l'un en c++; l'autre en c#) de manière implicite.
 
Si vous avez des idées... Merci d'avance  

Je vais utiliser la méthode explicite (dynamique par des pointeurs) en espérant qu'avec des pragma data seg, cela marche.

Euh... alors déjà, ta dll, elle est développée en quel langage ?
Comment l'appelles tu en C++ ? en C# ?
Quand tu dis "les modifications de l'un des programme sur la dll, n'est pas perçue par l'autre", de quelles modifications parles tu ?

 
désolé de n'avoir pas été clair.
La dll est développée en C++.
L'objectif de la dll: stocker des valeurs modifiées par le prog en c++ pour être lue par le prog en c# et vice versa (je n'ai pas trouvé mieux pour faire transiter des variables).  
 
Donc pour répondre à ta question, la dll sera appelée par les deux programmes (il faudra que je fasse un mutex), donc j'ai fais les appels en c# et en c++. Ces appels là marchent en statiques (dll export/import, pas de pointeurs), mais les deux programmes écrivent/lisent chacun sur une instance de dll, donc ça ne fait pas ce que je veux.
 
Peut être que l'appel en statique est incompatible avec ce que je veux faire c'est pour ça que je refais les appels, en dynamique cette fois (je l'ai fais sur le programme en c++, pas encore fini sur celui c#), mais je ne sais pas si cela vient de là.
 
 
 

Et les valeurs modifiées par le prog en C++, tu les transmets comment à ta dll ? Par un fichier ?
Sinon, pour faire communiquer tes programmes, pourquoi ne pas passer par une sérialisation XML ? C'est quand même plus pratique qu'une dll non ?

 
Les valeurs modifiées par le prog en C++ sont transmises par une fonction de la dll.  
Typiquement: le programme en c++ appel setTemperature de la dll qui modifie la variable temperature de la dll.  
Le programme en c# lis ensuite cette variable.
Il n'y a pas d'autre intermédiaire.
J'ai choisi cette approche car elle me semblais plus rapide (le programme en c# est une interface graphique, qui devra interagir rapidement avec le programme en c++).
 
Etant assez inexperimenté, je n'ai pas songé à la méthode que tu me décris.

J'imagine que tu dois écrire un truc dans ce genre :

Si c'est le cas, alors c'est normal, car tu transmets une copie de ta variable, et pas ta variable elle même.
La solution aurait été de transmettre un pointeur vers ta variable à la dll, lequel pointeur sera transmis au programme C#, mais ça ne fonctionnera pas non plus, car l'espace mémoire qui contient ta variable est propre à ton processus C++, et il ne peut pas être écrit par un autre processus (celui en C# en l'occurence).
Donc oublie l'idée de communiquer par dll, c'est très complexe à mettre en oeuvre. La sérialisation consiste, en simplifiant, à transformer un objet en fichier. Ce fichier pourra ensuite être désérialisé par n'importe quel programme qui pourra le modifier et le sérialiser à nouveau.

Ok merci pour le tuyau!

Je suis en train de me documenter sur la serialisation. J'ai déjà quelques interrogations mais j'attends de les avoir toutes rassemblé pour t'en faire part.
Par ailleurs, je suis tombé sur ce site, décrivant la technique de la mémoire partagée
http://www.developpez.net/forums/d [...] -partagee/  
Je me demande si ça ne résout pas mon problème initial ou si ça n'est pas finalement l'erreur que tu m'a décrit plus haut.

Ton problème initial se résout par tout un tas de méthodes pas forcément simples à mettre en oeuvre quand on a pas d'expérience, et qui font appel à des fonctions de gestion de mémoire très proches de l'OS et pas du tout portables car OS-dependantes. La solution la plus simple reste de passer par un fichier externe via un mécanisme de sérialisation.

J'ai résolu le problème en suivant les indications de ce site:
http://www.codeproject.com/KB/DLL/ [...] h_DLL.aspx