什么是C#中的单身人士？

Question

非常直截了当的问题.

什么是单身人士,何时应该使用它？

Answer 1

单例是一个只允许创建自身的一个实例的类 - 并且可以简单,方便地访问所述实例.单例前提是跨软件开发的模式.

有一个C#实现"在C#中实现Singleton模式"涵盖了你需要知道的大部分内容 - 包括一些关于线程安全的好建议.

说实话,你需要实现一个单例是非常罕见的 - 在我看来,它应该是你应该注意的事情之一,即使它不经常使用.

Answer 2

你问了C#.琐碎的例子:

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

    private static readonly Singleton _singleton = new Singleton();

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

Answer 3

它是什么:在应用程序的生命周期中只有一个持久实例的类.请参见单例模式.

什么时候应该使用它:尽可能少.只有当你完全确定你需要它时.我不愿意说"从不",但通常有一个更好的选择,例如依赖注入或简单的静态类.

Answer 4

另一种在c#中实现singleton的方法,我个人更喜欢这种方式,因为你可以将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
    }

但是,据我所知,这两种方式都被认为是"正确的",所以这只是个人风格.

Answer 5

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和Bar的例子还要好,还有来自Judith Bishop的关于C#3.0的图书设计模式有关于mac dock中活动应用的例子.

如果你查看代码,我们实际上是在for循环上构建新对象,所以创建新对象但重用实例,因为oldbalancer和newbalancer具有相同的实例,如何？由于函数GetLoadBalancer()使用静态关键字,尽管具有不同的服务器值是随机列表,但GetLoadBalancer()上的静态属于类型本身而不是特定对象.

此外,还有双重检查锁定在这里

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

来自MSDN

lock关键字确保一个线程不进入代码的关键部分,而另一个线程处于临界区.如果另一个线程试图输入锁定的代码,它将等待,阻止,直到该对象被释放.

所以每次都会发出互斥锁,即使它不需要也不需要,所以我们进行空检查.

希望它有助于清除更多.

如果我的理解是指导错误的方式,请评论.

Answer 6

Singleton(这与C#无关,它是一种OO设计模式)是您希望在整个应用程序中只允许创建一个类的一个实例.使用通常包括全球资源,虽然我会从个人经验中说,但它们往往是巨大痛苦的根源.

Answer 7

虽然只能有一个单例的实例,但它与静态类不同.静态类只能包含静态方法,并且永远不能实例化,而单例实例的使用方式与任何其他对象相同.