我想制作能够采用可解析类型或可解析类型数组的泛型类。两者的逻辑几乎相同，所以我不想为这个操作创建两个不同的类。是否可以使用 Swift 泛型或协议(protocol)关联类型类型来解决它？

protocol Parsable: class {
    associatedtype Type
    static func objectFromDictionary(dictionary: Dictionary<String, AnyObject>, inContext context: NSManagedObjectContext) -> Type?
    func importFromDictionary(dictionary: Dictionary<String, AnyObject>)
}

class ParseOperation<T: Parsable>: NSOperation {
    func execute() -> T {

    }
}

class ParseOperation<T where T: SequenceType, T.Generator.Element == Parsable>: NSOperation {
    func execute() -> T {
        // Do parsing
    }
}

我想这样工作:

class ParseOperation<T where T: SequenceType, T.Generator.Element == Parsable OR T: Parsable>: NSOperation {
    func execute() -> T {
        // Do parsing
    }
}

在我当前的实现中，我使用的是枚举，它看起来有点难看:

class ParseOperation<T where T: NSManagedObject, T:Parsable>: NSOperation {
    var responseToParse: AnyObject?
    var parseType: ParseType

    var parsedObjects: [T]?

    init(parseType: ParseType) {}

    func execute() {
        var objects: [NSManagedObject] = []

        if self.parseType == .Single {
            if let responseToParse = self.responseToParse as? Dictionary<String, AnyObject>,
                let parsedObject = T.objectFromDictionary(responseToParse, inContext: localContext) {
                objects.append(parsedObject)
            }
        } else if self.parseType == .Array {
            if let responseToParse = self.responseToParse as? Array<Dictionary<String, AnyObject>> {
                for dictionary in responseToParse {
                    if let parsedObject = T.objectFromDictionary(dictionary, inContext: localContext) {
                        objects.append(parsedObject)
                    }
                }
            }
        }
        self.parsedObjects = objects
        ...
    }
}

最佳答案

我修改了@RonaldMartin 的答案以显示ParsableArray 可能如何帮助您。它不需要接受 Parsable 元素的输入，只需这样实现 parse 函数:

protocol Parsable {
    associatedtype T

    static func parse(input: AnyObject) -> T?
}

struct ParsableArray<TElement where TElement: Parsable>: Parsable {
    static func parse(input: AnyObject) -> [TElement.T]? {
        guard let arrayInput = input as? [AnyObject] else {
            return nil
        }

        return arrayInput.flatMap(TElement.parse)
    }
}

我已将 objectFromDictionary 重命名为 parse 因为它需要采用 AnyObject 而不是 Dictionary 才能能够解析数组。当然，您可以添加 context 或任何您喜欢的 parse 方法。

如果 Parsable 这样做，那么 ParseOperation 就变得非常简单:

class ParseOperation<T where T: Parsable>: NSOperation {
    let input: AnyObject

    var result: T.T?

    init(input: AnyObject) {
        self.input = input
    }

    override func main() {
        result = T.parse(input)
    }
}

然后，你可以这样解析数组(注意:这只是为了演示如何创建ParseOperation；S只是一些Parsable 结构):

let op = ParseOperation<ParsableArray<S>>(input: [["1": 5, "2": 6], ["3": 10]])
op.main()

var r: [S]? = op.result

我希望这会有所帮助。

关于ios - 可以采用元素数组或单个元素的 Swift 泛型类，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/37061345/