Hai mai usato la libreria Combine nei tuoi progetti…

Sì, l'ho usato.

L'uso principale di Combine nei miei progetti riguarda l'elaborazione di eventi asincroni, come:

Richieste di rete: elaborazione delle risposte API, trasformazione dei dati, gestione degli errori.
Modifiche agli elementi UI: reazioni alle azioni dell'utente, modifiche ai campi di testo, swipe.
Elaborazione di dati locali: monitoraggio delle modifiche nei database (ad esempio, Core Data), notifiche di FileManager.
Creazione di flussi di dati reattivi nell'architettura MVVM per il binding tra View e ViewModel.

Vantaggi dell'uso di Combine:

Riduzione della quantità di codice e miglioramento della leggibilità quando si lavora con operazioni asincrone.
Gestione centralizzata degli errori e cancellazione delle operazioni.
Composizione e trasformazione semplice dei flussi di dati tramite operatori.
Integrazione nativa con i framework Apple (SwiftUI, Core Data, URLSession).

Esempio di utilizzo di Combine per una richiesta di rete:

import Combine
import Foundation

struct APIResult: Decodable {
    let value: String
}

func fetchData(from url: URL) -> AnyPublisher<APIResult, Error> {
    URLSession.shared.dataTaskPublisher(for: url)
        .map(\data) // Estrae i dati dalla tupla (data, response)
        .decode(type: APIResult.self, decoder: JSONDecoder()) // Decodifica i dati
        .receive(on: DispatchQueue.main) // Passa al thread principale per aggiornare l'UI
        .eraseToAnyPublisher() // Rimuove il tipo specifico per semplicità
}

// Esempio di sottoscrizione
let cancellable = fetchData(from: URL(string: "https://api.example.com/data")!)
    .sink(receiveCompletion: { completion in
        switch completion {
        case .finished:
            print("Richiesta completata con successo")
        case .failure(let error):
            print("Errore nella richiesta: \(error.localizedDescription)")
        }
    }, receiveValue: { result in
        print("Dati ricevuti: \(result.value)")
    })
// È necessario conservare il riferimento a cancellable affinché l'abbonamento rimanga attivo

Ho anche usato Combine per collegare proprietà nel pattern MVVM:

class ViewModel {
    @Published var text: String = ""
    @Published var isValid: Bool = false

    private var cancellables = Set<AnyCancellable>()

    init() {
        $text
            .map { $0.count > 0 } // Trasforma il testo in un valore booleano
            .assign(to: &$isValid) // Assegna il risultato alla proprietà isValid
    }
}

class ViewController: UIViewController {
    let textView = UITextField()
    let validationLabel = UILabel()
    let viewModel = ViewModel()

    private var cancellables = Set<AnyCancellable>()

    override func viewDidLoad() {
        super.viewDidLoad()

        // Binding del UITextField al ViewModel
        NotificationCenter.default.publisher(for: UITextField.textDidChangeNotification, object: textView)
            .compactMap { ($0.object as? UITextField)?.text }
            .assign(to: \.text, on: viewModel) // Assegna il testo al ViewModel

        // Binding del ViewModel al UILabel
        viewModel.$isValid
            .map { $0 ? "Valido" : "Non valido" }
            .assign(to: \.text, on: validationLabel) // Assegna il testo al UILabel
            .store(in: &cancellables) // Conserva l'abbonamento
    }
}

L'esperienza con Combine è positiva, semplifica notevolmente la gestione dell'asincronia rispetto ai metodi più vecchi (closures, delegate) in scenari complessi.

Hai mai usato la libreria Combine nei tuoi progetti?