Unite Typen unter einem Protokoll

Question

Was ist der beste Weg, um zu nicht verwandten Typen unter einem Protokoll, z. diesen neuen Typ als Elementtyp für ein Array zu verwenden?

z.B.: von Drittanbietern bereitgestellte Klasse Foo und Klasse Bar nicht verwandt sind, jedoch würde Ich mag ein Array erstellen, die Bar Elemente der Typen Foound enthält. Beachten Sie, dass ich die Implementierung von Foo und Bar nicht direkt ändern kann.

Ein Ansatz könnte sein:

protocol FooBar {} 
extension Foo: FooBar {} 
extension Bar: FooBar {} 

Doch dies scheint mir seltsam und eher unattraktiv, da es keine Implementierungen sind - gibt es andere Möglichkeiten?

Ich werde durch dieses Array aufzählen und die Elemente mit der Kenntnis, dass es entweder Foo oder Bar innerhalb sein kann.

Answer 1

nicht die Antwort direkt auf Ihre Frage, aber wenn man bedenkt, dass man nur durch das Array zu durchlaufen möchten, die Foo s enthält und Bar s Sie enum wie verwenden:

enum FooBar { 
    case WrappedFoo(Foo) 
    case WrappedBar(Bar) 
} 

Das werden Sie zumindest speichern aus as? mit jedem Element zu tun, um den genauen Typ zu erhalten, mit dem Sie es zu tun haben.

Beispiel:

// Some setup 
var arr: [FooBar] = [] 

let foo = Foo() 
let bar = Bar() 

arr.append(.WrappedFoo(foo)) 
arr.append(.WrappedFoo(foo)) 
arr.append(.WrappedBar(bar)) 
arr.append(.WrappedFoo(foo)) 
arr.append(.WrappedBar(bar)) 
arr.append(.WrappedBar(bar)) 

// Enumeration 
arr.forEach { 
    switch $0 { 
    case .WrappedFoo(let foo): 
     // do something with `foo` 
    case .WrappedBar(let bar): 
     // do something with `bar` 
    } 
}