当前位置：首页 > news >正文

C#的单继承限制下实现派生类ChildClass既继承BaseClass又成为单例的方法

news 2026/6/6 5:16:03

在 C# 中，类只能继承一个父类（单继承限制）。当前 Singleton 是通过继承实现的，因此如果 ChildClass 既要继承 BaseClass 又要成为单例，直接使用当前的 Singleton 实现会遇到继承冲突。

解决方案

方案一：使用组合模式（推荐）

让 ChildClass 继承 BaseClass ，同时内部持有一个单例实例，通过静态属性暴露。

public class BaseClass
{
    // 基类逻辑
}public class ChildClass : BaseClass
{
    private static ChildClass 
    _instance;
    private static readonly object 
    _locker = new object();    private ChildClass() : base() 
    { }    public static ChildClass 
    Instance
    {
        get
        {
            if (_instance == null)
            {
                lock (_locker)
                {
                    if (_instance 
                    == null)
                    {
                        _instance = 
                        new 
                        ChildClass
                        ();
                    }
                }
            }
            return _instance;
        }
    }
}

方案二：修改 Singleton 实现为接口+扩展方法

将 Singleton 改为接口，通过扩展方法提供单例功能，这样 ChildClass 可以同时继承 BaseClass 并实现 ISingleton 接口。

// 定义单例接口
public interface ISingleton
{
    void Init();
}// 扩展方法实现单例逻辑
public static class 
SingletonExtensions
{
    private static readonly 
    Dictionary<Type, object> 
    _instances = new 
    Dictionary<Type, object>();
    private static readonly object 
    _locker = new object();    public static T GetInstance<T>
    (this T instance) where T : 
    class, ISingleton, new()
    {
        lock (_locker)
        {
            if (!_instances.
            TryGetValue(typeof(T), 
            out var obj))
            {
                obj = new T();
                ((ISingleton)obj).
                Init();
                _instances[typeof
                (T)] = obj;
            }
            return (T)obj;
        }
    }
}// 使用方式
public class BaseClass
{
    // 基类逻辑
}public class ChildClass : 
BaseClass, ISingleton
{
    public void Init()
    {
        // 初始化逻辑
    }
}// 访问方式
var instance = default(ChildClass).
GetInstance();

方案三：调整继承结构

如果 BaseClass 本身不需要实例化，可以让 BaseClass 继承 Singleton ，然后 ChildClass 继承 BaseClass 。但这种方式的单例实例类型是 BaseClass ，不是 ChildClass 。

public class BaseClass : 
Singleton<BaseClass>
{
    // 基类逻辑
}public class ChildClass : BaseClass
{
    // 子类逻辑
}// 访问方式（只能通过 BaseClass.
instance 访问，类型为 BaseClass）
var instance = BaseClass.instance;