Proteger los datos del almacenamiento compartido entre la aplicación y el agente de fondo

Question

De acuerdo con MSDN la comunicación entre la aplicación en primer plano y los agentes de fondo a través de archivos en almacenamiento aislado debe estar protegida por un Mutex.

El único artículo que puedo encontrar que describe cómo hacer esto es this one de Dina Berry. Sin embargo, ella solo parece proteger las lecturas con el Mutex y no con las escrituras.

¿Cuál es la forma correcta de hacerlo?

Answer 1

Un mutex puede bloquearse en múltiples procesos. Esto sería útil en Windows Phone si tiene una tarea programada en ejecución que necesita acceso exclusivo a un recurso. Para bloquear un mutex en todos los procesos, se debe dar un nombre a Mutex.

Un monitor puede bloquearse solo dentro de un proceso.

objeto mutex Ejemplo:

Phone App Tarea:

public class DatabaseService 
{ 
    private Mutex _mut=new Mutex("mutex control",false); 
    public void AddToDatabase(DbObject row) 
    { 
    mut.WaitOne(); 
    SaveRow(row); 
    mut.ReleaseMutex(); 
    } 
} 

clase de tarea programada:

public class ResourceUtilisation 
{ 
    private Mutex _mut=new Mutex("mutex control",true); 
    //.. does stuff 
    private static void UseResource() 
    { 
    // Wait until it is safe to enter. 
    _mut.WaitOne(); 

    //Go get dataabse and add some rows 
    DoStuff(); 

    // Release the Mutex. 
    _mut.ReleaseMutex(); 
    } 
} 

En el ejemplo anterior sólo estamos permitiendo una aplicación a la vez el acceso a la recurso de base de datos local. Es por eso que usaríamos un Mutex.

Ejemplo monitor (utilizando la sintaxis de bloqueo):

Teléfono App Tarea:

public class DatabaseService 
{ 
    private object _locker=new object(); 
    public void AddToDatabase(DbObject row) 
    { 
    lock(_locker) 
     SaveRow(row); 
    } 
} 

clase tarea programada:

public class ResourceUtilisation 
{ 
    private object _locker=new object(); 
    //.. does stuff 
    private static void UseResource() 
    { 

    //Go get dataabse and add some rows 
    lock(_locker) 
     DoStuff(); 
    } 
} 

En este ejemplo podemos detener más de una entrada subproceso de la aplicación SaveRow y podemos evitar que más de un hilo de ScheduledTask ingrese el método DoStuff. Lo que no podemos hacer con un Monitor es garantizar que solo un hilo acceda al DB local de una vez.

Esa es básicamente la diferencia. El monitor es mucho más rápido que un Mutex también.