Logo GNT
Actualités Tests & Guides Bons Plans
Twitter iPhone pliant OnePlus 11 PS5 Disney+ Orange Livebox Windows 11
Entraide Développement Développement Visual Basic Partage de mémoire entre EXE

Partage de mémoire entre EXE

13 réponses
Avatar
Gianfranco
Hello,

Je ne sais pas si cela est possible mais j'aimerais partager de la
m=E9moire entre EXE. Le probl=E8me est que mes exe sont de langages
diff=E9rents.

Je poss=E8de une application en VB6. Et je souhaite cr=E9er une autre
application en VB.NET ou C#.NET qui ait acc=E8s =E0 l'espace m=E9moire de
ma premi=E8re application.

En r=E9sum=E9, j'aimerais que mon nouvel exe puisse lire certaines
variables de mon premier exe. Voire =E9galement pouvoir les modifier.

En esp=E9rant que quelqu'un puisse m'aider.

A+
Signaler un problème avec ce contenu

10 réponses

Supprimer
Cette action est irreversible, confirmez la suppression du commentaire ?
Signaler le commentaire

Veuillez sélectionner un problème

Nudité
Violence
Harcèlement
Fraude
Vente illégale
Discours haineux
Terrorisme
Autre
1 2
Avatar
Christian Hugoud
A ma connaissance, l'OS va refuser avec férocité...

Christian

"Gianfranco" a écrit dans le message de news:

Hello,

Je ne sais pas si cela est possible mais j'aimerais partager de la
mémoire entre EXE. Le problème est que mes exe sont de langages
différents.

Je possède une application en VB6. Et je souhaite créer une autre
application en VB.NET ou C#.NET qui ait accès à l'espace mémoire de
ma première application.

En résumé, j'aimerais que mon nouvel exe puisse lire certaines
variables de mon premier exe. Voire également pouvoir les modifier.

En espérant que quelqu'un puisse m'aider.

A+
Avatar
Jean-Marc
>"Gianfranco" a écrit dans le message de
news:
Hello,



Je ne sais pas si cela est possible mais j'aimerais partager de la
mémoire entre EXE. Le problème est que mes exe sont de langages
différents.



Je possède une application en VB6. Et je souhaite créer une autre
application en VB.NET ou C#.NET qui ait accès à l'espace mémoire de
ma première application.



En résumé, j'aimerais que mon nouvel exe puisse lire certaines
variables de mon premier exe. Voire également pouvoir les modifier.



Hello,

Je ne sais pas si c'est possible, et si ça l'est ce n'est surement
pas très simple.

Une chose est sure, c'est que ce genre de design me fait peur...
Il y a d'autres moyens, plus surs, de faire communiquer 2 applis:
- queues
- TCP/IP
- fichier temporaire

Dans tous les cas, ce sera plus sain au niveau applicatif, et
beaucoup plus simple à mettre en oeuvre, en particulier pour
tout ce qui est synchronisation, réinitialisation, etc. La gestion
des accès concurrents sera aussi plus simple, amha.

--
Jean-marc
Tester mon serveur (VB6) => http://myjmnhome.dyndns.org
"There are only 10 kind of people
those who understand binary and those who don't."
mailto: remove '_no_spam_' ;
Avatar
Gianfranco
Ok,

merci déjà pour ces réponses, le problèmes est que nos
applications ne doivent pas parler via socket ni TCP/IP etc. pour ce
qui est de la sécurité, des accès et autres nous sommes conscient
qu'il faut faire attention pour ne pas complétement altéré l'autre
exe mais nous devons faire ainsi. Avec toute la précaution, et tests
nécessaires pour qu'il y ait erreur 0.

Merci
Avatar
Jean-Marc
>"Gianfranco" a écrit dans le message de
news:
Ok,

merci déjà pour ces réponses, le problèmes est que nos
applications ne doivent pas parler via socket ni TCP/IP etc. pour ce
qui est de la sécurité, des accès et autres nous sommes conscient
qu'il faut faire attention pour ne pas complétement altéré l'autre
exe mais nous devons faire ainsi. Avec toute la précaution, et tests
nécessaires pour qu'il y ait erreur 0.




Hello,

j'ai trouvé un article dans le magazine "Byte" qui donne de
très bonnes pistes pour ce que tu veux:
http://www.byte.com/art/9410/sec14/art3.htm

Si tu es familier d'UNIX, ça devrait te rappeler des choses.
Bref, tu peux t'en sortir avec le file mapping.

Tu devras aussi sans doute utiliser Mutex() pour gérer les
accès concurrents.

Je serais intéressé de savoir si tu as pu faire qq chose avec
ça.

--
Jean-marc
Tester mon serveur (VB6) => http://myjmnhome.dyndns.org
"There are only 10 kind of people
those who understand binary and those who don't."
mailto: remove '_no_spam_' ;
Avatar
Jean-Marc
complément, la page de MSDN qui explique tout ça, avec un exemple:
http://msdn.microsoft.com/library/default.asp?url=/library/en-us/fileio/fs/creating_named_shared_memory.asp


--
Jean-marc
Tester mon serveur (VB6) => http://myjmnhome.dyndns.org
"There are only 10 kind of people
those who understand binary and those who don't."
mailto: remove '_no_spam_' ;
Avatar
Jean-Marc
L'affaire m'ayant intéressé, j'ai fait qq recherches et
j'ai finalement trouvé un excellent article sur le site
des mvps (vb.mvps.org):
http://vb.mvps.org/articles/ap199910.asp

La première partie explique comment travailler en VB avec les fichiers
mappés, et ceci s'applique directement à l'utilisation de ces fichiers
comme mémoire partagée entre process.
Le (listing1) implémente une classe pour manipuler tout cela de façon
transparente. En examinant le code de cette classe, on a tout ce qu'il
faut pour s'amuser avec la mémoire partagée.

Hope this helps;

--
Jean-marc
Tester mon serveur (VB6) => http://myjmnhome.dyndns.org
"There are only 10 kind of people
those who understand binary and those who don't."
mailto: remove '_no_spam_' ;
Avatar
Patrick Philippot
Bonjour,

Le (listing1) implémente une classe pour manipuler tout cela de façon
transparente. En examinant le code de cette classe, on a tout ce qu'il
faut pour s'amuser avec la mémoire partagée.



Les MMF (memory mapped files) sont en effet le moyen "officiel" de
partager de la mémoire entre processus sous Win32. Par rapport à
l'article en question, j'ajouterai toutefois une remarque importante.

Si l'objectif n'est pas de traiter des gros fichiers mais vraiment de
partager de la mémoire entre processus, il est complètement inutile de
travailler avec un "vrai" fichier. Au lieu d'ouvrir un fichier disque et
de récupérer son handle pour le passer à CreateFileMapping, on n'ouvre
pas de fichier et passe à CreateFileMapping le pseudo-handle 0xFFFFFFFF.

Tout va fonctionner exactement de la même manière, à ceci près qu'au
lieu d'utiliser un fichier standard, on utilise le fichier de pagination
de la mémoire virtuelle. Ou dit autrement, dans ce cas le mapping est
vraiment l'exact équivalent d'un bloc de mémoire virtuelle "normal".

--
Patrick Philippot - Microsoft MVP
MainSoft Consulting Services
www.mainsoft.fr
Avatar
Gianfranco
Bonjour,

eh ben merci bien pour toutes ces précisions. Jean-Marc j'étais
déjà tombé sur ce code que je trouve bien intéressant.
Malheureusement, et comme l'a très bien deviné Patrick, ce que j'ai
besoin c'est de passer uniquement une variable d'un exe à un autre,
donc pas besoin de fichier "physique" sur un disque.

Si je schématise un peu, un application va écrire un byte à quelque
part dans ma mémoire, et la 2ème application va être capable de lire
ce byte précis pour exécuter ou pas une opération après.

Je suis en train d'essayer à faire ça, mais je dois me planter à
quelque part. Si qqun a un bout de code faisant ça : (là j'essaie de
faire le test en passant une chaîne de caractères)

Dim filePaging As Long
Dim hFile As Long
Dim mess As String
mess = "String en mémoire"

filePaging = CreateFileMapping(&HFFFFFFFF, ByVal 0&, PAGE_READWRITE,
0&, Len(mess), "test")

Call CopyMemory(filePaging, mess, Len(mess))


Y aurait-il quelqu'un pour un coup de main svp.

Merci
Avatar
Jean-Marc
>"Gianfranco" a écrit dans le message de
news:
Bonjour,



Hello,

eh ben merci bien pour toutes ces précisions. Jean-Marc j'étais
déjà tombé sur ce code que je trouve bien intéressant.
Malheureusement, et comme l'a très bien deviné Patrick, ce que j'ai
besoin c'est de passer uniquement une variable d'un exe à un autre,
donc pas besoin de fichier "physique" sur un disque.



oui j'ai bien compris. MAIS les file mapping sont le moyen utilisé
par Windows pour faire cela. Il n'y a pas besoin de fichier physique,
la fonction CreateFileMapping peut être appelée avec INVALID_FILE_HANDLE
justement pour ça. Tu n'as pas vu ça dans la doc ?

Si je schématise un peu, un application va écrire un byte à quelque
part dans ma mémoire, et la 2ème application va être capable de lire
ce byte précis pour exécuter ou pas une opération après.



Oui j'ai bien compris :-) L'exemple donné dans le listing 1 montre
comment faire cela.

Je suis en train d'essayer à faire ça, mais je dois me planter à
quelque part. Si qqun a un bout de code faisant ça : (là j'essaie de
faire le test en passant une chaîne de caractères)



Dim filePaging As Long
Dim hFile As Long
Dim mess As String
mess = "String en mémoire"
filePaging = CreateFileMapping(&HFFFFFFFF, ByVal 0&, PAGE_READWRITE,
0&, Len(mess), "test")

Call CopyMemory(filePaging, mess, Len(mess))



Tu dois avoir un superbe plantage de l'IDE, non ?

Voici un exemple. J'ai fait ici le programme qui fait le CreateFileMapping,
et qui lit et écrit dans la mémoire partagée ainsi créée.

Pour lire et écrire depuis un autre programme, même principe mais utiliser
OpenFileMapping au lieu de CreateFileMapping.

Note: il faut bien sur libérer les ressources à la fin du programme,
avec CloseHandle et Unmap etc.


Bref, voici le code:

Note: le projet complet est disponible ici
(seveur en général allumé entre 08H00 et 12H00):
http://myjmnhome.dyndns.org/download.htm
(lien : sharedmemory.zip)


'---------------------------------------------------------------------------
------------
' Module : prog1
' DateTime : 7/11/2005 19:48
' Author : Jean-Marc
' Purpose : CREATION DU FILE MAPPING
'---------------------------------------------------------------------------
------------
Option Explicit
'
' Avertissement : Ce code ne comporte PAS de gestion d'erreurs...
'
Private Declare Function CreateFileMapping Lib "kernel32" Alias
"CreateFileMappingA" ( _
ByVal hFile As Long, lpFileMappigAttributes As Any, ByVal flProtect As
Long, ByVal _
dwMaximumSizeHigh As Long, ByVal dwMaximumSizeLow As Long, ByVal lpName
As _
String) As Long
Private Declare Function MapViewOfFile Lib "kernel32" (ByVal
hFileMappingObject As Long, _
ByVal dwDesiredAccess As Long, ByVal dwFileOffsetHigh As Long, ByVal _
dwFileOffsetLow As Long, ByVal dwNumberOfBytesToMap As Long) As Long

Private Declare Sub CopyMemory Lib "kernel32" Alias "RtlMoveMemory"
(Destination As _
Any, Source As Any, ByVal length As Long)


' Used by the API functions
Private Const STANDARD_RIGHTS_REQUIRED = &HF0000
Private Const SECTION_QUERY = &H1
Private Const SECTION_MAP_WRITE = &H2
Private Const SECTION_MAP_READ = &H4
Private Const SECTION_MAP_EXECUTE = &H8
Private Const SECTION_EXTEND_SIZE = &H10
Private Const SECTION_ALL_ACCESS = _
STANDARD_RIGHTS_REQUIRED Or SECTION_QUERY Or SECTION_MAP_WRITE Or
SECTION_MAP_READ Or _
SECTION_MAP_EXECUTE Or SECTION_EXTEND_SIZE

Private Const FILE_MAP_ALL_ACCESS = SECTION_ALL_ACCESS
Private Const PAGE_READONLY = &H2
Private Const PAGE_READWRITE = &H4
Private Const PAGE_WRITECOPY = &H8
Private Const INVALID_HANDLE_VALUE = -1&

Private GLOB_Buf_map As Long

'---------------------------------------------------------------------------
------------
' Procedure : CreateAndMap
' DateTime : 7/11/2005 20:08
' Author : Jean-Marc
' Purpose : Creation du filemapping et mapping de la vue
'---------------------------------------------------------------------------
------------
'
Private Function CreateAndMap(ByVal sharedName As String, _
ByVal memorySize As Long, _
ByRef pBufMap As Long, _
ByRef szErr As String) As Boolean
Dim hMapFile As Long

sharedName = Text1.Text
memorySize = Val(Text2.Text)

hMapFile = CreateFileMapping(INVALID_HANDLE_VALUE, ByVal 0&,
PAGE_READWRITE, 0&, memorySize, sharedName)
If hMapFile = 0 Then
szErr = "Echec de l'appel à CreateFileMapping()"
pBufMap = 0
CreateAndMap = False
Else
pBufMap = MapViewOfFile(hMapFile, FILE_MAP_ALL_ACCESS, 0&, 0&,
memorySize)
If pBufMap = 0 Then
szErr = "Echec lors de l'appel à MapViewOfFile()"
CreateAndMap = False
Else
CreateAndMap = True
End If
End If


End Function

'---------------------------------------------------------------------------
------------
' Procedure : Command1_Click
' DateTime : 7/11/2005 20:10
' Author : Jean-Marc
' Purpose : Appel de CreateAndMap()
'---------------------------------------------------------------------------
------------
'
Private Sub Command1_Click()
Dim sharedName As String
Dim memorySize As Long
Dim szErr As String
Dim ret As Boolean
Dim pBufMap As Long

' le nom de partage
sharedName = Text1.Text
' la taille qu'on veut allouer
memorySize = Val(Text2.Text)

' on fait un appel à createAndMap, qui va à la fois
' créer le mapfile et la view
' la fonction retourne un pointeur (pBufMap) sur la zone de méoire
partagée
' et retourne TRUE si succès
ret = CreateAndMap(sharedName, memorySize, pBufMap, szErr)
If Not ret Then
MsgBox "Erreur lors de l'appel de CreateAndMap, raison : " & szErr,
vbExclamation, "Erreur"
Else
' on met le pointeur dans une variable globale,
' car c'est juste un programme de démo
GLOB_Buf_map = pBufMap
MsgBox "Mémoire partagée initialisée correctement.", vbInformation,
"Information"
End If

End Sub

'---------------------------------------------------------------------------
------------
' Procedure : Command2_Click
' DateTime : 7/11/2005 20:15
' Author : Jean-Marc
' Purpose : Ecriture dans la mémoire partagée
'---------------------------------------------------------------------------
------------
'
Private Sub Command2_Click()
Dim Value As String
Dim length As Long
Dim Buffer() As Byte
Dim lpBuffer As Long
Dim i As Long

' récupère le texte à écrire dans le textBox
Value = Text3.Text
' calcul de la longueur
length = CLng(Len(Value))

' on dimensionne un buffer de byte de meme taille
ReDim Buffer(0 To length - 1) As Byte
' et on copie la chaine dedans octet par octet
For i = 1 To length
Buffer(i - 1) = Asc(Mid$(Value, i, 1))
Next i
' on calcule l'adresse du buffer
lpBuffer = VarPtr(Buffer(0))
' et on écrit ce buffer dans la mémoire partagée
Call CopyMemory(ByVal GLOB_Buf_map, ByVal lpBuffer, ByVal length)

MsgBox "Ecriture réussie.", vbInformation, "Information"
End Sub

'---------------------------------------------------------------------------
------------
' Procedure : Command3_Click
' DateTime : 7/11/2005 20:26
' Author : Jean-Marc
' Purpose : Lecture dans la mémoire partagée
'---------------------------------------------------------------------------
------------
'
Private Sub Command3_Click()
Dim Buffer() As Byte
Dim length As Long
Dim szResult As String
Dim i As Long


' on récupère la taille demandée
length = CLng(Val(Text4.Text))

' on alloue un buffer de la bonne taille
ReDim Buffer(0 To length - 1) As Byte

' et on lit depuis la mémoire partagée le bon nombre de bytes
Call CopyMemory(ByVal VarPtr(Buffer(0)), ByVal GLOB_Buf_map, ByVal
length)

' on construit une chaine, pour l'exemple
For i = 0 To length - 1
szResult = szResult & Chr$(Buffer(i))
Next i
' et on l'affiche dans le buffer
Label9.Caption = szResult

End Sub


--
Jean-marc
Tester mon serveur (VB6) => http://myjmnhome.dyndns.org
"There are only 10 kind of people
those who understand binary and those who don't."
mailto: remove '_no_spam_' ;
Avatar
Gianfranco
Bonjour,

eh ben merci bien pour tout ce boulot, ça m'aide vraiment beaucoup.
Mais maintenant moi je dois pousser encore plus loin la chose. Je dois
créer la mémoire partagée depuis VB6 mais pouvoir la lire depuis
VB.NET. Peut-on faire ça?

A+
1 2