Utilizzo di Combinare per gestire flussi di dati asincroni in Ios

Alcuni editori comuni incorporati includono:

• ][] – per le risposte di rete
• ] – per eventi periodici
• ][] – per osservare le notifiche
• ][] – un editore guidato manualmente che trasmette valori a più iscritti
• ][] – un soggetto che mantiene un valore attuale e pubblica aggiornamenti

È inoltre possibile creare editori personalizzati conforme al protocollo ], anche se in pratica molte esigenze sono soddisfatte combinando editori esistenti con gli operatori.

Iscrizioni

]Subscriber[]] è un protocollo che riceve valori da un editore. Gli abbonati definiscono come gestire i dati in arrivo e gli eventi di completamento (sia terminazione che fallimento). Mentre è possibile scrivere abbonati personalizzati, la maggior parte degli sviluppatori utilizzano il metodo integrato , che accetta chiusure per eventi di completamento e valore, o , che l'oggetto

Per esempio:

let publisher = Just("Hello, Combine!")
publisher
 .sink(receiveCompletion: { completion in
 print("Completed: \(completion)")
 }, receiveValue: { value in
 print("Received: \(value)")
 })

Qui crea un abbonato implicito che esegue le chiusure previste ogni volta che arriva un nuovo valore o il flusso completa.

Operatori

Gli operatori sono metodi per gli editori che ritornano un altro editore, permettendoti di incatenare le trasformazioni.

• ]] []][]]] – trasforma i valori
• ][]] – passare solo valori che soddisfano una condizione
• ][] – trasforma e disattiva gli optional
• ], ][ – controllare il tasso di valori emessi
• ][]], ][[]], ] – combinare più flussi
• []], []]][] – errore di gestione
• [] – editori nidi appiattiti

Gli operatori formano la colonna portante delle tubazioni reattive, incatenandole, è possibile creare flussi di dati sofisticati che sono facili da leggere e mantenere.

Impostare la combinazione nel vostro progetto

La combinazione fa parte del framework Foundation ed è disponibile su iOS 13.0+, macOS 10.15+, watchOS 6.0+ e tvOS 13.0+. Non sono richieste ulteriori importazioni . Tuttavia, perché la Combina si basa pesantemente su generici e chiusure, in genere memorizzare gli abbonamenti in un per gestire il loro ciclo di vita.

AnyCancellable[[]] è un oggetto cancellabile di tipo cancellabile che cancella automaticamente l'abbonamento quando viene negoziato. Mantenendo questi token in una raccolta (spesso un set sul controller di vista o sul modello di vista), si assicura che gli abbonamenti vengano ripuliti quando l'oggetto di proprietà viene rilasciato.

var cancellables = Set<AnyCancellable>()

func setupObservation() {
 NotificationCenter.default.publisher(for: UIApplication.didBecomeActiveNotification)
 .sink { _ in
 print("App became active")
 }
 .store(in: &cancellables)
}

Esempi pratici utilizzando la combinazione

Per comprendere il potere della Combina, aiuta a vederlo applicato agli scenari del mondo reale. Di seguito sono riportati diversi esempi che dimostrano schemi comuni, dal networking e dagli aggiornamenti dell'interfaccia utente per combinare più sorgenti asincroni.

1. Reti di dati di acquisizione con gestione di errore

restituisce un editore che emette una tuple di []. È quindi possibile utilizzare gli operatori per estrarre e decodificare i dati.

import Combine
import Foundation

var cancellables = Set<AnyCancellable>()

struct User: Codable {
 let id: Int
 let name: String
}

func fetchUser(id: Int) {
 let url = URL(string: "https://jsonplaceholder.typicode.com/users/\(id)")!
 URLSession.shared.dataTaskPublisher(for: url)
 .map { $0.data }
 .decode(type: User.self, decoder: JSONDecoder())
 .receive(on: DispatchQueue.main)
 .sink(receiveCompletion: { completion in
 switch completion {
 case .finished:
 print("Request completed successfully")
 case .failure(let error):
 print("Request failed with error: \(error.localizedDescription)")
 }
 }, receiveValue: { user in
 print("Fetched user: \(user.name)")
 })
 .store(in: &cancellables)
}

In questa pipeline, l'operatore ] tenta di analizzare i dati grezzi in un oggetto . Se la decodifica non riesce, l'errore viene relè al gestore di completamento dell'abbonato. L'operatore assicura che la chiusura esegue sulla coda principale, che è essenziale per gli aggiornamenti dell'interfaccia utente.

2. Gestione dell'Input utente con Debounce

Combinare eccelle all'elaborazione degli eventi dell'interfaccia utente, come l'ingresso del campo di testo. Utilizzando , è possibile attendere fino a quando l'utente si ferma digitando prima di attivare una ricerca o una validazione.

class SearchViewModel: ObservableObject {
 @Published var query: String = ""
 @Published var results: [String] = []
 private var cancellables = Set<AnyCancellable>()

 init() {
 $query
 .debounce(for: .milliseconds(300), scheduler: RunLoop.main)
 .removeDuplicates()
 .sink { [weak self] searchText in
 self?.performSearch(with: searchText)
 }
 .store(in: &cancellables)
 }

 private func performSearch(with text: String) {
 // Simulate network search
 print("Searching for: \(text)")
 }
}

Il wrapper crea un editore che emette nuovi valori ogni volta [[]] cambiamenti. L'operatore [ aspetta 300 millisecondi dopo l'ultimo evento, e impedisce duplicate ricerche per lo stesso testo. Questo modello riduce inutili chiamate di rete e migliora le prestazioni.

3. Merging più sorgenti asincrono

Spesso un'applicazione deve combinare i dati da diversi flussi indipendenti. Ad esempio, potrebbe essere necessario attendere sia un profilo utente che un elenco di amici da caricare prima di aggiornare l'interfaccia utente. L'operatore consente di unire i valori più recenti da due editori.

let profilePublisher = URLSession.shared.dataTaskPublisher(for: profileURL)
 .map { $0.data }
 .decode(type: UserProfile.self, decoder: JSONDecoder())

let friendsPublisher = URLSession.shared.dataTaskPublisher(for: friendsURL)
 .map { $0.data }
 .decode(type: [Friend].self, decoder: JSONDecoder())

profilePublisher
 .combineLatest(friendsPublisher)
 .receive(on: DispatchQueue.main)
 .sink(receiveCompletion: { completion in
 // handle errors
 }, receiveValue: { profile, friends in
 // update UI with both profile and friends
 print("Profile: \(profile.name), Friends: \(friends.count)")
 })
 .store(in: &cancellables)

Con , l'abbonato riceve una tuple contenente i valori più recenti da entrambi gli editori ogni volta che emette un nuovo valore.Per scenari in cui è necessario associare i valori in ordine (prima con prima, seconda con seconda), utilizzare invece.

4. Recupero di errore con cattura e riprovazione

Le reti sono inaffidabili e la Combina fornisce agli operatori di gestire con grazia i guasti. L'operatore consente di sostituire un editore fallback quando si verifica un errore, mentre tenta di riscrivere un numero specificato di volte.

URLSession.shared.dataTaskPublisher(for: url)
 .map { $0.data }
 .decode(type: [String].self, decoder: JSONDecoder())
 .retry(3)
 .catch { error in
 // Return a fallback empty array
 Just([]).setFailureType(to: Error.self)
 }
 .sink(receiveCompletion: { completion in
 // Will not receive failure because catch handled it
 }, receiveValue: { data in
 print("Received \(data.count) items")
 })
 .store(in: &cancellables)

Catturando l'errore e fornendo un valore predefinito, il flusso si completa con successo dalla prospettiva dell'abbonato. Questo modello è particolarmente utile per fornire un'esperienza degradata graziosa quando i dati non sono disponibili.

5. Legare all'interfaccia utente con Assign

L'operatore di Combina consente di legare l'output di un editore direttamente a una proprietà di un oggetto, eliminando la necessità di un assegnazione manuale in una chiusura a lavello.

class SettingsViewModel: ObservableObject {
 @Published var isDarkMode: Bool = false
}

// In your view controller
let viewModel = SettingsViewModel()
NotificationCenter.default.publisher(for: .darkModeChanged)
 .compactMap { $0.userInfo?["enabled"] as? Bool }
 .assign(to: \.isDarkMode, on: viewModel)
 .store(in: &cancellables)

Questo modello mantiene il codice conciso e dichiarativo. Tuttavia, essere cauti con [ quando il proprietario della proprietà potrebbe essere trattato prima della fine dell'abbonamento. In tali casi, utilizzare riferimenti deboli o l'approccio con gestione esplicita del ciclo di vita.

Gestione della memoria e ciclo di vita

Gli abbonamenti combinati sono risorse che devono essere gestite con attenzione per evitare perdite di memoria o comportamenti inaspettati. Ogni chiamata a o restituisce un token. Se scarta questo token senza memorizzarlo, l'abbonamento viene immediatamente cancellato e non vengono ricevuti valori.

Il modello consigliato è quello di memorizzare tutti i token cancellabili in una proprietà sull'oggetto di appartenenza (come un controller di vista, un modello di vista o un gestore). Quando l'oggetto è trattato, il set è deinitializzato, e tutti gli abbonamenti vengono automaticamente cancellati.

class MyViewController: UIViewController {
 private var cancellables = Set<AnyCancellable>()

 override func viewDidLoad() {
 super.viewDidLoad()
 NotificationCenter.default.publisher(for: .someNotification)
 .sink { [weak self] notification in
 self?.handleNotification(notification)
 }
 .store(in: &cancellables)
 }
}

Una sottigliezza è che le chiusure all'interno degli abbonati catturano i riferimenti con forza per impostazione predefinita. Per evitare i cicli di mantenimento, cattura [ quando la chiusura fa riferimento all'oggetto di proprietà.

Integrazione di Combinazione con SwiftUI e UIKit

Combinare funziona senza soluzione di continuità sia con SwiftUI che con UIKit, anche se i modelli di integrazione differiscono leggermente.

SwiftUI

SwiftUI è stato progettato con Combine in mente. wrapper di proprietà su [] crea automaticamente un editore, e le opinioni di SwiftUI abbonarsi alle modifiche tramite il o ] wrapper di proprietà.

class TimerViewModel: ObservableObject {
 @Published var timeString: String = ""
 private var cancellables = Set<AnyCancellable>()

 init() {
 Timer.publish(every: 1.0, on: .main, in: .common)
 .autoconnect()
 .map { formatter.string(from: $0) }
 .assign(to: &$timeString)
 }
}

struct TimerView: View {
 @StateObject private var viewModel = TimerViewModel()

 var body: some View {
 Text(viewModel.timeString)
 }
}

Qui, l'operatore lega il tempo formattato direttamente alla proprietà pubblicata, e SwiftUI aggiorna automaticamente la vista ogni volta che la stringa cambia.

UIKIT

In UIKit, la Combina brilla per sostituire i modelli di delega o callback. Puoi usare per reagire agli eventi dell'editore e aggiornare direttamente gli elementi dell'interfaccia o utilizzare per i binding. La chiave è quella di inviare il lavoro sulla coda principale utilizzando prima di aggiornare l'interfaccia.

class LoginViewController: UIViewController {
 @IBOutlet weak var usernameField: UITextField!
 @IBOutlet weak var passwordField: UITextField!
 @IBOutlet weak var loginButton: UIButton!
 private var cancellables = Set<AnyCancellable>()

 override func viewDidLoad() {
 super.viewDidLoad()
 let usernamePublisher = NotificationCenter.default.publisher(for: UITextField.textDidChangeNotification, object: usernameField)
 .compactMap { ($0.object as? UITextField)?.text }
 let passwordPublisher = NotificationCenter.default.publisher(for: UITextField.textDidChangeNotification, object: passwordField)
 .compactMap { ($0.object as? UITextField)?.text }

 Publishers.CombineLatest(usernamePublisher, passwordPublisher)
 .map { username, password in
 !username.isEmpty && !password.isEmpty
 }
 .assign(to: \.isEnabled, on: loginButton)
 .store(in: &cancellables)
 }
}

In questo esempio, Combine ascolta i cambiamenti del campo di testo, combina i valori più recenti e consente il pulsante di login solo quando entrambi i campi non sono vuoti. Il risultato è una sostituzione pulita e dichiarativa per i metodi delegata e i modelli di azione target.

Argomenti avanzati: Editori e Backpressure personalizzati

Per esigenze più specifiche, è possibile creare editori personalizzati, conforme al protocollo []. Ciò richiede l'implementazione del [ metodo, che collega il vostro editore a un abbonato a valle.

Un concetto che merita attenzione è backpressure]. La combinazione è un quadro a comando estraneo: gli abbonati richiedono un certo numero di valori dall'editore, e l'editore li consegna alla tariffa richiesta. Questo impedisce all'editore di schiacciare l'abbonato. Per impostazione predefinita, richiede un numero illimitato di valori, ma è possibile implementare gli abbonati personalizzati con controllo della domanda se necessario.

Per ulteriori informazioni sui modelli di Combinazione avanzata, fare riferimento a WDC 2019 Sessione 722: Combina in Pratica[]] per la guida ufficiale sulle tubazioni reattive di costruzione.

Vantaggi dell'adozione di combinazione

Integrare la Combinazione nel flusso di lavoro di sviluppo offre diversi vantaggi tangibili:

• Crea chiarezza dichiarativa[[] – Le linee di tubazioni sono espresse come una catena di operatori, rendendo i dati in modo evidente a colpo d'occhio.
• Composability[] – I piccoli operatori focalizzati possono essere combinati per costruire comportamenti complessi senza nidi di callback aggrovigliati.
• Sicurezza del tipo[[] – I controlli a tempo pieno si appropriano di tipi di output e di lacune di gestione degli errori prima del runtime.
• Gestione delle risorse[[] – La cancellazione automatica sulla destinazione riduce le perdite di memoria.
• Integrazione ecosistema[[] – Combine lavora in nativo con SwiftUI, Foundation e molti quadri di terze parti che espongono gli editori.
• Testability[]] – Gli editori possono essere ingannati e gli abbonamenti possono essere convalidati utilizzando le aspettative di XCTest.

I team che adottano la Combine spesso segnalano una riduzione del codice della caldaia e meno bug relativi alle condizioni di gara o alle chiamate dimenticate. Il paradigma reattivo incoraggia anche un'architettura più data-driven, dove il flusso di informazioni è esplicito e tracciabile.

Migliori Pratiche per Codice di Produzione

Per ottenere il massimo dalla Combinazione evitando le insidie comuni, seguire queste linee guida:

• Gestisci sempre gli abbonamenti[[] – Conserva cancellabili in un set e usa . Non contare mai su abbonamenti di lunga durata senza un proprietario chiaro.
• Capture richiami deboli[] – Usa nelle chiusure di lavandino per evitare i cicli di mantenimento, soprattutto quando la chiusura fa riferimento all'oggetto che possiede le cancellabili.
• Dispatch alla coda corretta[[] – Usa [[]] per garantire che i valori vengano elaborati sul programmatore appropriato, in genere la coda principale per gli aggiornamenti dell'interfaccia utente.
• Preferire ] per le obbligazioni[] – Quando è sufficiente aggiornare una proprietà, utilizzare invece di per il codice più pulito.
• Leverage [] con SwiftUI[] – Nei progetti SwiftUI, combinare [ proprietà con il sistema di osservazione di SwiftUI per gli aggiornamenti automatici.
• Esecuzioni di maneggio a livello di pipeline[[] – Usa [, [, o ] per recuperare da errori piuttosto che lasciare che gli errori si propagano agli abbonati.
• Le tubazioni di Koep si concentrano[[] – Evitare di costruire catene monolitiche.
• Profilo con strumenti[[] – Utilizzare il Sanitario del filo e gli strumenti specifici della combinazione per rilevare le razze di dati e le perdite di abbonamento.

Per un'immersione più profonda in modelli di gestione degli errori di Combina, vedere Guida di Apple sulla gestione degli errori in Combina[.

Conclusioni

Combina fornisce una solida base di chiarificazione per la gestione di flussi di dati asincroni in applicazioni iOS, macOS, watchOS e tvOS. Il suo modello di editor-subscriber-operator consente di esprimere flussi reattivi complessi con chiarezza e precisione, mentre la sua stretta integrazione con SwiftUI e Foundation riduce la piastra caldaia e migliora la manutenbilità del codice.

Come si adotta Combine, iniziare sostituendo direttamente i modelli di delega o callback con semplici pipeline, poi gradualmente esplorare gli operatori più avanzati come la vostra fiducia cresce. La composibilità del framework significa che anche l'uso modesto di Combine può dare miglioramenti immediati nella leggibilità del codice e correttezza. Con attenzione attenta alla gestione della memoria e alla filettatura, Combine diventerà una parte indispensabile del vostro toolkit di sviluppo iOS, che vi permetterà di gestire il flusso di eventi basati sul tempo con fiducia e l'eleganza.