Question

的后续问题

由于我的英语技能缺乏描述问题，我将不得不布置问题并描述我当前（有缺陷的）实现。问题的基本要点是我想要一个中央系统其他系统可以注册并接收一堆所谓的Value。

让我们说System A和System B在Central System Manager (CSM)注册。

CSM保存对这两个系统的引用并分派一些Value个，如果有新的。系统有一个接收处理程序，在那里他们可以挑选出他们感兴趣的值（但是他们总是会收到所有值 - 作为字典）。

所以我的设置如下：

// The ValueIDs are a unique way to identify the different value types
enum ValueIDs: Int {
    case DistanceValueId = 0
    case SpeedValueId = 1
}

// A very generic value class
class Value: Hashable {
    var id: Int

    var hashValue: Int {
        return id.hashValue
    }

    var value: Any

    static func ==(lhs: Value, rhs: Value) -> Bool {
        return lhs.id == rhs.id
    }

    init(id: Int = 0, value: Any) {
        self.id = id
        self.value = value
    }
}

// These are concrete value implementations
class DistanceValue: Value {
    override init(id: Int = 0, value: Any) {
        super.init(id: ValueIDs.DistanceValueId.rawValue, value: value)
    }
}

class DescriptionValue: Value {
    override init(id: Int = 0, value: Any) {
        super.init(id: ValueIDs.SpeedValueId.rawValue, value: value)
    }
}

// The `Value`s dictionary is being initialized and appended with concrete implementations
// of `Value`
var values: [Int: Any] = [:]

let intV = DistanceValue(value: 123)
let stringV = DescriptionValue(value: "Hello")

func addValue(_ value: Value) {
    values[value.id] = value.value
}

addValue(intV)
addValue(stringV)

// The is the point where the systems, i.e. `System A` and `System B`
// would receive the `values` dictionary and would pick out the values that
// they are interested in.
// `System A`, for example, would only be interested in `DistanceValue`
let testInt: Int = values[ValueIDs.DistanceValueId.rawValue] as! Int

// `System B` would only be interested in the `SpeedValue`
let testString: String = values[ValueIDs.SpeedValueId.rawValue] as! String

当前的实施工作正常，但我想阻止System级别的向下转发。有没有更好的方式/设计来实现我正在尝试的东西，或者是否有办法进一步推动低迷，所以System不需要这样做？

Answer 1

通过使用带有关联值的枚举，您可以获得更好的结果：

enum Value {
    case distance(Int)
    case speed(Int)
}

extension Value: Equatable {
    static func ==(lhs: Value, rhs: Value) -> Bool {
        switch (lhs, rhs) {
        case let (.distance(value1), .distance(value2)),
             let (.speed(value1), .speed(value2)):
            return value1 == value2
        default: return false
        }
    }
}

extension Value: Hashable {
    var hashValue: Int {
        switch self {
            case let .distance(value),
                 let .speed(value):
            return value.hashValue
        }
    }
}

，并将枚举值存储在数组中而不是字典中。

防止向下压力

1 个答案: