继承实现单例模式的探索(一)

前言

之前看到朋友采用继承的方式来实现单例模式,觉得很厉害,随后自己去探索了一番,以前实现单例模式都是把代码内联到具体的类中,这使得工程中每次需要使用单例模式时,都采用拷贝的方式,增加了很多冗余代码,并且难以规范单例的统一标准,使得代码不方便扩展和管理。这次探索找到了一种实现方式,先记录下来,后续如果有其它方式再发表系列文章,示例代码为C#。

代码

v1.0版本

cs 复制代码
using System;

/// <summary>
/// 单例模式基类
/// </summary>
/// <typeparam name="T">单例类型</typeparam>
public abstract class Singleton<T>
where T : class, new()
{
    public static T instance => _instance.Value;
    static bool _unlock;
    static readonly Lazy<T> _instance = new Lazy<T>(() =>
    {
        _unlock = true;
        return new T();
    });

    protected Singleton()
    {
        if (!_unlock)
            throw new InvalidOperationException("Singleton:The ctor is proxied by singleton and cannot be called from outside.");
        _unlock = false;
    }
}

v1.1

cs 复制代码
using System;

/// <summary>
/// 单例模式基类
/// </summary>
/// <typeparam name="T">单例类型</typeparam>
public abstract class Singleton<T>
where T : class, new()
{
    public static T instance => _instance.Value;
    static bool _unlock;
    static readonly Lazy<T> _instance = new Lazy<T>(Create);

    static T Create()
    {
        _unlock = true;
        T item = new T();
        _unlock = false;
        return item;
    }

    protected Singleton()
    {
        if (!_unlock)
            throw new InvalidOperationException("Singleton:The ctor is proxied by singleton and cannot be called from outside.");
    }
}

测试

单例基类

cs 复制代码
using System;

/// <summary>
/// 单例模式基类
/// 版本1.0
/// </summary>
/// <typeparam name="T">单例类型</typeparam>
// public abstract class SingletonWithTest<T>
// where T : class, new()
// {
//     public static T instance => _instance.Value;
//     static bool _unlock;
//     static readonly Lazy<T> _instance = new Lazy<T>(() =>
//     {
//         _unlock = true;
//         return new T();
//     });

//     protected SingletonWithTest()
//     {
//         if (!_unlock)
//         {
//             // throw new InvalidOperationException("Singleton:The ctor is proxied by singleton and cannot be called from outside.");
//             Console.WriteLine($"Singleton({GetHashCode()}):The ctor is proxied by singleton and cannot be called from outside.");
//             return;
//         }
//         _unlock = false;
//         Console.WriteLine("*************************");
//     }
// }

/// <summary>
/// 单例模式基类
/// 版本1.1
/// </summary>
/// <typeparam name="T">单例类型</typeparam>
public abstract class SingletonWithTest<T>
where T : class, new()
{
    public static T instance => _instance.Value;
    static bool _unlock;
    static readonly Lazy<T> _instance = new Lazy<T>(Create);

    static T Create()
    {
        _unlock = true;
        T item = new T();
        _unlock = false;
        return item;
    }

    protected SingletonWithTest()
    {
        if (!_unlock)
        {
            // throw new InvalidOperationException("Singleton:The ctor is proxied by singleton and cannot be called from outside.");
            Console.WriteLine($"Singleton({GetHashCode()}):The ctor is proxied by singleton and cannot be called from outside.");
            return;
        }
        Console.WriteLine("*************************");
    }
}

单例继承类

cs 复制代码
public class TestA : SingletonWithTest<TestA>
{
    public readonly string key;

    public TestA() { key = "Default A"; }
    public TestA(string key) { this.key = key; }
}

public class TestB : SingletonWithTest<TestB>
{
    public readonly string key;

    public TestB() { key = "Default B"; }
    public TestB(string key) { this.key = key; }
}

public class TestC : SingletonWithTest<TestC>
{
    public readonly string key;

    public TestC() { key = "Default C"; }
    public TestC(string key) { this.key = key; }
}

public class TestD : SingletonWithTest<TestD>
{
    public readonly string key;

    public TestD() { key = "Default D"; }
    public TestD(string key) { this.key = key; }
}

public class TestE : SingletonWithTest<TestE>
{
    public readonly string key;

    public TestE() { key = "Default E"; }
    public TestE(string key) { this.key = key; }
}

public class TestF : SingletonWithTest<TestF>
{
    public readonly string key;

    public TestF() { key = "Default F"; }
    public TestF(string key) { this.key = key; }
}

测试代码

cs 复制代码
// ********************************* 创建实例测试:通过 ********************************* 

// 直接创建实例测试:通过
// TestA a = new TestA(); // 无法通过 new + 无参ctor 创建实例
// TestA a1 = new TestA("A1"); // 无法通过 new + 有参ctor 创建实例
// TestA a2 = Activator.CreateInstance<TestA>(); // 无法通过 Activator 创建实例
// TestA? a2 = Activator.CreateInstance(typeof(TestA), "A1") as TestA; // 无法通过 Activator 创建实例

// ********************************* 线程安全测试:通过 *********************************

Thread t1, t2, t3, t4, t5, t6;

// 打印同一单例的 HashCode 测试:通过
t1 = new Thread(() => Console.WriteLine("Thread1:" + TestA.instance.GetHashCode()));
t2 = new Thread(() => Console.WriteLine("Thread2:" + TestA.instance.GetHashCode()));
t3 = new Thread(() => Console.WriteLine("Thread3:" + TestA.instance.GetHashCode()));
t4 = new Thread(() => Console.WriteLine("Thread4:" + TestA.instance.GetHashCode()));
t5 = new Thread(() => Console.WriteLine("Thread5:" + TestA.instance.GetHashCode()));
t6 = new Thread(() => Console.WriteLine("Thread6:" + TestA.instance.GetHashCode()));

// 使用单例的同时直接创建该单例类型实例测试:通过
// t1 = new Thread(() => Console.WriteLine("Thread1:" + TestA.instance.GetHashCode()));
// t2 = new Thread(() => Console.WriteLine("Thread2:" + new TestA().GetHashCode()));
// t3 = new Thread(() => Console.WriteLine("Thread3:" + new TestA().GetHashCode()));
// t4 = new Thread(() => Console.WriteLine("Thread4:" + new TestA().GetHashCode()));
// t5 = new Thread(() => Console.WriteLine("Thread5:" + new TestA().GetHashCode()));
// t6 = new Thread(() => Console.WriteLine("Thread6:" + new TestA().GetHashCode()));

// 同时使用不同单例的测试:通过
// t1 = new Thread(() => Console.WriteLine("Thread1:" + TestA.instance.GetHashCode()));
// t2 = new Thread(() => Console.WriteLine("Thread2:" + TestB.instance.GetHashCode()));
// t3 = new Thread(() => Console.WriteLine("Thread3:" + TestC.instance.GetHashCode()));
// t4 = new Thread(() => Console.WriteLine("Thread4:" + TestD.instance.GetHashCode()));
// t5 = new Thread(() => Console.WriteLine("Thread5:" + TestE.instance.GetHashCode()));
// t6 = new Thread(() => Console.WriteLine("Thread6:" + TestF.instance.GetHashCode()));

// 使用单例的同时创建其它单例类型的实例测试:通过
// t1 = new Thread(() => Console.WriteLine("Thread1:" + TestA.instance.GetHashCode()));
// t2 = new Thread(() => Console.WriteLine("Thread2:" + new TestB().GetHashCode()));
// t3 = new Thread(() => Console.WriteLine("Thread3:" + new TestC().GetHashCode()));
// t4 = new Thread(() => Console.WriteLine("Thread4:" + new TestD().GetHashCode()));
// t5 = new Thread(() => Console.WriteLine("Thread5:" + new TestE().GetHashCode()));
// t6 = new Thread(() => Console.WriteLine("Thread6:" + new TestF().GetHashCode()));

t1.Start();
t2.Start();
t3.Start();
t4.Start();
t5.Start();
t6.Start();

t1.Join();
t2.Join();
t3.Join();
t4.Join();
t5.Join();
t6.Join();

优缺点分析

| 优点 | 1.通过继承实现单例; 2.可以通过单例基类规范统一标准; 3.线程安全; 4.无法通过除单例基类提供的静态属性instance以外的其它方式获取其派生类实例,外部通过new关键字显示调用构造函数或反射等其它获取实例的方式创建派生类实例将触发异常; 5.派生类的无参构造函数用于初始化; 6.按需加载,延迟初始化。 |

缺点 1.要求派生类的无参构造函数公开; 2.派生类对外部始终开放无参构造函数,无法避免new关键字的显式调用所触发的异常;

版本改进

| V1.1 | 1.将延迟初始化的工厂方法从Lambda表达式替换为本地静态方法,因为_unlock相对于Lazy<T>是外部引用,所以不可避免存在创建闭包的开销,所以改为本地静态方法进行改进; 2._unlock在构造函数中进行重置会存在线程安全的问题,放在作为延迟初始化的工厂方法的本地静态方法中可以保证线程安全。 |

......

如果这篇文章对你有帮助,请给作者点个赞吧!

相关推荐
IT规划师3 小时前
开源 - Ideal库 - 常用枚举扩展方法(一)
开源·c#·.net core·ideal库·枚举转换
NetX行者9 小时前
.NET 9震撼来袭:基于.NET 8的五大功能亮点,引领开发新潮流
开发语言·microsoft·c#·.netcore
张某布响丸辣9 小时前
HTTP状态码详解
java·网络·python·网络协议·http·c#
飞舞的哈哈10 小时前
C# 有趣的小程序—桌面精灵详细讲解
c#
Skyshin3412 小时前
C# IEnumerator,IEnumerable ,Iterator
开发语言·c#
ling1s12 小时前
C#核心(7)索引器
开发语言·c#
LKID体13 小时前
win32com库基于wps对Word文档的基础操作
c#·word·wps
金蝶软件小李14 小时前
vector和docker的区别?
开发语言·docker·c#
金蝶软件小李15 小时前
图像处理椒盐噪声
开发语言·图像处理·算法·计算机视觉·c#
小吴同学·16 小时前
(实战)WebApi第13讲:怎么把不同表里的东西,包括同一个表里面不同的列设置成不同的实体,所有的给整合到一起?【前端+后端】、前端中点击标签后在界面中显示
c#·.netcore·.net core