主页 / coding / 问题 / 79597598
Accepted
HL666
Asked: 2025-04-29 12:18:10 +0800 CST

如何使协议包装器（而非协议本身）符合 Swift 中的 Hashable

  • 772

我有一个仅限于类类型的协议：

protocol Plugin: AnyObject {}

现在我想使用插件作为哈希表的键。我不想让Plugin协议继承自Hashable，因为这样我就得any Plugin在所有地方都写一遍（因为它会从其父协议继承“自身要求”）。

为了解决这个问题，我想创建一个通用包装器。我不想使用AnyHashable，因为我希望在出现错误时使用更严格的类型。

public struct ObjectHashable<T: AnyObject>: Hashable {
  
  public let object: T
  
  public init(object: T) {
    self.object = object
  }
  
  public static func ==(lhs: Self, rhs: Self) -> Bool {
    return ObjectIdentifier(lhs.object) == ObjectIdentifier(rhs.object)
  }
  
  public func hash(into hasher: inout Hasher) {
    hasher.combine(ObjectIdentifier(object))
  }
}

现在我想做类似的事情

typealias PluginHashable = ObjectHashable<Plugin>

然而，这给了我错误：

要求指定为“T”：“AnyObject”[其中T = 任何插件]

所以我把它改成了

typealias PluginHashable = ObjectHashable<any Plugin>

我遇到了同样的错误：

要求指定为“T”：“AnyObject”[其中T = 任何插件]

我的理解是，虽然Plugin协议被限制为类类型，但any Plugin事实并非如此。但是，我不知道下一步该怎么做。

更新：

如果我不使用通用的 for ObjectHashable，它就会起作用：

public struct PluginHashable: Hashable {
  
  public let plugin: Plugin
  
  public init(plugin: Plugin) {
    self.plugin = plugin
  }
  
  public static func ==(lhs: Self, rhs: Self) -> Bool {
    return ObjectIdentifier(lhs.plugin) == ObjectIdentifier(rhs.plugin)
  }
  
  public func hash(into hasher: inout Hasher) {
    hasher.combine(ObjectIdentifier(plugin))
  }
}

但是，这个解决方案仅适用于Plugin协议，因此并不理想。我更希望有一个适用于所有类似情况的解决方案。

swift

1 个回答

  1. Best Answer

    我完全明白你遇到了什么。

    即使Plugin: AnyObject，当你引用 时any Plugin，它也会被视为存在性——而Swift 中的存在性不是类类型，即使它们来自的协议是AnyObject。
    这就是为什么ObjectHashable<T: AnyObject>拒绝接受any Plugin为 的原因T——因为any Plugin它本身不是一个类，即使的实现Plugin必须是。

    为什么任何插件都是问题

    any Plugin 是一个值类型，表示“任何符合 Plugin 的实例”。

    它不能以通用约束可以检查的方式保证它是类型级别的类实例。

    Swift 对待任何插件的方式与符合插件的具体类型不同。

    那么...如何解决你的情况？

    诀窍在于： 您不需要编写ObjectHashable<any Plugin>，而是需要在使用站点上编写， 或者稍微重新设计以接受存在值。
    ObjectHashable<some Plugin>
    ObjectHashable

    适合您情况的干净解决方案

    改变ObjectHashable以接受任何 AnyObject（甚至any Plugin存在）。

    这是稍微更新的版本ObjectHashable：

    public struct ObjectHashable: Hashable {
    public let object: AnyObject

    public init(_ object: AnyObject) {
        self.object = object
    }

    public static func ==(lhs: Self, rhs: Self) -> Bool {
        return ObjectIdentifier(lhs.object) == ObjectIdentifier(rhs.object)
    }

    public func hash(into hasher: inout Hasher) {
        hasher.combine(ObjectIdentifier(object))
    }
}

    现在你无需担心泛型了。
    你可以存储任何类对象（包括经过any Plugin正确包装的对象）。

    用法：

    
var dict: [ObjectHashable: String] = [:]
let pluginInstance: any Plugin = SomePlugin()
dict[ObjectHashable(pluginInstance)] = "some value"

    但是你要求严格（不要太开放AnyObject）......

    如果您仍然希望将其仅限于插件（而不是任何类），那么您可以按照以下更严格的方式进行操作：

    public struct PluginHashable: Hashable {
    public let plugin: any Plugin

    public init(_ plugin: any Plugin) {
        self.plugin = plugin
    }

    public static func ==(lhs: Self, rhs: Self) -> Bool {
        return ObjectIdentifier(lhs.plugin as AnyObject) == ObjectIdentifier(rhs.plugin as AnyObject)
    }

    public func hash(into hasher: inout Hasher) {
        hasher.combine(ObjectIdentifier(plugin as AnyObject))
    }
}

    - 这确保您只能包装any Plugin，而不能包装任何 AnyObject。
    - 并且您仍然可以根据对象标识进行散列。

    用法：

    var pluginDict: [PluginHashable: String] = [:]
let p1: any Plugin = MyPlugin()
let p2: any Plugin = MyOtherPlugin()
pluginDict[PluginHashable(p1)] = "First Plugin"
pluginDict[PluginHashable(p2)] = "Second Plugin"

    为什么不能使用ObjectHashable<Plugin>？

    因为ObjectHashable<T: AnyObject>期望一个类类型 T，
    但any Plugin它不是一个类类型——它是一个存在值。

    您必须执行以下操作之一：

    • 制作ObjectHashable非通用的，存储AnyObject，或

    • 使其专门用于您的协议（如上PluginHashable）。

    希望以上信息对您有所帮助。如果您的问题解决了，请告诉我。

    编辑：

    既然您提到之前的解决方案不适合您，我将遵循评论中的建议：专门针对类的存在性使用 ObjectHashable。

    你可以这样做：

    public struct ObjectHashable<T>: Hashable {
    public let object: T

    public init(_ object: T) {
        self.object = object
    }

    public static func ==(lhs: ObjectHashable<T>, rhs: ObjectHashable<T>) -> Bool {
        ObjectIdentifier(lhs.object as AnyObject) == ObjectIdentifier(rhs.object as AnyObject)
    }

    public func hash(into hasher: inout Hasher) {
        hasher.combine(ObjectIdentifier(object as AnyObject))
    }
}

    请仔细注意：

    • T是通用的。

    • 在运行时，我们AnyObject==在和内部手动hash(into:)转换为。

    • 编译时，您仍然可以进行严格的类型检查ObjectHashable<Plugin>等。

    现在使用起来非常干净：

    typealias PluginHashable = ObjectHashable<任何插件>

    var pluginDict: [PluginHashable: String] = [:]
let plugin1: any Plugin = MyPlugin()
let plugin2: any Plugin = AnotherPlugin()
pluginDict[PluginHashable(plugin1)] = "Plugin 1"
pluginDict[PluginHashable(plugin2)] = "Plugin 2"

    通过这种方式，您可以获得：
    - 编译时严格执行类型。
    - 也可用于其他仅限类的协议，而无需每次都使用自定义包装器。

    如果您想要更严格的可选编译时保护，您可以添加运行时断言，这将禁止滥用（例如：有人试图传递结构），您将得到如下代码：

    public init(_ object: T) {
    precondition(Mirror(reflecting: object).subjectType is AnyObject.Type, "T must be a class type")
    self.object = object
}

    不过说实话，既然你手动选择了any Plugin别名PluginHashable，那就没问题了。除非你超级偏执，否则没必要进行运行时检查，哈哈。

    • 0

相关问题