C# 中的单例设计模式

作者 : 慕源网 本文共2324个字,预计阅读时间需要6分钟 发布时间: 2022-03-29 共115人阅读

什么是单例设计模式?

C#中的单例设计模式是最流行的设计模式之一。在这种模式下,一个类在程序中只有一个实例,它提供了一个全局访问点。换句话说,单例是一个类,它只允许创建其自身的一个实例,并且通常提供对该实例的简单访问。
有多种方法可以在 C# 中实现单例模式。以下是单例模式的共同特征。
  • 私有且无参数的单个构造函数
  • 密封类。
  • 用于保存对单个创建实例的引用的静态变量
  • 获取对已创建实例的引用的公共和静态方式。

强烈推荐

海量程序代码,编程资源,无论你是小白还是大神研究借鉴别人优秀的源码产品学习成熟的专业技术强势助力帮你提高技巧与技能。在此处获取,给你一个全面升级的机会。只有你更值钱,才能更赚钱

如果你是初级程序员可以研究别人的代码提高技术,如果你喜欢搞网盟或者外包,可以让你快速建站,还等什么赶快关注吧,我们会持续输出相关资源

海量源码程序,学习别人的产品设计思维与技术实践

单例设计模式的优点

单例模式的优点是,
  1. 单例模式可以实现接口。
  2. 可以延迟加载并具有静态初始化。
  3. 它有助于隐藏依赖关系。
  4. 它提供对特定实例的单点访问,因此易于维护。

单例设计模式的缺点

单例模式的缺点是,
  1. 单元测试有点困难,因为它将全局状态引入应用程序
  2. 通过锁定减少程序内并行的可能性。

单例类与静态方法

下面比较 Singleton 类与静态方法,
  1. 静态类不能扩展,而单例类可以扩展。
  2. 静态类不能初始化,而单例类可以。
  3. 当加载包含该类的程序时,CLR 会自动加载静态类。

如何在 C# 代码中实现单例模式

有几种方法可以在 C# 中实现单例模式。
  1. 没有线程安全的单例。
  2. 线程安全单例。
  3. 使用双重检查锁定的线程安全单例。
  4. 没有锁的线程安全。
  5. 使用 .NET 4 的 Lazy<T> 类型。

没有线程安全的单例

以下代码的解释,
  1. 以下代码不是线程安全的。
  2. 两个不同的线程都可以评估测试(如果 instance == null)并发现它是真的,然后都创建实例,这违反了单例模式。
public sealed class Singleton1 {  
    private Singleton1() {}  
    private static Singleton1 instance = null;  
    public static Singleton1 Instance {  
        get {  
            if (instance == null) {  
                instance = new Singleton1();  
            }  
            return instance;  
        }  
    }  
}  

线程安全单例

以下代码的解释,
  1. 以下代码是线程安全的。
  2. 在代码中,线程被锁定在一个共享对象上并检查一个实例是否已经创建。它解决了内存屏障问题并确保只有一个线程会创建一个实例。例如:由于一次只能有一个线程在该部分代码中,当第二个线程进入它时,第一个线程将创建实例,因此表达式将评估为假。
  3. 最大的问题是性能。由于每次请求实例时都需要锁定,因此性能会受到影响。
public sealed class Singleton2 {  
    Singleton2() {}  
    private static readonly object lock = new object();  
    private static Singleton2 instance = null;  
    public static Singleton2 Instance {  
        get {  
            lock(lock) {  
                if (instance == null) {  
                    instance = new Singleton2();  
                }  
                return instance;  
            }  
        }  
    }  
}  

使用双重检查锁定的线程安全单例

以下代码的解释,

在下面的代码中,线程被锁定在一个共享对象上,并通过双重检查检查实例是否已创建。
public sealed class Singleton3 {  
    Singleton3() {}  
    private static readonly object lock = new object();  
    private static Singleton3 instance = null;  
    public static Singleton3 Instance {  
        get {  
            if (instance == null) {  
                lock(lock) {  
                    if (instance == null) {  
                        instance = new Singleton3();  
                    }  
                }  
            }  
            return instance;  
        }  
    }  
}  

不使用锁且不延迟实例化的线程安全单例

下面代码的解释:
  1. 前面的实现看起来像一个非常简单的代码。
  2. 这种类型的实现有一个静态构造函数,因此每个应用程序域只执行一次。
  3. 它不像其他实现那样懒惰。
public sealed class Singleton4    
{    
    private static readonly Singleton4 instance = new Singleton4();    
    static Singleton4()    
    {    
    }    
    private Singleton4()    
    {    
    }    
    public static Singleton4 Instance    
    {    
        get    
        {    
            return instance;    
        }    
    }    
}

使用 .NET 4 的 Lazy<T> 类型

下面代码的解释:
  1. 如果您使用的是 .NET 4 或更高版本,则可以使用 System.Lazy<T> 类型来使懒惰变得非常简单。
  2. 您可以将委托传递给调用 Singleton 构造函数的构造函数,这使用 lambda 表达式最容易完成。
  3. 允许您检查是否已使用 IsValueCreated 属性创建实例。
public sealed class Singleton5    
{    
    private Singleton5()    
    {    
    }    
    private static readonly Lazy<Singleton5> lazy = new Lazy<Singleton5>(() => new Singleton5());    
    public static Singleton5 Instance    
    {    
        get    
        {    
            return lazy.Value;    
        }    
    }    
}  
希望你喜欢这篇文章。请在评论部分告诉我反馈。

慕源网 » C# 中的单例设计模式

常见问题FAQ

程序仅供学习研究,请勿用于非法用途,不得违反国家法律,否则后果自负,一切法律责任与本站无关。
请仔细阅读以上条款再购买,拍下即代表同意条款并遵守约定,谢谢大家支持理解!

发表评论

开通VIP 享更多特权,建议使用QQ登录