Comment implémenter la mémoire partagée dans .NET?

Mise à jour: Hey, voici une page je viens de trouver un compleate de mise en oeuvre.

---

À l'aide de C++/CLI, il est très facile d'installation de la mémoire partagée, comme la normale API C++ C++/CLI être en mesure d'interagir avec les natifs et gérés TAS/références de mémoire). Le UnmanagedMemoryStream peut ensuite être utilisé pour exposer un objet de Flux de données en C#.

Je n'ai pas joindre les .h de fichier, mais vous pouvez en déduire le tracé de la pmapped natif typedef assez easially ;). Vous pouvez également évaluer la possibilité de l'utilisation d'un BufferedStream en fonction de votre lecteur/graveur de cas d'utilisation. Et le code est à partir d'un projet que je n'utilise plus donc je ne me souviens pas le statut de c'est un bogue de régression.

Voici le C++/CLI classe qui établit un fichier de mappage et expose une 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;
};

---

Voici CLoseMap au moins... je viens de le trouver... il n'a pas été compilé avec /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;
}

Est la mémoire partagée la seule option? Il existe de nombreuses façons pour les deux .NET aux processus de communiquer. Certains d'entre eux sont:

• .NET Remoting Objet - Permettre aux objets d'interagir les uns avec les autres à travers des processus. Il est un bon exemple de code ici
• MSMQ (Microsoft Message Queue), ce qui constitue UNE file d'attente de messages entre les processus. MSMQ sera exécutée comme un autre Service Windows.

Je suppose .NET v2.0 n'a pas de prise en charge intégrée de la mémoire partagée.
Tout au plus pouvons nous PInvoke la CreateFileMapping et MapViewOfFile Api.

Dans mon scénario, l'IPC doit avoir lieu sur une seule machine. Donc, pipes est l'option la plus rapide à partir de maintenant.

Merci pour les réponses