How to make sure we have only one instance, and it is disposed in a correct way

Question

In the software I am writing I will read some data from an external device (connected via USB). The drivers I have been given (dll file) are not thread safe and only one instance can be used at a time. I have to write a wrapper to these drivers in C#. Given that I have a multi-threaded application, I would like to make sure that:

Always only one instance is used (probably the wrapper being a singleton?).
It can be disposed of to release the drivers and resources there (IDisposable?).

From Disposable Singleton I can see that the opinions are divided, can a singleton be IDisposable or not. Maybe there is a better solution to both? Any help welcome.
For now I have an IDisposable singleton, like below:

using System;
using System.Runtime.InteropServices;

namespace Philips.Research.Myotrace.DataReading.Devices
{
    class MyDevice: IDisposable
    {
        private static volatile MyDeviceInstance;
        private static object SyncRoot = new Object();

        private bool disposed = false;

        private MyDevice()
        {
            //initialize unmanaged resources here (call LoadLibrary, Initialize, Start etc)
        }

        public MyDevice GetInstance()
        {
            if (Instance == null)
            {
                lock (SyncRoot)
                {
                    if (Instance == null)
                    {
                        Instance = new MyDevice();
                    }
                }
            }

            return Instance;
        }

        public void Dispose()
        {
            this.Dispose(true);
        }

        protected virtual void Dispose(bool disposing)
        {
            if (!this.disposed)
            {
                if (disposing)
                {
                    //dispose of unmanaged resources here (call Stop and Close from reflection code

                    Instance = null;
                }

                this.disposed = true;
            }
        }

        [DllImport("devicedrivers.dll")]
        private static extern bool Initialize();
        [DllImport("devicedrivers.dll")]
        private static extern bool LoadLibrary();
        [DllImport("devicedrivers.dll")]
        private static extern bool Start();
        [DllImport("devicedrivers.dll")]
        private static extern bool Stop();
        [DllImport("devicedrivers.dll")]
        private static extern bool Close();
        //and few more
    }
}

Do you actually *need* to dispose of it? When would you do so? Presumably only at the end of the application - and if the process is going away, why bother releasing it explicitly? (It'll happen automatically.) You might also want to read http://csharpindepth.com/Articles/General/Singleton.aspx to make your singleton pattern simpler. — Jon Skeet, Feb 27 '14 at 14:00
I am unsure how the unmanaged code will behave (the drivers), if I do not call appropriate closing functions (no documentation from the source of the drivers) — Daniel Gruszczyk, Feb 27 '14 at 14:03
The OS is normally responsible for cleaning up unmanaged resources on process termination. For a resource that you want to keep open for the duration of the process, that should be fine. — Jon Skeet, Feb 27 '14 at 14:05
great then, if you put all of that as an answer, I can mark it as the correct one. Thanks for your time again :) — Daniel Gruszczyk, Feb 27 '14 at 14:07
@DanielGruszczyk, you could use something like [this](http://stackoverflow.com/q/21211998/1768303) to implement thread affinity for non-thread-safe unmanaged DLL. — noseratio, Feb 27 '14 at 22:24

score 3 · Accepted Answer · answered Feb 27 '14 at 14:23

The operating system is responsible for cleaning up unmanaged resources when the process terminates. So if you're happy for the resources to be allocated from the point at which you first use the resource until the program termination, I wouldn't implement IDisposable at all.

Having said that, for the sake of testability I would quite possibly avoid exposing the singleton publicly. Consider creating an interface and using dependency injection to inject the same instance throughout your code. I generally dislike singletons. If you're going to use one though, I'd suggest following one of the later patterns in my article on singletons. Avoid all this double-checked locking nonsense :)

I forgot to say that your article about singletons is great, and the book looks interesting too. Thanks for your input. — Daniel Gruszczyk, Mar 26 '14 at 12:21

score 0 · Answer 2 · answered Feb 28 '14 at 17:32

I would not recommend having a directly-disposable static singleton, but rather have a method which returns an IDisposable object (or list of objects) encapsulating the currently-connected device(s). A lot of USB drivers which are mostly limited to single-threaded operation have a single situation where multi-threading is allowed: any thread may request that a driver instance shut down, causing any pending or future operations to abort at first opportunity. The shutdown may not be immediate, and if one wants to shut down and restart a device which has gotten "stuck" one must be prepared for the possibility that re-open attempts may fail and/or block if issued before the shutdown is complete.

Although the OS will try to clean up any USB device drivers a program may be using when it exits, such cleanup doesn't always work, and I would avoid relying upon it. It would be better to dispose of things you can, when you know they're no longer needed. From an abstraction standpoint, if one uses a singleton method which will identify the connected device(s), if any, there's no problem with disposing the device(s) identified thereby. Once devices are disposed, they'll no longer appear on the list until something is done to re-establish connection.

How to make sure we have only one instance, and it is disposed in a correct way

2 Answers2