Swift - 没有全局访问权限的单例

Question

我想创建一个没有全局访问权限的 Swift 单例。我想要创建的模式是确保始终只存在一个类的实例，但不应通过通常的全局 MyClass.shared 访问此类。句法。这样做的原因是我希望这个类可以完全和正确地测试(这对于全局单例来说是不可能的)。然后我将使用依赖注入(inject)将单个实例从 viewcontroller 传递到 viewcontroller。因此，无需全局静态实例即可解决“访问”问题。

我能做的基本上就是什么都不做。只需创建一个普通类并相信所有开发人员的纪律，不要一次又一次地实例化此类，而仅将其作为依赖项注入(inject)。但我宁愿有一些编译器强制模式来禁止这种情况。

所以要求是:

• 确保在编译期间只有一个类的实例被实例化
• 没有全局访问权限
• 在单元测试期间不应强制执行只有一个类被实例化的保证，因此可以正确地测试它

我第一次尝试解决这个问题是这样的:

class WebService {
    private static var instances = 0

    init() {
        assertSingletonInstance()
    }

    private func assertSingletonInstance() {
        #if DEBUG
        if UserDefaults.standard.bool(forKey: UserDefaultsKeys.isUnitTestRunning.rawValue) == false {
            WebService.instances += 1
            assert(WebService.instances == 1, "Do not create multiple instances of this class. Get it thru the shared dependencies in your module.")
        }
        #endif
    }
}

备注:在启动期间传递参数会创建一个用户默认值，可以在运行时检查该值。这就是我如何知道当前运行是一个单元测试。

通常这种模式效果很好。我唯一的问题是——我必须为每个可能的单例一遍又一遍地复制这段代码。这不好。我更喜欢可重用的解决方案。

单例协议(protocol)扩展

一个解决方案是创建协议(protocol)扩展:

protocol Singleton {
    static var instances: Int { get set }
    func assertSingletonInstance()
}

extension Singleton {
    // Call this assertion in init() to check for multiple instances of one type.
    func assertSingletonInstance() {
        if UserDefaults.standard.bool(forKey: UserDefaultsKeys.isUnitTestRunning.rawValue) == false {
            Self.instances += 1
            assert(Self.instances == 1, "Do not create multiple instances of this class. Get it thru the shared dependencies in your module.")
        }
        #endif
    }
}

然后这样使用:

class WebService: Singleton {)
    static var instances = 0

    init() {
        assertSingletonInstance()
    }
}

这种方法的问题是 instances变量不是 private .因此有人可以在实例化类之前将此变量设置为 0，这样检查将不再有效。

单例基类

另一个尝试是 Singleton基类。在本例中为 private static var instances可以使用。

class Singleton {
    private static var instances = 0

    required init() {
        assertSingletonInstance()
    }

    private func assertSingletonInstance() {
        #if DEBUG
            if UserDefaults.standard.bool(forKey: UserDefaultsKeys.isUnitTestRunning.rawValue) == false {
                Singleton.instances += 1
                assert(Singleton.instances == 1, "Do not create multiple instances of this class. Get it thru the shared dependencies in your module.")
            }
        #endif
    }
} 

这种方法的问题是 - 它不起作用。递增 Singleton.instance将 static instances 加 1的 Singleton键入而不是派生自 Singleton 的类基类。

现在我要么什么都不做，要么依赖所有开发人员的纪律和理解，要么至少使用协议(protocol)扩展 internal或 public使用权。

可以找到示例实现 here .

也许有人有更好的想法来真正干净地解决这个问题。我感谢任何提示或有关它的讨论。谢谢。

Answer 1

您可以使用原子标志(用于线程安全)将单例标记为已实例化:

class Singleton {

    static private var hasInstance = atomic_flag()

    init() {
        // use precondition() instead of assert() if you want the crashes to happen in Release builds too
        assert(!atomic_flag_test_and_set(&type(of: self).hasInstance), "Singleton here, don't instantiate me more than once!!!")
    }

    deinit {
        atomic_flag_clear(&type(of: self).hasInstance)
    }
}

您在 init 中将单例标记为已分配，并在 deinit 中重置标志。这允许你一方面只有一个实例(如果原始实例没有被释放)，另一方面有多个实例，只要它们不重叠。

应用程序代码:假设您将在某处保留对注入(inject)下游的单例的引用，那么永远不应调用 deinit，这只会导致一种可能的分配。

单元测试代码:如果单元测试正确地进行了清理(被测试的单例在每次测试后被释放)，那么在某个时间点将只有一个活的实例，它赢了'触发断言失败。