Reactivecocoa: आरएसी सिद्धांत: केवल एक बार `सिग्नलप्रोड्यूसर` शुरू करने के लिए सबसे अच्छा कैसे?

replayLazily करना चीजों को थोड़ा सरल करता है - फिर आप सिग्नल को रीडायरेक्ट करने के बजाय SignalProducer सीधे बचा सकते हैं।

इसके अलावा, यहां एक दौड़ की स्थिति है, इसलिए आप RAC के Atomic प्रकार का उपयोग करना चाह सकते हैं। (यदि 2 धागे एक ही समय में getUsers कॉल करते हैं, तो आप 2 अनुरोधों को समाप्त कर सकते हैं।)

मैं वास्तविक एपीआई कोड को एक अलग विधि या वर्ग में विभाजित करने की भी सलाह दूंगा। इससे कोड को पढ़ने में थोड़ी आसानी होगी और चिंताओं को थोड़ा बेहतर ढंग से अलग किया जा सकेगा।

struct API {
    static func getUsers() -> SignalProducer<User, NSError> {
            return SignalProducer<User, NSError> { observer, disposable in
                let url = NSURL(string:"http://jsonplaceholder.typicode.com/users/1")!
                let task = NSURLSession.sharedSession()
                    .dataTaskWithURL(url) { (data, response, error) in
                    if error != nil {
                        observer.sendFailed(NSError(domain:"", code:5, userInfo:nil))
                    } else {
                        let json = try! NSJSONSerialization.JSONObjectWithData(data!, options: NSJSONReadingOptions())
                        let user = User(JSON: json)
                        print("Completed user request at \(NSDate())")
                        observer.sendNext(user)
                        observer.sendCompleted()
                    }
                }
                print("Started user request at \(NSDate())")
                task.resume()
         }
    }
}

class UserManager {
    static let sharedManager = UserManager()

    private var requestProducer: Atomic<SignalProducer<User, NSError>?> = Atomic(nil)

    func getUsers() -> SignalProducer<User, NSError> {
        return requestProducer.modify { producer in
            if let producer = producer {
                print("There is already a request in progress so simply return a reference to its signal")
                return producer
            }

            return API.getUsers()
                .on(completed: {
                    self.requestProcuder.modifify { _ in nil }
                })
               .replayLazily()
        }
    }
}

⚠️ मैंने इसे सीधे ब्राउज़र में टाइप किया और यह अप्रयुक्त है। ⚠️

अभी भी राज्य है, लेकिन यह थोड़ा बेहतर है।

RAC-iest तरीका यह करने के लिए एक नया ऑपरेटर जोड़ना होगा जिसमें राज्य शामिल है।

extension SignalProducer {
    func replayIfStarted() -> SignalProducer<Value, Error> {
        let active: Atomic<SignalProducer<Value, Error>?> = nil
        return active.modify { producer in
            if let producer = producer {
                return producer
            }

            return self
                .on(completed: {
                    active.modify { _ in nil }
                })
                .replayLazily()
        }
    }
}

मुझे यकीन है कि आरएसी कोडबेस के खिलाफ दोहरी जांच होगी, और निर्माता जीवन भर कुछ परीक्षण भी लिखेंगे, यह सुनिश्चित करने के लिए कि मैंने इसे ठीक से लिखा है। ☺️

अच्छा लगा! और मेरी ओर से कोड-बारफ के लिए माफी, मुझे उस "पहले से कोड नहीं है" संदेश के साथ ब्लॉक करना चाहिए

जब मैं Xcode के सामने हूँ, तो मैं इसे देख लूंगा; आपके सभी अंतर्दृष्टि की सराहना करते हैं।

मैं इसे बंद करने जा रहा हूं। अगर आपको इसे देखने के बाद कोई सवाल है तो फिर से आज़ाद हों!

👍 धन्यवाद मैट

इस समस्या के बारे में जाने का एक और तरीका है: Property !

final class UserManager {
    /// The public API is as easy as observing this.
    public let users: AnyProperty<[User]>
    private let usersMutableProperty = MutableProperty<[User]>([])

    init() {
        self.users = AnyProperty(self.usersMutableProperty)  
    }

    private func getUsers() -> SignalProducer<User, NSError> { }

    public func requestUsers() {
        /// This is not idea because multiple calls to this method would step onto one-another, just doing it like this for simplicity
        self.usersMutableProperty <~ self.usersRequest()
    }
}