Как реализовать одиночный элемент в C#?

Путем сокрытия общедоступного конструктора, добавления частного статического поля для содержания этого единственного экземпляра и добавления статического метода фабрики (с ленивым инициализатором) для возврата того единственного экземпляра

public class MySingleton   
{  
    private static MySingleton sngltn; 
    private static object locker;  
    private MySingleton() {}   // Hides parameterless ctor, inhibits use of new()   
    public static MySingleton GetMySingleton()       
    {     
        lock(locker)
            return sngltn?? new MySingleton();
    }   
}

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

hmmm... Немного констант со связанными функциями..., которые не были бы лучше достигнуты через перечисления? Я знаю, что можно создать пользовательское перечисление в Java с методами, и все, то же должно быть достижимым в C#, если не непосредственно поддерживаемый тогда может быть сделан с простым одиночным элементом класса с частным конструктором.

, Если Ваши константы семантически связаны, Вы должны рассмотренные перечисления (или эквивалентное понятие), Вы получите все преимущества статических переменных константы +, Вы будете в состоянии использовать в ваших интересах проверку типа компилятора.

Мои 2 цента

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

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

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

Спрашивают себя это: "Этот класс повредится, если будет больше чем один экземпляр его?" Если ответ не, Вам не нужен одиночный элемент.

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

    public class GenericSingleton<T> where T : new()
    {
        private static T ms_StaticInstance = new T();

        public T Build()
        {
            return ms_StaticInstance;
        }
    }

...
    GenericSingleton<SimpleType> builder1 = new GenericSingleton<SimpleType>();
    SimpleType simple = builder1.Build();

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

Статический одиночный элемент является в значительной степени анти-шаблоном, если Вы хотите слабо связанный дизайн. Избегайте, если это возможно, и если это не очень простая система, я рекомендовал бы взглянуть на одну из многих доступных платформ внедрения зависимости, такой как http://ninject.org/ или http://code.google.com/p/autofac/ .

Для регистрации / используют тип, настроенный как одиночный элемент в autofac, Вы сделали бы что-то как следующее:

var builder = new ContainerBuilder()
builder.Register(typeof(Dependency)).SingletonScoped()
builder.Register(c => new RequiresDependency(c.Resolve<Dependency>()))

var container = builder.Build();

var configured = container.Resolve<RequiresDependency>();

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

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

/// <summary>
/// Thread-safe singleton implementation
/// </summary>
public sealed class MySingleton {

    private static volatile MySingleton instance = null;
    private static object syncRoot = new object();

    /// <summary>
    /// The instance of the singleton
    /// safe for multithreading
    /// </summary>
    public static MySingleton Instance {
        get {
            // only create a new instance if one doesn't already exist.
            if (instance == null) {
                // use this lock to ensure that only one thread can access
                // this block of code at once.
                lock (syncRoot) {
                    if (instance == null) {
                        instance = new MySingleton();
                    }
                }
            }
            // return instance where it was just created or already existed.
            return instance;
        }
    }


    /// <summary>
    /// This constructor must be kept private
    /// only access the singleton through the static Instance property
    /// </summary>
    private MySingleton() {

    }

}

Я рекомендовал бы прочитать статью , Исследовав Шаблон разработки Singleton, доступный на MSDN. Это детализирует функции платформы, которые делают шаблон простым реализовать.

Как в стороне, я проверил бы связанное продолжение читать ТАК относительно Одиночных элементов .

Хм, это все кажется немного сложным.

, Почему Вам нужна платформа внедрения зависимости для получения одиночного элемента? Используя МОК контейнер хорошо для некоторого корпоративного приложения, (как долго, поскольку это не злоупотребляется, конечно), но, ах, парень просто хочет знать aboiut реализация шаблона.

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

Можно действительно упростить одноэлементную реализацию, это - то, что я использую:

    internal FooService() { }        
    static FooService() { }

    private static readonly FooService _instance = new FooService();

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

Одиночные элементы только имеют смысл, если оба из этих условий верны:

1. объект должен быть глобален
2. , Там должен только когда-либо существовать единственный экземпляр объекта

Примечание, что № 2 не означает, что Вы были бы как объект только иметь единственный экземпляр - если это так, просто инстанцировать его только однажды - это означает, что там должен (как в, опасно для этого не быть верным) только когда-либо быть единственным экземпляром.

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

Thats мое мнение так или иначе.

Singleton != Global. Вы, кажется, ищете ключевое слово static.

public class Globals
{
    private string setting1;
    private string setting2;

    #region Singleton Pattern Implementation

    private class SingletonCreator
    {
        internal static readonly Globals uniqueInstance = new Globals();

        static SingletonCreator()
        {
        }
    }

    /// <summary>Private Constructor for Singleton Pattern Implementaion</summary>
    /// <remarks>can be used for initializing member variables</remarks>
    private Globals()
    {

    }

    /// <summary>Returns a reference to the unique instance of Globals class</summary>
    /// <remarks>used for getting a reference of Globals class</remarks>
    public static Globals GetInstance
    {
        get { return SingletonCreator.uniqueInstance; }
    }

    #endregion

    public string Setting1
    {
        get { return this.setting1; }
        set { this.setting1 = value; }
    }

    public string Setting2
    {
        get { return this.setting2; }
        set { this.setting2 = value; }
    }

    public static int Constant1 
    {
        get { reutrn 100; }
    }

    public static int Constat2
    {
        get { return 200; }
    }

    public static DateTime SqlMinDate
    {
        get { return new DateTime(1900, 1, 1, 0, 0, 0); }
    }

}