1. Inicio
  2. Pregunta y respuesta
  3. ¿Cómo implementar memoria compartida en .NET?

¿Cómo implementar memoria compartida en .NET?

2009-01-13 20 views

Respuesta

6

Existen varias opciones para comunicarse con sus aplicaciones. Los más populares son Remoting y Pipes. Hay varios ejemplos para ambos y, antes de elegir uno, debe considerar los pros y los contras, como la portabilidad. Aquí hay algunos enlaces útiles:

Inter-Process Communication in .NET Using Named Pipes, Part 1

Inter-Process Communication in .NET Using Named Pipes, Part 2

.NET Remoting in Simple English

.NET Remoting with an easy example

Fuente

2009-01-13 17:10:02 Diadistis

+4

Es una gran respuesta y todo, pero la pregunta era sobre la memoria compartida. –

3

se comparte la memoria la única opción? Hay muchas maneras para comunicarse con dos procesos .NET. Algunos de ellos son:

  • .NET Objeto Remoto - Permite que los objetos interactúen entre ellos en los procesos. Hay una buena muestra de código here
  • Microsoft Message Queue (MSMQ) - Una cola de mensajes compartidos entre procesos. MSMQ se ejecutará como otro servicio de Windows.

Fuente

2009-01-13 17:11:04 Gant

1

Supongo que .NET v2.0 no tiene compatibilidad incorporada para la memoria compartida. Como máximo, podemos invocar las API CreateFileMapping y MapViewOfFile.

En mi caso, el IPC debe tener lugar en una sola máquina. Entonces, las tuberías son la opción más rápida a partir de ahora.

Gracias por las respuestas

Fuente

2009-01-13 18:31:14

13

Actualización: Hola, acabo de here's a page encontraron con un implmentation compleate.

Usando C++/CLI, es bastante fácil de memoria compartida configuración según API normal de C++ (C++/CLI ser capaz de interactuar con las referencias administrada y nativa PAFH/memoria). El UnmanagedMemoryStream se puede usar para exponer un objeto Stream a C#.

No adjunté el archivo .h, pero puede inferir bastante fácilmente el diseño del typedef nativo pmapped;). También es posible que desee evaluar el posible uso de un BufferedStream en función de su caso de uso de lector/escritor. Y el código es de un proyecto que ya no uso, así que no puedo recordar el estado de la regresión de errores.

Aquí está la clase C++/CLI que establece una asignación de archivos y expone un UnmanagedMemoryStream;

public ref class MemMapp 
{ 
    public: 
     __clrcall MemMapp(String^ file) 
     { 
      map = NULL; 

      if(!File::Exists(file)) throw gcnew ApplicationException("Can not find file " + file); 

      marshal_context^ x = gcnew marshal_context(); 
      const char *nname = x->marshal_as<const char*>(file); 

      map = (pmapped) malloc(sizeof(mapped)); 
      ZeroMemory(map, sizeof(mapped)); 
      map->name = strdup(nname); 
      InitMap(map); 
     } 
     void __clrcall MapBytes(long long loc, long length) 
     { 
      map->low = loc & 0xffffffff; 
      map->high = (loc >> 32) & 0xffffffff; 
      map->size = length & 0xffffffff; 
      if(!GetMapForFile(map)) 
       throw gcnew ApplicationException("can not map range " + loc + " :" + length); 

      if(map->size = 0) 
       map->size = MAXMAX&0xffffffff; 

     } 
     UnmanagedMemoryStream ^View() 
     { 
      return gcnew UnmanagedMemoryStream((unsigned char *) map->blok, map->size, map->size, FileAccess::Read); 
     } 
     long long __clrcall FileSize() 
     { 
      DWORD high, low; 
      long long rv; 

      low = GetFileSize(map->hFile, &high); 
      maxmax = high; 
      maxmax << 32; 
      maxmax += low; 

      rv = high; 
      rv << 32; 
      rv = rv & low; 
      return rv; 
     } 
     property unsigned int MinBufSiz { unsigned int get() { return map->dwbufz; } } 
     property long long BufBase { long long get() { return (map->high << 32) + map->low; } } 
     property long long BufLim { long long get() { return ((map->high << 32) + map->low) + map->size; } } 
     property long long MAXMAX { long long get() { return maxmax; } } 
     static MemMapp() { } 
     __clrcall ~MemMapp() { if(map != NULL) { CloseMap(map); free(map->name); free(map); map = NULL; } } 
    protected: 
     __clrcall !MemMapp() { if(map != NULL) { CloseMap(map); free(map->name); free(map); map = NULL; } } 
     pmapped map; 
     long long maxmax; 
};

Aquí es CLoseMap al menos ... Me acabo de encontrar ...no fue compilado con/CLR

bool CloseMap(pmapped map) 
{ 
    if(map->blok != NULL) { 
     UnmapViewOfFile(map->blok); 
     map->blok = NULL; 
    } 
    if(map->hMap != INVALID_HANDLE_VALUE && map->hMap != NULL) { 
     CloseHandle(map->hMap); 
     map->hMap = INVALID_HANDLE_VALUE; 
    } 
    if(map->hFile != INVALID_HANDLE_VALUE && map->hFile != NULL) { 
     CloseHandle(map->hFile); 
     map->hFile = INVALID_HANDLE_VALUE; 
    } 
    return false; 
}

Fuente

2009-05-29 10:01:38 RandomNickName42

+2

+1 .net 4 tiene soporte para archivos mapeados en memoria http://msdn.microsoft.com/en-us/library/system.io.memorymappedfiles.aspx – kenny

3

También tiene una alternativa a C++/CLI como la importación de funciones de Win32 en su aplicación de C#:

[DllImport ("kernel32.dll", SetLastError = true)] 
    static extern IntPtr CreateFileMapping (IntPtr hFile, 
              int lpAttributes, 
              FileProtection flProtect, 
              uint dwMaximumSizeHigh, 
              uint dwMaximumSizeLow, 
              string lpName); 

    [DllImport ("kernel32.dll", SetLastError=true)] 
    static extern IntPtr OpenFileMapping (FileRights dwDesiredAccess, 
             bool bInheritHandle, 
             string lpName); 

    [DllImport ("kernel32.dll", SetLastError = true)] 
    static extern IntPtr MapViewOfFile (IntPtr hFileMappingObject, 
             FileRights dwDesiredAccess, 
             uint dwFileOffsetHigh, 
             uint dwFileOffsetLow, 
             uint dwNumberOfBytesToMap); 
    [DllImport ("Kernel32.dll")] 
    static extern bool UnmapViewOfFile (IntPtr map); 

    [DllImport ("kernel32.dll")] 
    static extern int CloseHandle (IntPtr hObject);

Fuente

2011-12-12 11:58:28 puikos

Cuestiones relacionadas

 Cuestiones relacionadas