Question

I have an app that creates an object that needs to be locked as this object creates an external hardware device object (via third party DLL) and the hardware device object can only be created once. When multiple instances of this app are launched, only the first instance should be able to create this C# object. The subsequence instances should see that the object has been locked and object can not be created. I used a mutex as this object creation occurs in multiple app instances (multiple processes). The code doesn’t lock with the mutex however. Am I running multiple instances in which each one creates its own lock?

public sealed class MyObject
{
    private static MyObject _myObject;
    static ExtDeviceDriver devDrv;
    private readonly static Mutex mut = new Mutex();

    private MyObject()
    {
        mut.WaitOne();
        //Thread safe code here.
        devDrv = new ExtDeviceDriver();
    }

    ~MyObject()
    {
        mut.ReleaseMutex();
    }

    // object accessor
    public static MyObject GetMyObject
    {
        get
        {
            if (_myObject == null)
                _myObject = new MyObject();
            return _myObject;   
        }
    }
}

Answer 1

I guess you should use named mutex (See this article on MSDN).

Mutexes are of two types: local mutexes and named system mutexes. If
you create a Mutex object using a constructor that accepts a name, it
is associated with an operating-system object of that name. Named
system mutexes are visible throughout the operating system and can be
used to synchronize the activities of processes. You can create
multiple Mutex objects that represent the same named system mutex, and
you can use the OpenExisting method to open an existing named system
mutex.

So, try to use this constructor to create a named Mutex. Besides you should check, whether it already exists with Mutex.OpenExisting Method (Consider the example given in this very article; is tells how to check, create, utilize a named mutex).

EDIT

See Mutex Class:

You can use the WaitHandle.WaitOne method to request ownership of a
mutex. The thread that owns a mutex can request the same mutex in
repeated calls to WaitOne without blocking its execution. However, the
thread must call the ReleaseMutex method the same number of times to
release ownership of the mutex. The Mutex class enforces thread
identity, so a mutex can be released only by the thread that acquired
it.

And Mutex Constructor (Boolean, String), that says, that a bool argument must be set to:

true to give the calling thread
initial ownership of the named system mutex if the named system mutex
is created as a result of this call; otherwise, false.