Swift中的通用委托实现

Question

Given the class

Calss<A: Type1, B: Type2>

would it be possible to create a delegate(protocol) property inside the class which would use a generic type from the class? eg

protocol CalssDelegate{
    func decorate(first: A, second: B) -> Void
}

In other words, how would I achieve type safety when creating a generic class delegate protocol?

Answer 1

You could let the "generic" delegate types be heterogenous protocols, to which you conform the types that you want generics A and B , respectively, which allows Type1 and Type2 to be used as actual types in the "generic" method blueprints of your delegate protocol.

---

Setting up the generic type constraints Type1 and Type2 (limitation: these must be heterogeneous) and the delegate protocol MyClassDelegate :

/* Generic type constraints */
protocol Type1: CustomStringConvertible {
    init(_ value: Int)
    func foo()
}
protocol Type2: CustomStringConvertible {
    init(_ value: Int)
    func bar()
}

/* Delegate protocol */
protocol MyClassDelegate {
    func decorate(first: Type1, second: Type2) -> Void
}

Setting up two example classes using the "generic" delegate for callbacks from one class to the other.

/* class using the delegate */
class MyDifferentClass<A: Type1, B: Type2> {
    var foo: A = A(0)
    var bar: B = B(0)
    var delegate: MyClassDelegate?

    var someInt : Int = 1 {
        didSet {
            delegate?.decorate(foo, second: bar)
        }
    }
}

/* class conforming to MyClassDelegate */
class MyCurrentClass<A: Type1, B: Type2>: MyClassDelegate {
    var myDifferentClass = MyDifferentClass<A, B>()

    init() {
        myDifferentClass.delegate = self
    }

    // MyClassDelegate
    func decorate(first: Type1, second: Type2) {
        first.foo()
        second.bar()

        print("first: \(first)", "second: \(second)")

        // ...
    }
}

Example types:

/* conforming some types to your generic type (constraint) protocols */
extension Int: Type1 {
    func foo() {
        print("foo!")
    }
}

extension Double: Type2 {
    func bar() {
        print("bar!")
    }
}

Example usage:

/* Example usage */
var a = MyCurrentClass<Int, Double>()

a.myDifferentClass.someInt += 1
/* foo!
   bar!
   first: 0 second: 0.0 */

This method is valid as long as type constraint protocols Type1 and Type2 are heterogeneous, ie, don't contain some associated types themselves.