Безопасен ли поток статического конструктора C #?

Другими словами, безопасен ли этот поток реализации Singleton:

public class Singleton
{
    private static Singleton instance;

    private Singleton() { }

    static Singleton()
    {
        instance = new Singleton();
    }

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

Статические конструкторы гарантированно будут запускаться только один раз в домене приложения до создания каких-либо экземпляров класса или доступа к любым статическим членам. https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/static-constructors

Показанная реализация является поточно-ориентированной для начальной конструкции, то есть для создания объекта Singleton не требуется блокировка или нулевое тестирование. Однако это не означает, что любое использование экземпляра будет синхронизировано. Существует множество способов сделать это; Я показал один ниже.

public class Singleton
{
    private static Singleton instance;
    // Added a static mutex for synchronising use of instance.
    private static System.Threading.Mutex mutex;
    private Singleton() { }
    static Singleton()
    {
        instance = new Singleton();
        mutex = new System.Threading.Mutex();
    }

    public static Singleton Acquire()
    {
        mutex.WaitOne();
        return instance;
    }

    // Each call to Acquire() requires a call to Release()
    public static void Release()
    {
        mutex.ReleaseMutex();
    }
}

Хотя все эти ответы дают один и тот же общий ответ, есть одна оговорка.

Помните, что все потенциальные производные универсального класса компилируются как отдельные типы. Поэтому будьте осторожны при реализации статических конструкторов для универсальных типов.

class MyObject<T>
{
    static MyObject() 
    {
       //this code will get executed for each T.
    }
}

РЕДАКТИРОВАТЬ:

Вот демонстрация:

static void Main(string[] args)
{
    var obj = new Foo<object>();
    var obj2 = new Foo<string>();
}

public class Foo<T>
{
    static Foo()
    {
         System.Diagnostics.Debug.WriteLine(String.Format("Hit {0}", typeof(T).ToString()));        
    }
}

В консоли:

Hit System.Object
Hit System.String

Использование статического конструктора на самом деле является потокобезопасным. Статический конструктор гарантированно будет выполнен только один раз.

Из спецификации языка C # :

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

• Экземпляр класса создан.
• На любые статические члены класса есть ссылки.

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

Zooba сделал отличное замечание (и за 15 секунд до меня тоже!), Что статический конструктор не гарантирует потокобезопасный общий доступ к синглтону. Это должно быть обработано другим способом.

Вот версия Cliffnotes с указанной выше страницы MSDN на c # singleton:

Всегда используйте следующий шаблон, вы не ошибетесь:

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

   private Singleton(){}

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

Помимо очевидных синглтон-функций, он дает вам две эти вещи бесплатно (в отношении синглтона в c ++):

1. ленивая конструкция (или не конструкция, если она никогда не называлась)
2. синхронизация

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

private static readonly Singleton instance = new Singleton();

Безопасность потоков - более важная проблема, когда вы лениво инициализируете вещи.

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

    private class InitializerTest
    {
        static private int _x;
        static public string Status()
        {
            return "_x = " + _x;
        }
        static InitializerTest()
        {
            System.Diagnostics.Debug.WriteLine("InitializerTest() starting.");
            _x = 1;
            Thread.Sleep(3000);
            _x = 2;
            System.Diagnostics.Debug.WriteLine("InitializerTest() finished.");
        }
    }

    private void ClassInitializerInThread()
    {
        System.Diagnostics.Debug.WriteLine(Thread.CurrentThread.GetHashCode() + ": ClassInitializerInThread() starting.");
        string status = InitializerTest.Status();
        System.Diagnostics.Debug.WriteLine(Thread.CurrentThread.GetHashCode() + ": ClassInitializerInThread() status = " + status);
    }

    private void classInitializerButton_Click(object sender, EventArgs e)
    {
        new Thread(ClassInitializerInThread).Start();
        new Thread(ClassInitializerInThread).Start();
        new Thread(ClassInitializerInThread).Start();
    }

Код выше дал результаты ниже.

10: ClassInitializerInThread() starting.
11: ClassInitializerInThread() starting.
12: ClassInitializerInThread() starting.
InitializerTest() starting.
InitializerTest() finished.
11: ClassInitializerInThread() status = _x = 2
The thread 0x2650 has exited with code 0 (0x0).
10: ClassInitializerInThread() status = _x = 2
The thread 0x1f50 has exited with code 0 (0x0).
12: ClassInitializerInThread() status = _x = 2
The thread 0x73c has exited with code 0 (0x0).

Хотя статическому конструктору потребовалось много времени, другие потоки остановились и стали ждать. Все потоки читают значение _x, установленное в нижней части статического конструктора.

Спецификация инфраструктуры общего языка гарантирует, что «инициализатор типа должен запускаться ровно один раз для любого данного типа, если это явно не вызвано кодом пользователя». (Раздел 9.5.3.1.) Таким образом, если у вас нет какого-то дурацкого IL на вызове Singleton ::. Cctor напрямую (маловероятно), ваш статический конструктор будет запущен ровно один раз перед использованием типа Singleton, будет создан только один экземпляр Singleton, и ваше свойство Instance является поточно-ориентированным.

Обратите внимание, что если конструктор Singleton обращается к свойству Instance (даже косвенно), свойство Instance будет иметь значение null. Лучшее, что вы можете сделать, это обнаружить, когда это происходит, и выдать исключение, проверив, что экземпляр не равен NULL в методе доступа к свойству. После завершения статического конструктора свойство Instance будет иметь ненулевое значение.

Как указывает ответ Zoomba , вам нужно сделать Singleton безопасным для доступа из нескольких потоков или внедрить механизм блокировки с использованием экземпляра singleton.

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

Статический конструктор гарантированно безопасен для потоков. Также ознакомьтесь с обсуждением Singleton на DeveloperZen: http://web.archive.org/web/20160404231134/http://www.developerzen.com/2007/07/15/whats-wrong-with-this-code -1-обсуждение /

Хотя другие ответы в основном правильные, есть еще одна оговорка со статическими конструкторами.

Как указано в разделе II.10.5.3.3 Расы и тупиков в инфраструктуре ECMA-335 Common Language

Одна только инициализация типа не должна создавать тупиковую ситуацию, если какой-либо код, вызываемый из инициализатора типа (прямо или косвенно), явно не вызывает операции блокировки.

Следующий код приводит к тупику

using System.Threading;
class MyClass
{
    static void Main() { /* Won’t run... the static constructor deadlocks */  }

    static MyClass()
    {
        Thread thread = new Thread(arg => { });
        thread.Start();
        thread.Join();
    }
}

Оригинальный автор Игорь Островский, смотрите его пост здесь .