Wie beobachtet man ein Array von NSObjects in swift?

Question

Ich bin neu in der schnellen Sprache und mein Problem ist, wie beobachtbar/Beobachter Muster in Swift verwenden.

Ich möchte, dass mein Array in meiner SocketManager-Klasse beobachtbar ist, damit es von meiner UIViewController-Klasse beobachtet werden kann. Ich habe die Klasse Observable geschrieben von Andrew J Wagner verwendet, die ich von diesem Link bekam:

http://www.drewag.me/posts/swift-kvo-substitute-observable-variables

Ich habe das Array:

var marketIndexList: Array < market> = []

welches seine Daten von einem Server erhält. Diese Liste wird jedes Mal aktualisiert, wenn neue Daten vom Server empfangen werden. Nachdem ich die Werte meines Array von Server bekam ich will es vom Typ Klasse Observable machen, die durch den obigen Link implementiert:

marketIndexList = beobachtbare (marketIndexList)

Aber ich habe diesen Fehler:

"MarketIndex" ist nicht identisch mit "AnyObject"

MarketIndex ist eine Klasse vom Typ NSObject, die einige Eigenschaften vom Typ String hat.

Dies ist die Klasse Observable, die ich verwendet habe:

import Foundation 


class Observable { 
    typealias DidChangeHandler = (oldValue: Array<MarketIndex>?, newValue: Array<MarketIndex>) ->() 

    var value : Array<MarketIndex> = [] { 
     didSet { 
      for (owner, handlers) in self.observers { 
       for handler in handlers { 
        handler(oldValue: oldValue, newValue: value) 
       } 
      } 
     } 
    } 

    init(_ value: Array<MarketIndex>) { 
     self.value = value 
    } 

    func addObserverForOwner(owner: IndexViewController, triggerImmediately: Bool, handler: DidChangeHandler) { 

     if let index = self.indexOfOwner(owner) { 
      // since the owner exists, add the handler to the existing array 
      self.observers[index].handlers.append(handler) 
     } else { 
      // since the owner does not already exist, add a new tuple with the 
      // owner and an array with the handler 
      self.observers.append(owner: owner, handlers: [handler]) 
     } 

     if (triggerImmediately) { 
      // Trigger the handler immediately since it was requested 
      handler(oldValue: nil, newValue: self.value) 
     } 
    } 

    func removeObserversForOwner(owner: AnyObject) { 
     if let index = self.indexOfOwner(owner) { 
      self.observers.removeAtIndex(index) 
     } 
    } 

    // #pragma mark - Private Properties 

    var observers: [(owner: IndexViewController, handlers: [DidChangeHandler])] = [] 

    // #pragma mark - Private Methods 

    func indexOfOwner(owner: AnyObject) -> Int? { 
     var index : Int = 0 
     for (possibleOwner, handlers) in self.observers { 
      if possibleOwner === owner { 
       return index 
      } 
      index++ 
     } 
     return nil 
    } 
} 

Kann mir jemand sagen, was das Problem ist?

Kennt jemand auch eine Möglichkeit, ein Array von Objekten in swift zu beobachten?

Ich würde jede Hilfe zu schätzen wissen.

Vielen Dank im Voraus.

Answer 1

Der Fehler ist, weil marketIndexList als Array<MarketIndex> definiert ist, aber Sie Observable Instanz zugewiesen. Vielleicht wollte man so etwas tun:

var observableList: Observable = Observable([]) 
var marketIndexList: Array<MarketIndex> = [MarketIndex(), MarketIndex()] 
observableList.value = marketIndexList  

// Or maybe 
observableList = Observable(marketIndexList) 

By the way, können Sie auch Objective-C KVO von Swift verwenden. Markieren Sie einfach die Eigenschaft als dynamic und stellen Sie sicher, dass die Klasse NSObject erbt, um die Eigenschaft beobachtbar zu machen. Zum Beispiel:

class ObservableClass: NSObject { 
    dynamic var value = [Int]() 
} 

Dieser Beitrag ist gut zu lesen für KVO in Swift zusätzlich zu dem, was Sie bezeichnet. https://medium.com/proto-venture-technology/the-state-of-kvo-in-swift-aa5cb1e05cba