Question

Question, Let’s say I had Thread A and Thread B and both of these needed access to a singleton object and it’s properties.

Currently the singleton looks as follows.

public class Singleton{

        #region fields
        private static Singleton singletonObject;
        private double value1= 0;
        private double value2= 0;
        private double value3= 0;
        private double value4= 0;
        private object locker = null;
        #endregion

        // private constructor. This will avoid creating object using new keyword
        private Singleton() {
            locker = new object();
        }

        // public method which will be called
        public void GetName() {
            Console.WriteLine("singleton Object");
        }
        public static Singleton Instance() {
            // this object will be used with lock, so that it will be always one thread which will be executing the code
            object instanceLocker = new object();
            // put a lock on myObject. We won't be able to use singleTonObject becuase it will be null. lock is to make the object thread safe.
            // lock can't be worked with null objects.
            lock (instanceLocker) {
                // check whether the instance was there. If it's not there, then create an instance.
                if (singletonObject == null) {
                    singletonObject = new Singleton();

                }
            }
            return singletonObject;
        }

        public double Value1 { get { lock (locker) { return value1; } } set { lock (locker) { value1= value; } } }
        public double Value2 { get { lock (locker) { return value2; } } set { lock (locker) { value2= value; } } }
        public double Value3 { get { lock (locker) { return value3; } } set { lock (locker) { value3= value; } } }
        public double Value4 { get { lock (locker) { return value4; } } set { lock (locker) { value4= value; } } }


    }

My question. Rather than having thread safe properties, is there a better approach?

Thanks,

Answer 1

Currently your code is completely broken. You’re creating a new object to lock on during every call. No other thread will ever know about it, so it’s completely pointless.

Don’t bother trying to fix it in clever ways. Just initialize it in the static variable initializer:

private static Singleton singletonObject = new Singleton();

Nice and simple.

For more information about implementing the singleton pattern in C# (including using Lazy<T> in .NET 4), see my article on the topic.