Faul - /inline-Umsetzung eines Protokolls in Swift

Was du suchst, ist eine innere Klasse (nicht unbedingt eine anonyme eins), erklärte in einem Bereich, ermöglicht es den Zugriff auf die count variable MyClass Instanz, und das nimmt ein Protokoll definiert, in einem anderen Bereich. Jetzt Swift hat ein paar der Stücke, aber es sieht nicht wie Sie können setzen Sie alle zusammen in einer Weise, die so prägnant wie das, was Sie vielleicht gesucht werden.

Man könnte meinen, über die Deklaration einer inneren Klasse:

class MyView: UIView {
    let someComponent = SomeInnerComponent() //type SomeInnerComponent is inferred
    var count = 0 //type Int is inferred
    class Helper: SomeProtocol {
        func a0() { count-- } //ERROR
        //...
    }
    init() {
        someComponent.delegate = Helper()
    }
}

Aber das wird nicht funktionieren, weil count implizit self.count, wo self ist ein Helper Instanz, nicht die MyView Instanz, die "Eigentümer" der Helper Instanz. Und gibt es nicht eine Möglichkeit verweisen, dass MyView Instanz (bzw. seine Eigenschaften) innerhalb eines Helper's Methoden, da könnte man genauso gut konstruieren MyView.Helper() ohne eine vorhandene MyView Instanz. Innere Klassen (oder geschachtelte Typen im Allgemeinen) im Swift-nest nur im lexikalischen Bereich, nicht in existenzielle Eigentum. (Oder um es anders zu sagen, da Sie verwiesen Java: alle inneren Klassen in Swift sind wie statische innere Klassen in Java. Es gibt keine nicht-statischen inneren Klasse.) Wenn das eine Funktion, die Sie möchten, obwohl, wahrscheinlich ist es es Wert, erzählt Apple, dass Sie es wollen.

Könnte man auch versuchen, die Deklaration Helper innen MyView.init() -- in Swift können Sie nest-Typ-Definitionen überall, auch innerhalb von Funktionen oder Methoden von anderen Arten. Dort definiert, es kann beziehen sich auf MyView's Eigenschaften. Nun ist aber die Typ-Informationen für Helper ist nur sichtbar in der MyView.init(), so dass, wenn Sie zuweisen someComponent.delegate (deren Typ ist einfach SomeProtocol), können Sie nicht nutzen... dieser stürzt der compiler auch. (Das ist eine andere bug report, aber es ist schwer zu sagen, ob der bug ist wirklich "compiler stürzt auf gültige Verwendung" oder "code ist schlecht, aber der compiler stürzt ab, anstatt Fehler".)

Die nächste Lösung, die ich mit oben kommen kann sieht man hier:

class SomeInnerComponent {
    var delegate: SomeProtocol?
}
protocol SomeProtocol {
    func a0()
    func a1()
}
class MyClass  {
    var someComponent = SomeInnerComponent()
    var count = 0
    struct Helper: SomeProtocol {
        var dec: () -> ()
        var inc: () -> ()
        func a0() { dec() }
        func a1() { inc() }
    }
    init() {
        someComponent.delegate = Helper(
            dec: { self.count -= 1 }, //see note below
            inc: { self.count += 1 }
        )
    }
}

Wie es funktioniert:

• Helper ist eine innere Struktur (könnte eine Klasse sein, aber eine Struktur ist einfacher)
• Es implementiert die a0 und a1 Methoden, die Befriedigung der Anforderungen der SomeProtocol
• Die Implementierungen der a0 und a1 Anruf durch, um die Verschlüsse dec und inc gespeicherten Eigenschaften (aka Instanz-Variablen) der Helper struct
• Sie schreiben (oder anderweitig angeben) diese Verschlüsse, wenn Sie konstruieren eine Helper Instanz (mithilfe der Standard-Mitglied-Weise-Initialisierer, Helper(dec: (Void -> Void), inc: (Void -> Void)))
• Weil Sie schreiben können, sind die Verschlüsse beim initialisieren Helper, diese Verschlüsse erfassen können Variablen, von wo Sie anrufen die Initialisierung, einschließlich der impliziten self bezieht sich auf den MyClass Instanz erstellen der Helper.

Müssen Sie beide a0/a1 und dec/inc weil Sie brauchen, Verschlüsse (die letztere), nicht die Methoden, für die Erfassung der einschließenden Staat. Und obwohl Verschlüsse und funcs/Methoden sind in vielerlei Hinsicht austauschbar, Sie können nicht erstellen Sie eine Methode/func Umsetzung durch die Zuweisung einer closure an eine Methode/func-name. (Es wäre eine andere Geschichte, wenn SomeProtocol erforderlich abschlusseigenschaften anstelle von Methoden, aber ich gehe davon aus SomeProtocol ist nicht etwas, das unter Ihrer Kontrolle.)

Sowieso, das ist eine Menge von boilerplate und eine Ebene der Abstraktion, die Sie nicht wirklich brauchen, so es ist wahrscheinlich lohnt ein Blick in andere Wege zu Architekten in Ihren code ein.

Anmerkung: mein Beispiel verwendet die Schließung { self.count -= 1 } wo man erwarten könnte { self.count-- }. Letzteres funktioniert nicht, weil das eine Ausdruck mit einem Wert, so wird Swift interpretieren es als Kurzformel für die Schließung ist die Rückkehr Wert. Dann werden die sich beschweren, dass Sie zugewiesen () -> Int - Verschluss, um eine Eigenschaft, die erwartet, dass ein () -> () (aka Void -> Void) Verschluss. Mit -= 1 statt arbeitet, um dieses Problem.