SetEventData和GetEventData在WinXP的解决方案

//=====================================================================
//TITLE:
// SetEventData和GetEventData在WinXP的解决方案
//AUTHOR:
// norains
//DATE:
// Tuesday 16-March-2010
//Environment:
// WINDOWS XP
//=====================================================================

如果你熟悉于WinCE开发，又经常通过SetEventData和GetEventData在进程间传递数据，那么当你想将代码移植到WinXP平台，将会遇到一个十分尴尬的问题：Win32 API根本就没有这两个函数！当然，如果你是采用.net框架，那么这不是问题，这里本文不做讨论。

回到原点，我们来想想这两个函数的功能。我们可以这么认为，SetEventData是将DWORD数值和事件句柄相关联，而GetEventData则是将关联的数据取出。这些数据，是可以在不同的进程中共享的。

　　这个是不是和内存映射文件有几分类似？既然Win32 API没有这个函数，那么我们就手动来创建！
　　
　　由于事件句柄是与数值相关联地，从算法的简便性考虑，我们可以使用STL::map进行存储，这样可以大大降低我们的工作量。另一方面，因为我们在做映射文件时，有一些信息我们只能通过CreateEvent获取，故我们只能采用类的方式，将这几个函数重载。为描述简便，这个类我们声明为CMUF。
　　
　　先从头开始，我们看看重载的CreateEvent函数。其中的一些要点，我采用注释的方式列于代码中，方便于查看。
　　

HANDLE CMUF::CreateEvent(LPSECURITY_ATTRIBUTES lpEventAttributes,BOOL bManualReset,BOOL bInitialState,LPCTSTR lpName)
{
 BOOL bRes = FALSE;

 //调用原生的API函数创建事件.
 HANDLE hEvent = ::CreateEvent(lpEventAttributes,bManualReset,bInitialState,lpName);
 if(hEvent == NULL)
 {
  //如果创建失败，跳转到EXIT
  goto EXIT;
 }

 //先判断当前创建的这个事件是否已经被创建，以方便后续数据的处理。.
 BOOL bIsExisting = (GetLastError() == ERROR_ALREADY_EXISTS);
 
 if(bIsExisting == FALSE)
 {  
  //这是一个新的的事件
  TSTRING strMemFile;

  //先判断这个类是否只是内部使用。所谓的内部使用，指的是没有名字的事件，除了通过句柄来进行使用以外，无法通过再次打开获得。
  if(lpName != NULL)
  {
   //因为内存映射文件和事件名是同一个命名空间，所以这两者的名字不能相同。故我们要创建的内存映射文件名为：EVENT_前缀 + 事件名。
   strMemFile = TEXT("EVENT_");
   strMemFile += lpName;
  }
  else
  {
   //如果该事件为内部使用，那么也就意味着这内存映射文件也是内部使用。故采用程序句柄的名字+事件名的方式进行内存映射文件的名字确定。
   TSTRINGSTREAM stream;
   stream << GetModuleHandle(NULL) << TEXT("_") << hEvent;
   strMemFile = stream.str();
  }

  //通过调用InitMemFile来创建内存映射文件
  MemFile memFile;
  if(InitMemFile(strMemFile,sizeof(DWORD),memFile) == FALSE)
  {
   goto EXIT;
  }

  //ms_mpEventHandleToName和ms_mpEventNameToFile是类的静态成员，用来存储事件和映射文件的对应关系。
  if(lpName != NULL)
  {
   ms_mpEventHandleToName.insert(std::make_pair(hEvent,lpName));
   ms_mpEventNameToFile.insert(std::make_pair(lpName,memFile));
  }
  else
  {
   //因为内部使用的事件没有名字，所以采用组合的名字作为标识
   ms_mpEventHandleToName.insert(std::make_pair(hEvent,strMemFile));
   ms_mpEventNameToFile.insert(std::make_pair(strMemFile,memFile));
  }
 
 }
 else
 {
  //系统判断以该名字命名的事件已经被创建过，所以我们先搜索我们的数据库是否有相应的记录。
  std::map<HANDLE,TSTRING>::iterator iterName = std::find_if(ms_mpEventHandleToName.begin(),ms_mpEventHandleToName.end(),Functor::value_equal<HANDLE,TSTRING>(lpName));
  if(iterName == ms_mpEventHandleToName.end())
  {
   ASSERT(FALSE);

   goto EXIT;
  }


  std::map<TSTRING,MemFile>::iterator iterFile = ms_mpEventNameToFile.find(iterName->second);
  if(iterFile == ms_mpEventNameToFile.end())
  {
   ASSERT(FALSE);

   goto EXIT;
  }

  //找到相应记录的话，则将记数加1
  InterlockedIncrement(reinterpret_cast<LONG *>(&iterFile->second.dwCount));

  //即使该名字命名的事件之前已经使用，但第二次创建时，句柄还是不同的，所以我们必须将其保存
  ms_mpEventHandleToName.insert(std::make_pair(hEvent,lpName));
 }

 bRes = TRUE;

EXIT:
 
 if(bRes == FALSE)
 {
  CloseHandle(hEvent);
 }

 return hEvent;
 
     }
　　

　　这个函数有两个静态成员变量，在头文件中是这么声明的：
　　

class CMUF
{
private:
 struct MemFile
 {   
  HANDLE hFileMap;
  HANDLE pMapBuf;
  DWORD dwBufSize;
  DWORD dwCount;
 };

 static std::map<HANDLE,TSTRING> ms_mpEventHandleToName;
 static std::map<TSTRING,MemFile> ms_mpEventNameToFile;

};

　　

　　其中调用的InitMemFile函数如下：

BOOL CMUF::InitMemFile(const TSTRING &strMapName,DWORD dwSize,MemFile &memFile)
{

 //创建映射文件
 HANDLE hFileMap = CreateFileMapping(INVALID_HANDLE_VALUE,NULL,PAGE_READWRITE,0,dwSize,strMapName.c_str());
 if(hFileMap == NULL)
 {
  ASSERT(hFileMap != NULL);
  return FALSE;
 }

 //从映射文件句柄获得分配的内存空间
 VOID *pMapBuf = MapViewOfFile(hFileMap,FILE_MAP_ALL_ACCESS,0,0,0); 
 if(pMapBuf == NULL)
 {
  ASSERT(FALSE);
  CloseHandle(hFileMap);
  return FALSE;
 }

 //将内存中的数值设置为0
 DWORD dwData = 0;
 memcpy(pMapBuf,&dwData,dwSize);

 //将数值保存到结构体中
 memFile.hFileMap = hFileMap;
 memFile.pMapBuf = pMapBuf;
 memFile.dwBufSize = dwSize;
 memFile.dwCount = 1;

 return TRUE;
     }
　　

　　
　　和CreaetEvent相对应，我们来看看CloseHandle函数：
　　

BOOL CMUF::CloseHandle(HANDLE hObject)
{
 if(hObject == NULL)
 {
  return FALSE;
 }

 //查找所关闭的句柄是否存在于记录里. 
 std::map<HANDLE,TSTRING>::iterator iterName = ms_mpEventHandleToName.find(hObject);
 if(iterName != ms_mpEventHandleToName.end())
 {

  std::map<TSTRING,MemFile>::iterator iterFile = ms_mpEventNameToFile.find(iterName->second);
  if(iterFile != ms_mpEventNameToFile.end())
  { 
   //找到记录，数目减一
   InterlockedDecrement(reinterpret_cast<LONG *>(&iterFile->second.dwCount));

   
   if(iterFile->second.dwCount == 0)
   {
    //如果记数为零，则删掉映射文件.

    UnmapViewOfFile(iterFile->second.pMapBuf);
    ::CloseHandle(iterFile->second.hFileMap);
    ms_mpEventNameToFile.erase(iterFile);
   }
  }

  ms_mpEventHandleToName.erase(iterName);
 }

 //调用API函数进行真正的关闭。
 return ::CloseHandle(hObject);
     }
　　

　　创建和关闭就是这么简单，并不算复杂。在请出今天的主角之前，我们先来看看一个主角们都会利用到的武器，也就是GetMemFile函数，它用来获取和事件句柄有关的内存映射文件信息。
　　
　　函数很短，很简单：
　　

BOOL CMUF::GetMemFile(HANDLE hEvent,MemFile &memFile)
{
 if(hEvent == NULL)
 {
  return FALSE;
 }

 //根据句柄查找命名
 std::map<HANDLE,TSTRING>::iterator iterEvent = ms_mpEventHandleToName.find(hEvent);
 if(iterEvent == ms_mpEventHandleToName.end())
 {
  return FALSE;
 }

 //根据命名来查找映射文件信息
 std::map<TSTRING,MemFile>::iterator iterMem = ms_mpEventNameToFile.find(iterEvent->second);
 if(iterMem == ms_mpEventNameToFile.end())
 {
  return FALSE;
 }

 //将记录文件中的信息保存到输出变量缓存中。
 memFile = iterMem->second;

 return TRUE;
     }
　　

　　有了这个GetMemFile函数以后，那么SetEventData和GetEventData就简单了，甚至可以说，显得非常单薄，似乎和本文主角的光环搭不上边。但，我们所要求的，只是功能。:)
　　
　　好吧，我们让本文的两个主角一起闪亮登场吧：
　　

BOOL CMUF::SetEventData(HANDLE hEvent,DWORD dwData)
{
 MemFile memFile;
 if(GetMemFile(hEvent,memFile) == FALSE || memFile.pMapBuf == NULL)
 {
  return FALSE;
 }

 //将数值拷贝到内存中
 memcpy(memFile.pMapBuf,&dwData,memFile.dwBufSize);

 return TRUE;
}

DWORD CMUF::GetEventData(HANDLE hEvent)
{
 MemFile memFile;
 if(GetMemFile(hEvent,memFile) == FALSE || memFile.pMapBuf == NULL)
 {
  return 0;
 }

 //从内存中获取DWORD数据
 DWORD dwVal = 0;
 memcpy(&dwVal,memFile.pMapBuf,memFile.dwBufSize);

 return dwVal;
}
　　

　　OK，就这么简单，我们所需要做的，就是这些。
　　
　　最后的最后，我们来看看如何调用我们文中所列的函数。因为这些函数都是被声明为static ，并且访问权限是public，所以我们可以直接加上CMUF::前缀进行访问，比如：CMUF::SetEventData。
　　
　　当然，如果你的代码是以类为组织方式，那么就更简单了，直接继承于CMUF即可。