Что такое синглтон в C #?

Что такое синглтон и когда я должен его использовать?

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

Существует реализация C # «Реализация шаблона Singleton в C #», охватывающая большую часть того, что вам нужно знать, включая некоторые полезные советы относительно безопасности потоков .

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

Вы просили C #. Тривиальный пример:

public class Singleton
{
    private Singleton()
    {
        // Prevent outside instantiation
    }

    private static readonly Singleton _singleton = new Singleton();

    public static Singleton GetSingleton()
    {
        return _singleton;
    }
}

Что это: класс, для которого существует только один постоянный экземпляр на протяжении всего жизненного цикла приложения. См. Шаблон Singleton .

Когда вы должны использовать это: как можно меньше. Только тогда, когда вы абсолютно уверены, что вам это нужно. Я не хочу говорить «никогда», но обычно есть лучшая альтернатива, например, Dependency Injection или просто статический класс.

Другой способ реализовать синглтон в C #, я лично предпочитаю этот способ, потому что вы можете получить доступ к экземпляру класса Singeton как свойство вместо метода.

public class Singleton
    {
        private static Singleton instance;

        private Singleton() { }

        public static Singleton Instance
        {
            get
            {
                if (instance == null)
                    instance = new Singleton();
                return instance;
            }
        }

        //instance methods
    }

но, насколько я знаю, оба способа считаются «правильными», так что это просто вещь личного вкуса.

using System;
using System.Collections.Generic;
class MainApp
{
    static void Main()
    {
        LoadBalancer oldbalancer = null;
        for (int i = 0; i < 15; i++)
        {
            LoadBalancer balancerNew = LoadBalancer.GetLoadBalancer();

            if (oldbalancer == balancerNew && oldbalancer != null)
            {
                Console.WriteLine("{0} SameInstance {1}", oldbalancer.Server, balancerNew.Server);
            }
            oldbalancer = balancerNew;
        }
        Console.ReadKey();
    }
}

class LoadBalancer
{
    private static LoadBalancer _instance;
    private List<string> _servers = new List<string>();
    private Random _random = new Random();

    private static object syncLock = new object();

    private LoadBalancer()
    {
        _servers.Add("ServerI");
        _servers.Add("ServerII");
        _servers.Add("ServerIII");
        _servers.Add("ServerIV");
        _servers.Add("ServerV");
    }

    public static LoadBalancer GetLoadBalancer()
    {
        if (_instance == null)
        {
            lock (syncLock)
            {
                if (_instance == null)
                {
                    _instance = new LoadBalancer();
                }
            }
        }

        return _instance;
    }

    public string Server
    {
        get
        {
            int r = _random.Next(_servers.Count);
            return _servers[r].ToString();
        }
    }
}

Я взял код с dofactory.com , ничего особенного, но я нахожу это гораздо лучше, чем примеры с Foo and Bar, дополнительно в книге от Джудит Бишоп о C # 3.0 Design Patterns есть пример активного приложения в доке Mac.

Если вы посмотрите на код, мы фактически строим новые объекты для цикла for , так что он создает новый объект, но повторно использует экземпляр, в результате чего oldbalancer и newbalancer имеют один и тот же экземпляр. Как? Это происходит из-за того, что ключевое слово static используется в функции GetLoadBalancer () , несмотря на то, что сервер имеет другое значение, которое является случайным списком, static в GetLoadBalancer () принадлежит самому типу, а не конкретному объекту.

Кроме того , существует двойная проверка блокировки здесь

if (_instance == null)
            {
                lock (syncLock)
                {
                    if (_instance == null)

так как из MSDN

Ключевое слово lock гарантирует, что один поток не войдет в критический раздел кода, в то время как другой поток находится в критическом разделе. Если другой поток попытается ввести заблокированный код, он будет ждать блокировки до тех пор, пока объект не будет освобожден.

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

Надеюсь, это поможет очистить больше.

И, пожалуйста, прокомментируйте, если я понимаю, что неверно.

Синглтон (и это не связано с C #, это шаблон проектирования ОО) - это когда вы хотите, чтобы в вашем приложении создавался только ОДИН экземпляр класса. Использование обычно включает в себя глобальные ресурсы, хотя я скажу из личного опыта, они очень часто являются источником большой боли.

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

Это шаблон дизайна, и он не специфичен для c #. Подробнее об этом по всему Интернету и ТАК, как в этой статье в Википедии .

В разработке программного обеспечения одноэлементный шаблон является шаблоном проектирования, который используется для ограничения создания экземпляров класса одним объектом. Это полезно, когда ровно один объект необходим для координации действий в системе. Эта концепция иногда обобщается на системы, которые работают более эффективно, когда существует только один объект, или которые ограничивают создание экземпляра определенным числом объектов (скажем, пять). Некоторые считают это анти-паттерном, полагая, что он чрезмерно используется, вводит ненужные ограничения в ситуациях, когда единственный экземпляр класса фактически не требуется, и вводит глобальное состояние в приложение.

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

Я использую это для поиска данных. Загрузите один раз из БД.

public sealed class APILookup
    {
        private static readonly APILookup _instance = new APILookup();
        private Dictionary<string, int> _lookup;

        private APILookup()
        {
            try
            {
                _lookup = Utility.GetLookup();
            }
            catch { }
        }

        static APILookup()
        {            
        }

        public static APILookup Instance
        {
            get
            {
                return _instance;
            }
        }
        public Dictionary<string, int> GetLookup()
        {
            return _lookup;
        }

    }

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

Когда следует использовать:
это зависит от ситуации.

Примечание: пожалуйста, не используйте соединение с БД, подробный ответ см. В ответе @Chad Grant.

Вот простой пример Singleton:

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

    // Explicit static constructor to tell C# compiler
    // not to mark type as beforefieldinit
    static Singleton()
    {
    }

    private Singleton()
    {
    }

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

Вы также можете использовать, Lazy<T>чтобы создать свой Singleton.

Смотрите здесь для более подробного примера использованияLazy<T>

Вот что такое синглтон: http://en.wikipedia.org/wiki/Singleton_pattern

Я не знаю C #, но на самом деле это одно и то же во всех языках, отличается только реализация.

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

Извините за мой английский ;)

Класс Singleton используется для создания единого экземпляра для всего домена приложения.

public class Singleton
{
    private static Singleton singletonInstance = CreateSingleton();

    private Singleton()
    {
    }

    private static Singleton CreateSingleton()
    {
        if (singletonInstance == null)
        {
            singletonInstance = new Singleton();
        }

        return singletonInstance;
    }

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

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

Я знаю, что уже очень поздно, чтобы ответить на вопрос, но с Auto-Property вы можете сделать что-то вроде этого:

public static Singleton Instance { get; } = new Singleton();

Где Singletonвы класс и может быть через, в этом случае свойство только для чтения Instance.

EX Вы можете использовать Singleton для глобальной информации, которую необходимо ввести.

В моем случае я хранил данные о зарегистрированном пользователе (имя пользователя, разрешения и т. Д.) В глобальном статическом классе. И когда я попытался реализовать модульный тест, я никак не мог внедрить зависимость в классы контроллера. Таким образом, я изменил свой статический класс на шаблон Singleton.

public class SysManager
{
    private static readonly SysManager_instance = new SysManager();

    static SysManager() {}

    private SysManager(){}

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

http://csharpindepth.com/Articles/General/Singleton.aspx#cctor

Нам нужно использовать шаблон проектирования Singleton в C #, когда нам нужно убедиться, что будет создан только один экземпляр определенного класса, а затем обеспечить простой глобальный доступ к этому экземпляру для всего приложения.

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

Фасады: Вы также можете создать подключения к базе данных как Singleton, что может повысить производительность приложения.

Журналы: в приложении выполнение операции ввода-вывода над файлом является дорогостоящей операцией. Если вы создадите Logger как Singleton, это улучшит производительность операции ввода-вывода.

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

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

Недостатки шаблона проектирования Singleton в C # Недостатки использования шаблона проектирования Singleton в C # заключаются в следующем:

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

Я взял это из следующей статьи.

https://dotnettutorials.net/lesson/singleton-design-pattern/

Поток Safe Singleton без использования замков и без ленивых экземпляров.

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

public sealed class Singleton
{

    static Singleton(){}

    private Singleton(){}

    public static Singleton Instance { get; } = new Singleton();

}