COMMUNICATION INTER PROCESS + PARTAGE MÉMOIRE

Commentaire de MadM@tt le 19/09/2006 12:55:11

Ah ouais c'est pas mal ça, je me suis toujours demandé comment faire

Par contre tu devrais peut etre appeler la source "partage de variables..." ça serait peut etre plus clair, car la j'avais aucune idée du code sur lequel j'allait tomber quand j'ai cliqué dessus (enfin j'ai vu renfield, j'ai pas hésité ^^)

++

Commentaire de eldim le 20/09/2006 08:21:47

Bonjour,

C'est vraiment génial ce truc là !!!

Bravo

Commentaire de Mayzz le 20/09/2006 18:39:21

Il y a aussi sous VB les fonctions SaveSetting et GetSetting pour ceux qui ne connaissent pas mais le principe est tout autre et l'on ne peut accèder à la configuration que par le proramme l'ayant enregistrer(pas de partage) mais ca évite API, registre et fichier, sinon bravo pour ce code ! Je trouve ca très utile.

Commentaire de CADRATURE le 21/09/2006 13:25:43

Super

Commentaire de MadM@tt le 21/09/2006 19:07:16

Ah ouais mais dans ce cas ça crée un problème de sécurité la non ?
car soit y'a moyen de récupérer le mot de passe et le login,soit il s'agit d'une variable boolean genre true : loggé, false : pas loggé, mais dans ce cas y'a surement aussi moyen de récupérer sa valeur et de la modifier ? (c'est une question lol)

Commentaire de bouv le 21/09/2006 20:57:58

ASIMENGO>>Il faut connaitre la valeur affectée à MAPKEY pour lire les valeurs. Si tu changes pour
Private Const MAPKEY As String = "MonLogiciel"
Seul celui qui cherche avec la valeur 'MonLogiciel' pourra lire ces données.

MADM@TT>>Renfield à dernièrement ajouté une fonction de cryptage des données pour mieux sécuriser le procédé.

Commentaire de Renfield le 22/09/2006 03:54:34 administrateur CS

on peux même en ouvrir un autre (un autre 'MAPKEY')
en utilisant la méthode Load....

reste que quelque soit son nom, en espionnant le logiciel, les APIs utilisées, etc, on pourras toujours trouver que le logiciel ouvre un File mapping (et même en obtenir le contenu).

comme le précise bouv, en ajoutant un Password (par le biai de la propriété du même nom), les données sont cryptées dans le file Mapping.
sans ce Password lors de la lecture...

Commentaire de Renfield le 22/09/2006 10:43:57 administrateur CS

non...
si toutes les instances de la classe ShareValues sont coupées, on perds les infos...

vous pouvez sauvegarder le Stream, et de le restaurer a votre guise

Commentaire de violent_ken le 22/09/2006 13:14:53

MAYZZ ==> Ok ;) Mais la méthode du SaveSettings (pour des sauvegardes temporaires) est quand même assez mauvaise (ajout de clés pas forcément utiles).
@+

Commentaire de asimengo le 22/09/2006 19:16:55

@Renfield: ça te dirais t'ajouter des fonctions d'enregistrement/restauration du Stream? en espérant que ses infos soient illisibles dans le fichier.

Commentaire de Renfield le 02/07/2008 15:20:53 administrateur CS

version .NET :  (pas forcément optimale, hein, je tatonne ^^)
mais ca fonctionne...

Imports System.Runtime.InteropServices

Public Class SharedValues
    ' Pour que plusieurs programmes puissent échanger ces valeurs, il suffit de modifier la clé ci dessous :
    Private Const MAPKEY As String = "SharedValues"
    ' Taille du tampon (8 Ko)
    Private Const MAPSIZE = &H2000&

    Private Const SECTION_MAP_READ As Integer = &H4
    Private Const SECTION_MAP_WRITE As Integer = &H2
    Private Const FILE_MAP_READ As Integer = SECTION_MAP_READ
    Private Const FILE_MAP_WRITE As Integer = SECTION_MAP_WRITE
    Private Const INVALID_HANDLE_VALUE As Integer = &HFFFFFFFF
    Private Const PAGE_READWRITE As Integer = &H4

    Private Declare Function CloseHandle Lib "kernel32.dll" (ByVal hObject As Integer) As Integer
    Private Declare Function CreateFileMapping Lib "kernel32.dll" Alias "CreateFileMappingA" (ByVal hFile As Integer, ByVal lpFileMappingAttributes As Integer, ByVal flProtect As Integer, ByVal dwMaximumSizeHigh As Integer, ByVal dwMaximumSizeLow As Integer, ByVal lpName As String) As Integer
    Private Declare Function MapViewOfFile Lib "kernel32.dll" (ByVal hFileMappingObject As Integer, ByVal dwDesiredAccess As Integer, ByVal dwFileOffsetHigh As Integer, ByVal dwFileOffsetLow As Integer, ByVal dwNumberOfBytesToMap As Integer) As Integer
    Private Declare Function OpenFileMapping Lib "kernel32.dll" Alias "OpenFileMappingA" (ByVal dwDesiredAccess As Integer, ByVal bInheritHandle As Integer, ByVal lpName As String) As Integer
    Private Declare Function UnmapViewOfFile Lib "kernel32.dll" (ByRef lpBaseAddress As IntPtr) As Integer
    Private Declare Sub ZeroMemory Lib "kernel32.dll" Alias "RtlZeroMemory" (ByVal Destination As IntPtr, ByVal Length As Integer)

    Private mhMap As Integer
    Private msName As String
    Private mnSize As Integer

    Public ReadOnly Property Name() As String
        Get
            Name = msName
        End Get
    End Property

    Public ReadOnly Property Size() As Integer
        Get
            Size = mnSize
        End Get
    End Property

    Public Sub New()
        Load(MAPKEY, MAPSIZE)
    End Sub

    Public Sub New(ByRef vsName As String)
        Load(vsName, MAPSIZE)
    End Sub

    Public Sub New(ByVal vnSize As Integer)
        Load(MAPKEY, vnSize)
    End Sub

    ' Cette méthode permet de changer de mappage, ou de changer la taille de celui-ci...
    Public Sub New(ByRef vsName As String, ByVal vnSize As Integer)
        Load(vsName, vnSize)
    End Sub

    Private Sub Load(ByRef vsName As String, ByVal vnSize As Integer)
        Dim pMem As IntPtr
        ' Si un mappage est ouvert, on le ferme...
        If mhMap Then
            CloseHandle(mhMap)
        End If

        ' On enregistre le nom du mappage
        msName = vsName
        ' Et on tente d'ouvrir le mappage
        mhMap = OpenFileMapping(FILE_MAP_READ Or FILE_MAP_WRITE, 0, msName)
        If mhMap = 0 Then
            ' Le mappage n'existe pas ?
            ' Nous allons donc le créer. Il aura la taille demandée par l'utilisateur.
            mnSize = vnSize
            ' Création du mappage
            mhMap = CreateFileMapping(INVALID_HANDLE_VALUE, 0, PAGE_READWRITE, 0, mnSize, msName)
            If mhMap Then
                ' Le premier Integer dans le fichier sera la taille du mappage.
                ' Tout le reste est remplit par des 0
                pMem = MapViewOfFile(mhMap, FILE_MAP_WRITE, 0, 0, 0)
                If pMem Then
                    Marshal.WriteInt32(pMem, 0, mnSize)
                    ZeroMemory(New IntPtr(pMem.ToInt32 + 4), mnSize - 4)
                    UnmapViewOfFile(pMem)
                End If
            End If
        Else
            ' Le mappage existe déjà. Nous lisons la taille de celui-ci
            pMem = MapViewOfFile(mhMap, FILE_MAP_READ, 0, 0, 0)
            If pMem Then
                mnSize = Marshal.ReadInt32(pMem, 0)
                UnmapViewOfFile(pMem)
            End If
        End If
    End Sub

    Public Sub Unload()
        ' Fermeture du mappage
        If mhMap Then
            CloseHandle(mhMap)
            mhMap = 0
        End If
    End Sub

    ' Permet de récupérer une valeur en particulier du Stream.
    Public Property Value(ByVal vsName As String) As String
        Get
            Value = vbNullString
            Try
                For Each sPair As String In Stream.Split(vbNullChar)
                    If sPair.StartsWith(vsName & "=") Then
                        Value = sPair.Substring(vsName.Length + 1)
                        Exit For
                    End If
                Next sPair
            Catch e As NullReferenceException
            End Try
        End Get
        Set(ByVal value As String)
            Try
                Dim xsParts() As String = Stream.Split(vbNullChar)
                For i As Integer = 0 To xsParts.GetUpperBound(0)
                    If xsParts(i).StartsWith(vsName & "=") Then
                        ' Sinon, on modifie l'élement de notre tableau
                        xsParts(i) = vsName & "=" & value
                        ' Et on reconstruit le Stream
                        Stream = Join(xsParts, vbNullChar)
                        Exit Property
                    End If
                Next i
                Stream = Join(xsParts, vbNullChar) & vbNullChar & vsName & "=" & value
            Catch e As NullReferenceException
                Stream = vsName & "=" & value
            End Try
        End Set
    End Property

    ' Permet de récupérer le Stream enregistré dans le mapping
    Public Property Stream() As String
        Get
            Dim pMem As IntPtr

            Stream = vbNullString
            pMem = MapViewOfFile(mhMap, FILE_MAP_READ, 0, 0, 0)
            If pMem Then
                ' On récupère la taille effective des données
                Dim nLength As Integer = Marshal.ReadInt32(pMem, 4)
                If nLength > 0 Then
                    Dim xbData As Char() = New String(" ", nLength).ToCharArray
                    Marshal.Copy(New IntPtr(pMem.ToInt32 + 8), xbData, 0, nLength)
                    Stream = New String(xbData, 0, nLength)
                End If
                UnmapViewOfFile(pMem)
            End If
        End Get
        Set(ByVal value As String)
            Dim pMem As IntPtr
            pMem = MapViewOfFile(mhMap, FILE_MAP_WRITE, 0, 0, 0)
            If pMem Then
                Dim xbData As Char() = value.ToCharArray
                ' On regarde si le mapping est assez grand pour contenir les données
                If xbData.Length < mnSize Then
                    ' Tous les autres bits sont remis à 0
                    ZeroMemory(New IntPtr(pMem.ToInt32 + 8 + xbData.Length), mnSize - 8 - xbData.Length)
                    ' On ajoute la taille des données en début de mapping (après la taille du mapping)
                    Marshal.WriteInt32(pMem, 4, xbData.Length)
                    ' Et, s'il y a des données, on les ajoutes dans le mapping
                    If xbData.Length > 0 Then
                        Marshal.Copy(xbData, 0, New IntPtr(pMem.ToInt32 + 8), xbData.Length)
                    End If
                End If
                UnmapViewOfFile(pMem)
            End If
        End Set
    End Property
End Class

Commentaire de Renfield le 03/12/2009 15:23:14 administrateur CS

GROSSE mise a jour, la classe se tourne davantage vers une communication inter-process complète, avec la possibilité de propager des evènements personnalisés dans toutes les isntances de la classe

Commentaire de bouv le 04/12/2009 16:16:33

Merci pour la version .Net je vais essayer

++

Commentaire de bouv le 04/12/2009 16:36:17

Tu l'as dit bouffi... le subclassing en .Net est un vrai bonheur comme beaucoup d'autres choses. Si bien que je n'utilise plus du tout VB6 (même pas installé).
++

Commentaire de Renfield le 04/12/2009 19:01:40 administrateur CS

a noter qu'il vaut mieux personnaliser (GUID ?) les mots en clair (passés a RegisterWindowMessage et le MAPKEY)

Commentaire de DarkVader le 14/12/2009 12:26:33

Bonjour
C'est superbe Renfield - que du bonheur dans cette source,
qui en plus est distribuée sous VB6 et VB.net.

Commentaire de bouv le 14/12/2009 15:05:22

Dans le cadre de mon logiciel de GED.

Lors de la consultation d'une archive, aujourd'hui je dois :
- extraire le stream de la BDD
- le placer dans un fichier temporaire
- ouvrir le fichier
- surveiller sa fermeture
- supprimer le fichier du disque

Cette opération me ferait gagner un temps précieux en économisant les accès disque.

Commentaire de Renfield le 17/12/2009 12:19:57 administrateur CS

Bonne remarque, correction adaptée....

je repiques l'idée et mets a jour rapidement

Commentaire de DarkVader le 17/12/2009 12:33:29

Si beaucoup ne s'exprime en général pas ,
le nombre de téléchargement est tout de même la preuve que ta source ne laisse pas indifférent. 8)

Commentaire de DarkVader le 28/12/2009 18:20:37

Un blem mineur dans l'actualisation des données, pour peu que plusieurs écriture/lecture de données soient alternées

ex
[code]Private WithEvents classIP As InterProcess

Private Sub Class_Initialize()
    Set classIP = New InterProcess
    
    With classIP
        printVar classIP
    
        .VarValue("Var1") = "test3"
        printVar classIP
        
        .VarValue("Var2") = "True4"
        printVar classIP
    End With
End Sub

Private Sub Class_Terminate()
    Set classIP = Nothing
End Sub


    Private Sub classIP_Changed(ByVal vnIndex As Long)
         Debug.Print " --- classIP_Changed(ByVal " & vnIndex & " As Long): " & classIP.VarName(vnIndex) & " => " & classIP.VarValue(vnIndex)
    End Sub

    Private Sub printVar(oClass As Object)
        Dim x As Long
        
        With oClass
            Debug.Print String(13, "=") & " " & .VarCount & " " & String(13, "=") & vbCrLf
            For x = 0 To .VarCount - 1
                Debug.Print x, .VarName(x), .VarValue(x)
            Next
        End With
        Debug.Print String(30, "-") & vbCrLf
    End Sub[/code]
Résultat inattendu !
Un simple doevents placé après le Postmessage HWND_BROADCAST résoud le problème. 8)

Bonnes fêtes de fin d'année.

Commentaire de rvs76 le 29/03/2011 15:50:22

Bonjour,

Je déterre un peu ce code en espérant qu'on me réponde.
Voila, j'ai trois applis (indépendantes) en VB.NET avec des base de données qui contiennent des données proches et/ou complémentaires. J'ai créé une quatrième appli qui contient une autre bdd avec juste les mappages des trois autres bases ainsi que plusieurs fenêtres.
J'utilise cette source légèrement modifié afin d'avoir trois noms différents de fichier virtuel et trois objet IP dans la quatrième appli.

           Appli_1
             |
             |tuyau_1
             |
           Appli_4
           /     \
   tuyau_2/       \tuyau_3
         /         \
     Appli_2      Appli_3

Chaque "tuyau" est bien isolé, mais le problème est que les évènements StreamChanged qui se mélangent dans la quatrième appli. Par exemple, si du texte est envoyé de l'appli_1 vers l'appli_4, c'est le tuyau_3 qui déclenche l'évènement StreamChanged dans l'appli_4 (dernier tuyau créé ?) mais le stream du tuyau_3 est vide.
Si quelqu'un peut m'aider...

Commentaire de LaTatadu91 le 09/02/2012 16:14:34

Très bon code! Il me sera très utile ... une fois traduit en C++ !