Protezione dei dati isostorage condivisi tra l'app e l'agente di background

Question

In base alla comunicazione MSDN tra l'app in primo piano e gli agenti in background tramite file in una memoria isolata devono essere protetti da un Mutex.

L'unico articolo che posso trovare che descrive come fare questo è this one di Dina Berry. Tuttavia, sembra solo proteggere le letture con il Mutex e non con le scritture.

Qual è il modo corretto per farlo?

Answer 1

Un mutex può bloccare su più processi. Ciò sarebbe utile in Windows Phone se è in esecuzione un'attività pianificata che richiede l'accesso esclusivo a una risorsa. Per bloccare un mutex tra i processi, al Mutex deve essere assegnato un nome.

Un monitor può bloccare solo all'interno di un processo.

Mutex Esempio:

Telefono App Task:

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

Scheduled classe Task:

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(); 
    } 
} 

Nel precedente esempio stiamo consentendo solo un app in un tempo di accesso al risorsa del database locale. Questo è il motivo per cui utilizzeremmo un Mutex.

Monitor Esempio (utilizzando la sintassi di blocco):

Telefono App Task:

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

Scheduled classe Task:

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

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

In questo esempio si può fermare più di un thread entrante applicazione SaveRow e possiamo interrompere più di un thread ScheduledTask dall'accesso al metodo DoStuff. Quello che non possiamo fare con un Monitor è assicurarsi che solo un thread stia accedendo al DB locale in una volta.

Questa è fondamentalmente la differenza. Il monitor è molto più veloce di un Mutex.