Singleton Design Pattern - for single & multi-thread environment

DoubleLockSingleton.cs

namespace Patterns.Threading
{
    /// <summary>
    /// Singleton Design Pattern for multi-thread environment
    /// </summary>
    /// <remarks>Uses double-checked locking method - effective but expensive locking mechanism with least control.</remarks>
    public sealed class DoubleLockSingleton
    {
        private static readonly object _sync = new object();
        private static DoubleLockSingleton _instance;

        private DoubleLockSingleton()
        {
        }

        public static DoubleLockSingleton Instance
        {
            get
            {
                if (_instance != null)
                    return _instance;

                lock( _sync )
                {
                    _instance = new DoubleLockSingleton();
                    return _instance;
                }
            }
        }
    }
}

LazySingleton.cs

using System;

namespace Patterns
{
    /// <summary>
    /// Singleton Design Pattern for single thread environment
    /// </summary>
    /// <remarks>Uses lazy instantiation method.</remarks>
    public sealed class LazySingleton
    {
        private static readonly Lazy<LazySingleton> Lazy = new Lazy<LazySingleton>(() => new LazySingleton());

        private LazySingleton() { }

        public static LazySingleton Instance => Lazy.Value;
    }
}

MonitorSingleton.cs

using System.Threading;

namespace Patterns.Threading
{
    /// <summary>
    /// Singleton Design Pattern for multi-thread environment
    /// </summary>
    /// <remarks>The monitor mechanism gives the greatest control over locking use cases.</remarks>
    public sealed class MonitorSingleton
    {
        private static readonly object _sync = new object();
        private static MonitorSingleton _instance;

        private MonitorSingleton()
        {
        }

        public static MonitorSingleton Instance
        {
            get
            {
                if (_instance != null)
                    return _instance;

                Monitor.Enter(_sync);

                var single = new MonitorSingleton();
                Interlocked.Exchange(ref _instance, single);

                Monitor.Exit(_sync);

                return _instance;
            }
        }
    }
}

Singleton.cs

namespace Patterns
{
    /// <summary>
    /// Singleton Design Pattern for single thread environment
    /// </summary>
    /// <remarks>Basic use case for singleton.</remarks>
    public sealed class Singleton
    {
        private static Singleton _instance;

        private Singleton()
        {

        }

        public static Singleton Instance
        {
            get
            {
                if (_instance != null)
                    return _instance;

                _instance = new Singleton();
                return _instance;
            }
        }
    }
}