Question

I’m writing a windows phone app which stores data in a local database. There are multiple threads in my app that access the database and up until this point I have used the technique described here with an AutoResetEvent to ensure that only one thread can access the database at any one time.

So far this has worked very reliably, but now I want to add a ScheduledTask to do some work in the background so I’ve potentially got multiple processes now competing for access to the database.

Can anyone advise how I can adapt the AutoResetEvent technique to be used across multiple processes on Windows Phone?

I have seen approaches using a Mutex. If I acquire the Mutex before each DB call and then release it afterwards (similar to the way I’m using AutoResetEvent), will this do the trick? Is there any potential problems with this technique? eg: performance?

Answer 1

Ok so first of all my problem was actually 2 problems:

1. Need to ensure that if the foreground app is running, the background process won’t run
2. Need to ensure that only one thread can access the databasse at once and this needs to work across processes to cater for the (admittedly rare, but possible) scenario where the foreground app is started while the background process is in progress.

Based on the good work done in this thread, I created a couple of classes to help.

To solve problem (1), I created the SingleInstanceSynchroniser:

/// <summary>
/// Used to ensure only one instance (foreground app or background app) runs at once
/// </summary>
public class SingleInstanceSynchroniser : IDisposable
{
    private bool hasHandle = false;
    Mutex mutex;

    private void InitMutex()
    {
        string mutexId = "Global\\SingleInstanceSynchroniser"; 
        mutex = new Mutex(false, mutexId);
    }

    public SingleInstanceSynchroniser()
    {
        InitMutex();
        hasHandle = mutex.WaitOne(0);
    }

    public void Dispose()
    {
        if (hasHandle && mutex != null)
            mutex.ReleaseMutex();
    }

    public bool HasExclusiveHandle { get { return hasHandle; } }

}

Usage:

In App.xaml.cs:

...

SingleInstanceSynchroniser singleInstanceSynchroniser;

public App()
{
    singleInstanceSynchroniser = new SingleInstanceSynchroniser();

...

In ScheduledAgent.cs:

SingleInstanceSynchroniser singleInstanceSynchroniser;

protected override void OnInvoke(ScheduledTask task)
    {
        singleInstanceSynchroniser = new SingleInstanceSynchroniser();

        if (singleInstanceSynchroniser.HasExclusiveHandle)
        {
            //Run background process
            ...
        }
        else
        { //Do not run if foreground app is running
            NotifyComplete();
        }
    }

To solve problem (2), I created the SingleAccessSynchroniser:

/// <summary>
/// Used to ensure only one call is made to the database at once 
/// </summary>
public class SingleAccessSynchroniser : IDisposable
{
    public bool hasHandle = false;
    Mutex mutex;

    private void InitMutex()
    {
        string mutexId = "Global\\SingleAccessSynchroniser"; 
        mutex = new Mutex(false, mutexId);            
    }

    public SingleAccessSynchroniser() : this(0)
    { }

    public SingleAccessSynchroniser(int TimeOut)
    {
        InitMutex();

        if (TimeOut <= 0)
            hasHandle = mutex.WaitOne(); 
        else
            hasHandle = mutex.WaitOne(TimeOut);

        if (hasHandle == false)
            throw new TimeoutException("Timeout waiting for exclusive access on SingleInstance");
    }

    public void Release()
    {
        if (hasHandle && mutex != null)
        {
            mutex.ReleaseMutex();
            hasHandle = false;
        }
    }

    public void Dispose()
    {
        Release();
    }
}

Usage: In all database calls:

using (var dbSync = new SingleAccessSynchroniser())
        {
            //Execute your database calls
        }

This has been running reliably for a few weeks now. Hope someone else finds it useful.