?
Hi, das habe ich gestern schon versucht zu posten... Aber es war ja wieder mal kein Zugriff möglich....
Ich hab' dazu folgendes gefunden (allerdings bin ich mir nicht sicher ober das nur mit MFC funktioniert):
Du musst wie folgt vorgehen: 1. Definiere Dir einen eigenen Datentypen, welchen Du in den shared Memory halten willst, z.B.:
typedef struct structSHM_
{
TCHAR szMyString[256];
} STRUCTSHM, *PSTRUCTSHM;
2. Definiere folgende zwei globale Variablen in Deiner DLL:
// globale Variablen
HANDLE hMapping = NULL;
PSTRUCTSHM pSHM;
3. Nun erstellst Du ein FileMapping-Object in der DllMain-Methode im Bereich "case DLL_PROCESS_ATTACH:", wie folgt:
// Create a file mapping object.
SECURITY_ATTRIBUTES secAttr;
SECURITY_DESCRIPTOR sid; InitializeSecurityDescriptor(&sid, SECURITY_DESCRIPTOR_REVISION);
SetSecurityDescriptorDacl(&sid, TRUE, NULL, FALSE); secAttr.nLength=sizeof(SECURITY_ATTRIBUTES);
secAttr.lpSecurityDescriptor=&sid;
secAttr.bInheritHandle=TRUE; hMapping = ::CreateFileMapping ((HANDLE) INVALID_HANDLE_VALUE,
&secAttr,
PAGE_READWRITE,
0,
sizeof(STRUCTSHM),
SHMNAME);
if (hMapping == NULL || hMapping == INVALID_HANDLE_VALUE)
{
// Fehlermeldung ausgeben
return FALSE;
} // Convert the handle into a pointer.
pSHM = (PSTRUCTSHM) ::MapViewOfFile (hMapping, FILE_MAP_ALL_ACCESS, 0, 0, 0); if (pSHM == NULL)
{
// Fehlermeldung ausgeben ::CloseHandle (hMapping);
return FALSE;
}
4. In der DLLMain-Methode im Abschnitt "case DLL_PROCESS_DETACH:" kann der SharedMemory wieder geschlossen werden (wird aufgerufen, wenn kein Prozess mehr einen verweis auf die DLL hat):
if (pSHM)
{
::UnmapViewOfFile (pSHM);
pSHM = NULL;
}
if (hMapping)
{
::CloseHandle (hMapping);
hMapping = NULL;
}
5. In der .def-Datei Deines DLL-Projektes musst Du nun noch den folgenden Eintrag hinzufügen:
SECTIONS
.sdata READ WRITE SHARED
Das wars. Nun kannst Du Daten aus verschiedenen Prozessen, welche Deine DLL laden über den definierten Shared-Memory-Bereich austauschen. Du solltest aber deine DLL Multithreading-fähig programmieren, so dass sich verschiedene Prozesse untereinander nicht ungewollt beeinflussen.