Какой хороший потокобезопасный шаблон универсального шаблона singleton в C#

Предоставлено Джудит Бишоп, http://patterns.cs.up.ac.za/

Эта реализация одноэлементного шаблона обеспечивает ленивую инициализацию.

//  Singleton PatternJudith Bishop Nov 2007
//  Generic version

public class Singleton<T> where T : class, new()
{
    Singleton() { }

    class SingletonCreator
    {
        static SingletonCreator() { }
        // Private object instantiated with private constructor
        internal static readonly T instance = new T();
    }

    public static T UniqueInstance
    {
        get { return SingletonCreator.instance; }
    }
}

public sealed class Singleton
{
   private static readonly Singleton instance = new Singleton();

   private Singleton(){}

   public static Singleton Instance
   {
      get 
      {
         return instance; 
      }
   }
}

Есть нет двусмысленности в .NET в отношении порядка инициализации; но это вызывает проблемы с потоками.

По словам Джона Скита в Реализация шаблона Singleton в C#, опубликованный вами код на самом деле считается плохим кодом, потому что он кажется сломанным при проверке на соответствие стандарту ECMA CLI.

Также будьте осторожны: каждый раз, когда вы создаете экземпляр своего объекта с новым типом T, он становится другим экземпляром; это не отражается в вашем исходном синглтоне.

Мне очень понравился ваш исходный ответ - единственное, чего не хватает (согласно ссылке, опубликованной blowdart), - это сделать переменную _instance изменчивой, чтобы убедиться, что она действительно установлена ​​в блокировке. Я действительно использую решение blowdarts, когда мне нужно использовать синглтон, но у меня нет необходимости создавать поздние экземпляры и т. д.

Все это вам не нужно, в C# уже есть хороший встроенный шаблон singleton.

static class Foo

Если вам нужно что-то более интересное, скорее всего, ваш новый синглтон будет достаточно другим, чтобы ваш общий шаблон был бесполезен.

Обновлено: Под «чем-нибудь более интересным» я включаю наследование. Если вы можете наследовать от синглтона, это больше не синглтон.

Этот код не компилируется, вам нужно ограничение "класса" на T.

Кроме того, для этого кода требуется общедоступный конструктор в целевом классе, что не подходит для синглтона, потому что вы не можете контролировать во время компиляции, что вы получаете (единственный) экземпляр только через свойство (или поле) Instance. Если у вас нет других статических членов, кроме Instance, вы можете использовать только это:

class Foo
{
  public static readonly Instance = new Foo();
  private Foo() {}
  static Foo() {}
}

Это потокобезопасный (гарантируется CLR) и ленивый (экземпляр создается с первым доступом к типу). Дополнительные сведения о BeforeFieldInit и о том, почему нам здесь нужен статический конструктор, см. В разделе https://csharpindepth.com/articles/BeforeFieldInit.

Если вы хотите иметь другие общедоступные статические члены по типу, но создавать объект только при доступе к экземпляру, вы можете создать вложенный тип, как в https://csharpindepth.com/articles/Singleton

Я не думаю, что вы действительно хотите «сжечь свой базовый класс», чтобы сохранить две строчки кода. Вам действительно не нужен базовый класс для реализации синглтона.

Всякий раз, когда вам нужен синглтон, просто сделайте это:

class MyConcreteClass
{
  #region Singleton Implementation

    public static readonly Instance = new MyConcreteClass();

    private MyConcreteClass(){}

  #endregion

    /// ...
}

Подробнее об этом ответе в другом потоке: Как реализовать синглтон на C#?

Однако поток не использует общий.

Я искал образец синглтона получше, и он мне понравился. Так что портировал его на VB.NET, может быть полезно другим:

Public MustInherit Class Singleton(Of T As {Class, New})
    Public Sub New()
    End Sub

    Private Class SingletonCreator
        Shared Sub New()
        End Sub
        Friend Shared ReadOnly Instance As New T
    End Class

    Public Shared ReadOnly Property Instance() As T
        Get
            Return SingletonCreator.Instance
        End Get
    End Property
End Class

Мой вклад в обеспечение создания данных экземпляра по запросу:

/// <summary>Abstract base class for thread-safe singleton objects</summary>
/// <typeparam name = "T">Instance type</typeparam>
public abstract class SingletonOnDemand<T> {
    private static object __SYNC = new object();
    private static volatile bool _IsInstanceCreated = false;
    private static T _Instance = default(T);


    /// <summary>Instance data</summary>
    public static T Instance {
        get {
            if (!_IsInstanceCreated)
                lock (__SYNC)
                    if (!_IsInstanceCreated)
                        _Instance = Activator.CreateInstance<T>();
            return _Instance;
        }
    }
}

пфф ... снова ... :)
Мой вклад в обеспечение создания данных экземпляра по запросу:

/// <summary>Abstract base class for thread-safe singleton objects</summary>
/// <typeparam name = "T">Instance type</typeparam>
public abstract class SingletonOnDemand<T> {
  private static object __SYNC = new object();
  private static volatile bool _IsInstanceCreated = false;
  private static T _Instance = default(T);

  /// <summary>Instance data</summary>
  public static T Instance {
    get {
      if (!_IsInstanceCreated)
        lock (__SYNC)
          if (!_IsInstanceCreated) {
            _Instance = Activator.CreateInstance<T>();
            _IsInstanceCreated = true;
          }
          return _Instance;
    }
  }
}

По запросу, перекрестная публикация моего исходного ответа на другой вопрос.

Моя версия использует Reflection, работает с непубличными конструкторами в производном классе, является потокобезопасной (очевидно) с ленивым созданием (согласно статье, которую я нашел по ссылке ниже):

public class SingletonBase<T> where T : class
{
    static SingletonBase()
    {
    }

    public static readonly T Instance = 
        typeof(T).InvokeMember(typeof(T).Name, 
                                BindingFlags.CreateInstance | 
                                BindingFlags.Instance |
                                BindingFlags.Public |
                                BindingFlags.NonPublic, 
                                null, null, null) as T;
}

Я взял это несколько лет назад, не зная, сколько мне принадлежит, но поиск в Google кода мог бы найти исходный источник техники, если бы это был не я.

Это самый старый источник кода, который я могу найти, который публиковал не я.

: / Общий шаблон "singleton" Джудит Бишоп кажется некорректным, всегда можно создать несколько экземпляров типа T, поскольку конструктор должен быть общедоступным, чтобы использовать его в этом "шаблоне". На мой взгляд, это не имеет ничего общего с синглтоном, это просто своего рода фабрика, которая всегда возвращает один и тот же объект, но не делает его синглтоном ... пока может быть более одного экземпляра класса, который он не может быть синглом. По какой причине этот паттерн пользуется наибольшим рейтингом?

public sealed class Singleton
{
  private static readonly Singleton _instance = new Singleton();

  private Singleton()
  {
  }

  public static Singleton Instance
  {
    get
    {
      return _instance;
    }
  }
}

Статические инициализаторы считаются потокобезопасными ... Я не знаю, но вы вообще не должны использовать идиомы синглтона, если вы оберните мой код над его не более чем 3 строками ... и наследование от синглтона не делает никакого смысла тоже.

public static class LazyGlobal<T> where T : new()
{
    public static T Instance
    {
        get { return TType.Instance; }
    }

    private static class TType
    {
        public static readonly T Instance = new T();
    }
}

// user code:
{
    LazyGlobal<Foo>.Instance.Bar();
}

Или же:

public delegate T Func<T>();

public static class CustomGlobalActivator<T>
{
    public static Func<T> CreateInstance { get; set; }
}

public static class LazyGlobal<T>
{
    public static T Instance
    {
        get { return TType.Instance; }
    }

    private static class TType
    {
        public static readonly T Instance = CustomGlobalActivator<T>.CreateInstance();
    }
}

{
    // setup code:
    // CustomGlobalActivator<Foo>.CreateInstance = () => new Foo(instanceOf_SL_or_IoC.DoSomeMagicReturning<FooDependencies>());
    CustomGlobalActivator<Foo>.CreateInstance = () => instanceOf_SL_or_IoC.PleaseResolve<Foo>();
    // ...
    // user code:
    LazyGlobal<Foo>.Instance.Bar();
}

Некоторое время назад видел один, который использует отражение для доступа к частному (или общедоступному) конструктору по умолчанию:

public static class Singleton<T>
{
    private static object lockVar = new object();
    private static bool made;
    private static T _singleton = default(T);

    /// <summary>
    /// Get The Singleton
    /// </summary>
    public static T Get
    {
        get
        {
            if (!made)
            {
                lock (lockVar)
                {
                    if (!made)
                    {
                        ConstructorInfo cInfo = typeof(T).GetConstructor(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[0], null);
                        if (cInfo != null)
                            _singleton = (T)cInfo.Invoke(new object[0]);
                        else
                            throw new ArgumentException("Type Does Not Have A Default Constructor.");
                        made = true;
                    }
                }
            }

            return _singleton;
        }
    }
}

Попробуйте этот общий класс Singleton, реализующий шаблон проектирования Singleton поточно-безопасным и ленивым способом (спасибо wcell).

public abstract class Singleton<T> where T : class
{
    /// <summary>
    /// Returns the singleton instance.
    /// </summary>
    public static T Instance
    {
        get
        {
            return SingletonAllocator.instance;
        }
    }

    internal static class SingletonAllocator
    {
        internal static T instance;

        static SingletonAllocator()
        {
            CreateInstance(typeof(T));
        }

        public static T CreateInstance(Type type)
        {
            ConstructorInfo[] ctorsPublic = type.GetConstructors(
                BindingFlags.Instance | BindingFlags.Public);

            if (ctorsPublic.Length > 0)
                throw new Exception(
                    type.FullName + " has one or more public constructors so the property cannot be enforced.");

            ConstructorInfo ctorNonPublic = type.GetConstructor(
                BindingFlags.Instance | BindingFlags.NonPublic, null, new Type[0], new ParameterModifier[0]);

            if (ctorNonPublic == null)
            {
                throw new Exception(
                    type.FullName + " doesn't have a private/protected constructor so the property cannot be enforced.");
            }

            try
            {
                return instance = (T)ctorNonPublic.Invoke(new object[0]);
            }
            catch (Exception e)
            {
                throw new Exception(
                    "The Singleton couldnt be constructed, check if " + type.FullName + " has a default constructor", e);
            }
        }
    }
}

Идиома Double-Check Locking [Lea99], предоставляемая Microsoft здесь, удивительно похожа на предоставленный вами код, к сожалению, это не соответствует стандарту ECMA CLI для пуританского представления поточно-безопасного кода и может работать некорректно во всех ситуациях.

В многопоточной программе разные потоки могут одновременно пытаться создать экземпляр класса. По этой причине реализация Singleton, которая полагается на оператор if, чтобы проверить, является ли экземпляр нулевым не будет потокобезопасным. Не пишите такой код!

Простым, но эффективным средством создания потокобезопасного синглтона является использование вложенного класса для его создания. Ниже приведен пример синглтона с ленивым созданием экземпляра:

public sealed class Singleton
{ 
   private Singleton() { }

   public static Singleton Instance
   {
      get
      {
         return SingletonCreator.instance;
      }
   }

   private class SingletonCreator
   {
      static SingletonCreator() { }
      internal static readonly Singleton instance = new Singleton();
   }
}

Использование:

Singleton s1 = Singleton.Instance;
Singleton s2 = Singleton.Instance;
if (s1.Equals(s2))
{
    Console.WriteLine("Thread-Safe Singleton objects are the same");
}

Общее решение:

public class Singleton<T>
    where T : class, new()
{
    private Singleton() { }

    public static T Instance 
    { 
        get 
        { 
            return SingletonCreator.instance; 
        } 
    } 

    private class SingletonCreator 
    {
        static SingletonCreator() { }

        internal static readonly T instance = new T();
    }
}

Использование:

class TestClass { }

Singleton s1 = Singleton<TestClass>.Instance;
Singleton s2 = Singleton<TestClass>.Instance;
if (s1.Equals(s2))
{
    Console.WriteLine("Thread-Safe Generic Singleton objects are the same");
}

Наконец, вот несколько выпущенное и полезное предложение - чтобы помочь избежать взаимоблокировок, которые могут быть вызваны использованием ключевого слова lock, рассмотрите возможность добавления следующего атрибута для защиты кода только в общедоступных статических методах:

using System.Runtime.CompilerServices;
[MethodImpl (MethodImplOptions.Synchronized)]
public static void MySynchronizedMethod()
{
}

Рекомендации:

1. Поваренная книга C# (O'Reilly), Джей Хильярд и Стивен Тейле
2. C# 3.0 Design Patterns (O'Reilly), Джудит Бишоп
3. CSharp-Online.Net - шаблон проектирования синглтона: потокобезопасный синглтон

Я отправляю это группе. Он кажется поточно-ориентированным, универсальным и следует шаблону. Вы можете унаследовать от него. Это составлено из того, что сказали другие.

public class Singleton<T> where T : class
{
    class SingletonCreator
    {
        static SingletonCreator() { }

        internal static readonly T Instance =
            typeof(T).InvokeMember(typeof(T).Name,
                                    BindingFlags.CreateInstance |
                                    BindingFlags.Instance |
                                    BindingFlags.Public |
                                    BindingFlags.NonPublic,
                                    null, null, null) as T;
    }

    public static T Instance
    {
        get { return SingletonCreator.Instance; }
    }
}

Предполагаемая реализация:

public class Foo: Singleton<Foo>
{
     private Foo() { }
}

Потом:

Foo.Instance.SomeMethod();

Это моя точка зрения, использующая .NET 4

public class Singleton<T> where T : class, new()
    {
        Singleton (){}

        private static readonly Lazy<T> instance = new Lazy<T>(()=> new T());

        public static T Instance { get { return instance.Value; } } 
    }

Как в википедия:

the singleton pattern is a design pattern that restricts the instantiation of a class to one object

Я полагаю, что нет гарантированного способа сделать это с использованием дженериков, если вы ограничили создание экземпляра самого синглтона, как ограничить создание экземпляра основного класса, я думаю, что это невозможно сделать, и реализуя этот простой шаблон не так уж и сложно, воспользуйтесь этим путем, используя статический конструктор и частный набор:

public class MyClass
{
        private MyClass()
        {

        }

        static MyClass()
        {
            Instance = new MyClass();
        }

        public static MyClass Instance { get; private set; }
}

ИЛИ ЖЕ:

public class MyClass
    {
            private MyClass()
            {

            }

            static MyClass()
            {
                Instance = new MyClass();
            }

            private static MyClass instance;



            public static MyClass Instance
            {
                get
                {
                    return instance;
                }
                private set
                {
                    instance = value;
                }
            }
    }

Это работает для меня:

public static class Singleton<T> 
{
    private static readonly object Sync = new object();

    public static T GetSingleton(ref T singletonMember, Func<T> initializer)
    {
        if (singletonMember == null)
        {
            lock (Sync)
            {
                if (singletonMember == null)
                    singletonMember = initializer();
            }
        }
        return singletonMember;
    }
}

Использование:

private static MyType _current;
public static MyType Current = Singleton<MyType>.GetSingleton(ref _current, () => new MyType());

Потребляйте синглтон:

MyType.Current. ...

Независимо от того, какой пример вы выберете, всегда проверяйте параллелизм с помощью Parallel.For! (цикл, в котором итерации могут выполняться параллельно)

вставьте Singleton C'tor:

 private Singleton ()
        {
            Console.WriteLine("usage of the Singleton for the first time");
        }

поместите в Main:

Parallel.For(0, 10,
              index => {
                  Thread tt = new Thread(new ThreadStart(Singleton.Instance.SomePrintMethod));
                  tt.Start();
              });