C# y C++ Sincronizar entre procesos

Question

Tenemos 2 aplicaciones. Uno escrito en C# y el otro en C++. Necesitamos mantener un contador (en memoria) compartido entre estos procesos. Cada vez que se inicia una de estas aplicaciones, es necesario verificar este contador y aumentarlo, y cada vez que se apaga la aplicación, debe disminuir el contador. Si la aplicación se bloquea o se cierra con el administrador de tareas, también necesitamos que el contador disminuya.
Pensamos utilizar uno de los objetos de sincronización de SO como MUTEX.
Mi pregunta: ¿Qué tipo de objeto de sincronización es el mejor para el proceso cruzado (cuando uno es C# y el otro C++)

Espero que mi pregunta sea clara.
Muchas gracias,

Adi Barda

Answer 1

Usted puede salirse con semáforo con nombre. Semáforo es básicamente un conteo, está aquí para permitir a los desarrolladores limitar el número de subprocesos/procesos que están accediendo a algún recurso. Por lo general, funciona de esa manera

1. Se crea un semáforo con la máxima N. recuento
2. N hilos función Llamada en espera en él, WaitForSingleObject o similar y cada uno de ellos van sin esperar. Cada vez que el contador interno de semáforos baja.
3. N + 1 hilo también llama a la función de espera pero debido a que el contador interno de nuestro semáforo ahora es 0, tiene que esperar.
4. Uno de nuestros primeros N subprocesos libera el semáforo llamando a la función ReleaseSemaphore. Esta función incrementa el contador interno del semáforo.
5. Nuestro hilo de espera no tienen que esperar ahora, por lo que se reanuda pero semáforo contador vuelve a 0.

No creo que esta es la forma en que desea utilizar sin embargo. Por lo tanto, en su lugar, debe:

1. Cree el semáforo con nombre con el contador inicial establecido en cero.
2. Cuando se inicia la aplicación, suéltelo de inmediato, aumentando el contador. Obtendrás el valor del contador anterior durante esa llamada.
3. Cuando la aplicación finaliza, llame al WaitForSingleObject(hSemaphore, 0), disminuyendo el contador. 0 significa que no quiere esperar.

Esto es todo bastante fácil.

En C++

//create semaphore 
HANDLER hSemaphore = CreateSemaphore(NULL, 0, BIG_NUMBER, "My cool semaphore name"); 
//increase counter 
LONG prev_counter; 
ReleaseSemaphore(hSemaphore, 1, &prev_counter); 
//decrease counter 
WaitForSingleObject(hSemaphore, 0); 

En C#

using System.Threading; 
//create semaphore 
Semaphore sem = new Semaphore(0, BIG_NUMBER, "My cool semaphore name"); 
//increase counter 
int prev_counter = sem.Release(); 
//decrease counter 
sem.WaitOne(0); 

Nombres y BIG_NUMBERs debe ser el mismo, obviamente.

Si esto no es suficiente para su tarea, tendrá que buscar en la memoria compartida y bloquear el acceso a ella a través del nombre mutex, pero eso es un poco más complicado.

Answer 2

parece que necesita un semáforo con nombre (CreateSemaphore): http://msdn.microsoft.com/en-us/library/ms682438(VS.85).aspx para C++, que es adecuado para el incremento/decremento.

En C# tiene la clase System.Threading.Semaphore.

Answer 3

Eche un vistazo a this thread para los métodos para compartir algo de memoria con fines de sincronización o here para algunas sugerencias de sincronización en .net/C#.

Si hay métodos .net disponibles, es conveniente trabajar tanto para C++ y C# ..