Usare la Shared Memory

Ci sono molti metodi per mettere in comunicazione due processi, ma spesso basta condividere alcune informazioni...

A seconda della quantità e complessità delle informazioni da scambiare tra processi, è possibile utilizzare diversi meccanismi, standard e non, di tipo IPC (Inter Process Comunication) come, ad esempio COM, CORBA o WFC.

Quando i processi vengono eseguiti sulla stessa macchina, è possibile utilizzare un sistema molto semplice ed efficiente basato sulla condivisione di un'area di memoria: il primo processo che verrà eseguito allocherà la memoria ed il secondo sarà in grado di "aprire" la stessa area sia in lettura che scrittura.

La Classe che segue semplifica l'utilizzo di questo "antico", ma sempre valido sistema di scambio dati.

SharedMem.h

#ifndef __SHAREDMEM_H
#define __SHAREDMEM_H

#if _MSC_VER >= 1000
#pragma once
#endif // _MSC_VER >= 1000

class CSharedMem
{
protected:
  HANDLE m_hSharedMemoryFile;
  void* m_pwData;

  DWORD dwMaximumSizeHigh; 
  DWORD dwMaximumSizeLow;
  DWORD dwNumberOfBytesToMap;
  BOOL  m_bInit;
  BOOL  m_bAlreadyExist;

  CString csMutexName;
  HANDLE m_hMutex;

public:
  CString csName; 

public:
  CSharedMem();
  CSharedMem(LPCSTR cs, int size);
  ~CSharedMem();

public:
  BOOL Init(LPCSTR cs, int size);
  BOOL Init(int size );

  BOOL AlreadyExist();
  BOOL Lock(DWORD dwMilliSec = INFINITE);
  BOOL Unlock();
   
  void* Buffer();
};

#endif

SharedMem.cpp

#include "stdafx.h"
#include "SharedMem.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif


CSharedMem::CSharedMem()
{
  csName = _T("");
  m_bInit = FALSE;
  m_bAlreadyExist = FALSE;
  csMutexName = "Mutex";
}

CSharedMem::CSharedMem(LPCSTR cs, int size)
{
  m_bAlreadyExist = FALSE;
  Init(cs, size);
}

CSharedMem::~CSharedMem()
{
  if (m_bInit)
  {
    UnmapViewOfFile(m_pwData);
    CloseHandle(m_hSharedMemoryFile);
  }
}

BOOL CSharedMem::Init(LPCSTR cs, int size)
{
  csName = cs;
  m_bAlreadyExist = FALSE;
  csMutexName = csName + "Mutex"; 
  return Init(size);
}

BOOL CSharedMem::Init(int size)
{
  m_hMutex = CreateMutex(NULL, FALSE, csMutexName);

  dwNumberOfBytesToMap = size;

  m_hSharedMemoryFile = CreateFileMapping((HANDLE)0xFFFFFFFF,
                                          NULL,
                                          PAGE_READWRITE,
                                          0,                     /*dwMaximumSizeHigh*/
                                          dwNumberOfBytesToMap,  /*dwMaximumSizeLow*/
                                          csName.GetBuffer(0));
  if(m_hSharedMemoryFile == NULL)
  {
    m_bAlreadyExist = FALSE;
    m_bInit = FALSE;
    return FALSE;
  }
  else
  {
    if(GetLastError() == ERROR_ALREADY_EXISTS)
      m_bAlreadyExist = TRUE;
  }

  m_pwData = MapViewOfFile(m_hSharedMemoryFile,
                           FILE_MAP_WRITE,
                           0,            /*dwFileOffsetHigh*/
                           0,            /*dwFileOffsetLow*/
                           dwNumberOfBytesToMap);
  if(m_pwData == NULL)
  {
    m_bInit = FALSE;
    CloseHandle(m_hSharedMemoryFile);
    return FALSE;
  }
  else
  {
    if (!m_bAlreadyExist)
      ZeroMemory(m_pwData, size);
    m_bInit = TRUE;
  }
  
  return TRUE;
}

BOOL CSharedMem::AlreadyExist()
{
  return m_bAlreadyExist;
}

BOOL CSharedMem::Lock(DWORD dwMilliSec)
{
  if (WaitForSingleObject(m_hMutex, dwMilliSec) == WAIT_OBJECT_0)
    return TRUE;

  return FALSE;
}

BOOL CSharedMem::Unlock()
{
  return ReleaseMutex(m_hMutex);
}

void* CSharedMem::Buffer()
{
  if (m_bInit)
    return m_pwData;
  else
    return NULL;
}

Tutte le Utility