# Combine vs async/await w Swift: Wzorce Progresywnej Migracji

> Kompletny przewodnik po migracji z Combine do async/await w Swift: progresywne strategie, wzorce mostkowania i współistnienie paradygmatów w bazach kodu iOS.

- Published: 2026-03-13
- Updated: 2026-05-01
- Author: SharpSkill
- Tags: swift, ios, combine, async-await, migration
- Reading time: 14 min

---

Nadejście Swift Concurrency wraz z async/await przekształciło praktyki programowania asynchronicznego na iOS. Dla projektów wykorzystujących Combine pytanie o migrację pojawia się w sposób naturalny. Czy trzeba przepisywać wszystko? Czy oba podejścia mogą współistnieć? Jakie wzorce umożliwiają płynne przejście? Niniejszy przewodnik bada strategie progresywnej migracji, pozwalając na adopcję async/await bez gwałtownego porzucenia Combine.

> **Co obejmuje ten przewodnik**
>
> Niniejszy przewodnik prezentuje konkretne wzorce progresywnej migracji z Combine do async/await, z przykładami dwukierunkowego mostkowania i strategiami współistnienia dostosowanymi do istniejących baz kodu.

## Zrozumienie Fundamentalnych Różnic

Przed rozpoczęciem migracji niezbędne jest zrozumienie, co odróżnia Combine od async/await. Oba podejścia odpowiadają na różne potrzeby, a niektóre przypadki użycia pozostają lepiej obsługiwane przez Combine.

### Model Mentalny Combine

Combine opiera się na modelu strumieni danych. Publisher emituje wartości w czasie, operatory transformują te wartości, a Subscriber otrzymuje końcowy wynik. Ten model wyróżnia się przy strumieniach ciągłych, takich jak zdarzenia UI, powiadomienia czy WebSocket.

```swift
// CombineExample.swift
// Event stream with Combine - stream-based model
import Combine

class SearchViewModel {
    @Published var searchText = ""
    private var cancellables = Set<AnyCancellable>()

    // Combine excels for continuous streams with transformations
    func setupSearch() {
        $searchText
            // Wait 300ms pause in typing
            .debounce(for: .milliseconds(300), scheduler: RunLoop.main)
            // Ignore consecutive duplicates
            .removeDuplicates()
            // Filter searches that are too short
            .filter { $0.count >= 3 }
            // Transform text into network request
            .flatMap { query in
                self.searchAPI(query: query)
                    // Local error handling
                    .catch { _ in Just([]) }
            }
            // Final subscription
            .sink { results in
                self.updateUI(with: results)
            }
            .store(in: &cancellables)
    }

    private func searchAPI(query: String) -> AnyPublisher<[SearchResult], Error> {
        // Network implementation
    }
}
```

Ten kod ilustruje siłę Combine: łączenie deklaratywnych operatorów do przetwarzania ciągłego strumienia zdarzeń.

### Model Mentalny async/await

Async/await przyjmuje model sekwencyjny: operacja się zaczyna, kod czeka na jej wynik, a następnie kontynuuje. Ten model jest bardziej intuicyjny dla operacji jednorazowych, takich jak izolowane żądania sieciowe czy odczyty plików.

```swift
// AsyncAwaitExample.swift
// One-off operations with async/await - sequential model
import Foundation

actor SearchService {
    // async/await excels for sequential operations
    func performSearch(query: String) async throws -> [SearchResult] {
        // Pre-validation - clear sequential reading
        guard query.count >= 3 else {
            return []
        }

        // Network request with await
        let url = URL(string: "https://api.example.com/search?q=\(query)")!
        let (data, response) = try await URLSession.shared.data(from: url)

        // Response verification
        guard let httpResponse = response as? HTTPURLResponse,
              httpResponse.statusCode == 200 else {
            throw SearchError.invalidResponse
        }

        // Result decoding
        let results = try JSONDecoder().decode([SearchResult].self, from: data)
        return results
    }
}
```

Lektura jest liniowa, błędy propagują się naturalnie z `try`, a przepływ wykonania staje się natychmiast zrozumiały.

> **Kiedy wybrać każde z podejść**
>
> Combine pozostaje istotny dla strumieni ciągłych (zdarzenia UI, timery, WebSocket). Async/await jest lepiej dostosowany do operacji jednorazowych (żądania API, odczyty plików, izolowane obliczenia).

## Mostkowanie z Combine do async/await

Pierwszy krok migracji często polega na konsumowaniu istniejących Publisherów w kodzie async/await. Swift dostarcza natywnych narzędzi do tego mostkowania.

### Używanie AsyncSequence z Publisher.values

Od Swift 5.5 każdy Publisher udostępnia właściwość `.values` zwracającą `AsyncPublisher`. Ta asynchroniczna sekwencja pozwala iterować po emitowanych wartościach za pomocą pętli `for await`.

```swift
// BridgingCombineToAsync.swift
// Publisher → AsyncSequence conversion via .values
import Combine

class NotificationObserver {
    private let notificationPublisher: AnyPublisher<Notification, Never>

    init() {
        // Existing Combine Publisher
        notificationPublisher = NotificationCenter.default
            .publisher(for: UIApplication.didBecomeActiveNotification)
            .eraseToAnyPublisher()
    }

    // Consuming the Publisher with async/await
    func observeNotifications() async {
        // .values converts the Publisher to AsyncSequence
        for await notification in notificationPublisher.values {
            // Process each notification
            await handleAppBecameActive(notification)
        }
        // This line is never reached for an infinite Publisher
    }

    private func handleAppBecameActive(_ notification: Notification) async {
        // Async processing logic
    }
}
```

To podejście zachowuje oryginalny Publisher, jednocześnie umożliwiając jego konsumpcję w kontekście asynchronicznym.

### Pobranie Pojedynczej Wartości za pomocą firstValue

Dla Publisherów emitujących pojedynczą wartość (jak żądanie sieciowe) właściwość `.values.first(where:)` lub niestandardowe rozszerzenie upraszczają mostkowanie.

```swift
// SingleValueBridging.swift
// Extension to extract a single value from a Publisher
import Combine

extension Publisher where Failure == Never {
    // Awaits and returns the first emitted value
    var firstValue: Output {
        get async {
            await withCheckedContinuation { continuation in
                var cancellable: AnyCancellable?
                cancellable = self.first()
                    .sink { value in
                        continuation.resume(returning: value)
                        cancellable?.cancel()
                    }
            }
        }
    }
}

extension Publisher {
    // Throwing version for Publishers with errors
    var firstValueThrowing: Output {
        get async throws {
            try await withCheckedThrowingContinuation { continuation in
                var cancellable: AnyCancellable?
                cancellable = self.first()
                    .sink(
                        receiveCompletion: { completion in
                            if case .failure(let error) = completion {
                                continuation.resume(throwing: error)
                            }
                            cancellable?.cancel()
                        },
                        receiveValue: { value in
                            continuation.resume(returning: value)
                        }
                    )
            }
        }
    }
}

// Usage in async code
class UserRepository {
    private let apiClient: APIClient

    func fetchCurrentUser() async throws -> User {
        // Consume an existing Publisher asynchronously
        try await apiClient.userPublisher().firstValueThrowing
    }
}
```

To rozszerzenie enkapsuluje złożoność mostkowania i oferuje czyste API.

## Mostkowanie z async/await do Combine

Migracja w drugą stronę również okazuje się konieczna: konsumowanie kodu async w istniejących pipeline'ach Combine.

### Tworzenie Publishera z Funkcji async

Najbardziej bezpośrednie podejście wykorzystuje `Future` w połączeniu z `Task`, aby enkapsulować wywołanie async.

```swift
// BridgingAsyncToCombine.swift
// async → Publisher conversion via Future
import Combine

extension Publisher {
    // async flatMap operator for Combine pipelines
    func asyncMap<T>(
        _ transform: @escaping (Output) async throws -> T
    ) -> AnyPublisher<T, Error> {
        flatMap { value in
            Future { promise in
                Task {
                    do {
                        // Execute the async transformation
                        let result = try await transform(value)
                        promise(.success(result))
                    } catch {
                        promise(.failure(error))
                    }
                }
            }
        }
        .eraseToAnyPublisher()
    }
}

// Usage in a Combine pipeline
class ImageProcessor {
    @Published var selectedImageURL: URL?
    private var cancellables = Set<AnyCancellable>()

    func setupProcessingPipeline() {
        $selectedImageURL
            .compactMap { $0 }
            // Use an async function in the Combine pipeline
            .asyncMap { url in
                // downloadImage is an async function
                try await self.downloadImage(from: url)
            }
            .asyncMap { imageData in
                // processImage is also async
                try await self.processImage(imageData)
            }
            .receive(on: DispatchQueue.main)
            .sink(
                receiveCompletion: { completion in
                    if case .failure(let error) = completion {
                        print("Error: \(error)")
                    }
                },
                receiveValue: { processedImage in
                    self.displayImage(processedImage)
                }
            )
            .store(in: &cancellables)
    }

    private func downloadImage(from url: URL) async throws -> Data {
        let (data, _) = try await URLSession.shared.data(from: url)
        return data
    }

    private func processImage(_ data: Data) async throws -> UIImage {
        // Async image processing
    }
}
```

### Niestandardowy Publisher dla Strumieni Async

Dla bardziej zaawansowanych potrzeb niestandardowy Publisher może enkapsulować kompletny strumień AsyncSequence.

```swift
// AsyncSequencePublisher.swift
// Publisher wrapper for AsyncSequence
import Combine

struct AsyncSequencePublisher<S: AsyncSequence>: Publisher {
    typealias Output = S.Element
    typealias Failure = Error

    private let sequence: S

    init(_ sequence: S) {
        self.sequence = sequence
    }

    func receive<Sub>(subscriber: Sub) where Sub: Subscriber,
                                              Failure == Sub.Failure,
                                              Output == Sub.Input {
        let subscription = AsyncSubscription(
            sequence: sequence,
            subscriber: subscriber
        )
        subscriber.receive(subscription: subscription)
    }
}

private final class AsyncSubscription<S: AsyncSequence, Sub: Subscriber>: Subscription
where Sub.Input == S.Element, Sub.Failure == Error {

    private var task: Task<Void, Never>?
    private var subscriber: Sub?
    private let sequence: S

    init(sequence: S, subscriber: Sub) {
        self.sequence = sequence
        self.subscriber = subscriber
    }

    func request(_ demand: Subscribers.Demand) {
        // Start asynchronous iteration
        task = Task {
            do {
                for try await element in sequence {
                    // Check subscription is still active
                    guard subscriber != nil else { break }
                    _ = subscriber?.receive(element)
                }
                subscriber?.receive(completion: .finished)
            } catch {
                subscriber?.receive(completion: .failure(error))
            }
        }
    }

    func cancel() {
        task?.cancel()
        subscriber = nil
    }
}

// Convenience extension for any AsyncSequence
extension AsyncSequence {
    var publisher: AsyncSequencePublisher<Self> {
        AsyncSequencePublisher(self)
    }
}
```

## Strategie Współistnienia w Bazie Kodu

Kompletna migracja dużej bazy kodu zajmuje czas. Oto wzorce pozwalające harmonijnie współistnieć Combine i async/await.

### Architektura Warstwowa z Abstrakcją

Zdefiniowanie protokołów abstrahujących implementację umożliwia progresywną migrację bez modyfikowania kodu wywołującego.

```swift
// RepositoryAbstraction.swift
// Abstraction enabling two implementations
import Combine

// Protocol defining the contract
protocol UserRepositoryProtocol {
    // Modern async interface
    func fetchUser(id: String) async throws -> User

    // Legacy Combine interface (optional with default implementation)
    func fetchUserPublisher(id: String) -> AnyPublisher<User, Error>
}

// Default Publisher implementation based on async
extension UserRepositoryProtocol {
    func fetchUserPublisher(id: String) -> AnyPublisher<User, Error> {
        Future { promise in
            Task {
                do {
                    let user = try await self.fetchUser(id: id)
                    promise(.success(user))
                } catch {
                    promise(.failure(error))
                }
            }
        }
        .eraseToAnyPublisher()
    }
}

// Modern implementation - async first
class UserRepository: UserRepositoryProtocol {
    private let apiClient: APIClient

    init(apiClient: APIClient) {
        self.apiClient = apiClient
    }

    func fetchUser(id: String) async throws -> User {
        // Native async implementation
        let url = URL(string: "https://api.example.com/users/\(id)")!
        let (data, _) = try await URLSession.shared.data(from: url)
        return try JSONDecoder().decode(User.self, from: data)
    }

    // fetchUserPublisher is provided by the default extension
}
```

To podejście pozwala nowym wywołującym używać async/await, podczas gdy stary kod nadal korzysta z Publisherów.

> **Uwaga na zarządzanie pamięcią**
>
> Podczas mostkowania utworzone `Task` mogą przeżyć obiekty, które je stworzyły. Należy zawsze używać `[weak self]` lub jawnie anulować zadania, aby uniknąć wycieków pamięci.

### Hybrydowy ViewModel

ViewModel może udostępniać oba interfejsy w okresie przejściowym.

```swift
// HybridViewModel.swift
// ViewModel supporting both Combine and async/await
import Combine
import SwiftUI

@MainActor
class ProfileViewModel: ObservableObject {
    // Published state for SwiftUI (Combine)
    @Published private(set) var user: User?
    @Published private(set) var isLoading = false
    @Published private(set) var errorMessage: String?

    private let repository: UserRepositoryProtocol
    private var cancellables = Set<AnyCancellable>()
    private var loadTask: Task<Void, Never>?

    init(repository: UserRepositoryProtocol) {
        self.repository = repository
    }

    // Async interface for modern UIKit or SwiftUI with .task
    func loadUser(id: String) async {
        isLoading = true
        errorMessage = nil

        do {
            user = try await repository.fetchUser(id: id)
        } catch {
            errorMessage = error.localizedDescription
        }

        isLoading = false
    }

    // Combine interface for legacy code
    func loadUserPublisher(id: String) {
        isLoading = true
        errorMessage = nil

        repository.fetchUserPublisher(id: id)
            .receive(on: DispatchQueue.main)
            .sink(
                receiveCompletion: { [weak self] completion in
                    self?.isLoading = false
                    if case .failure(let error) = completion {
                        self?.errorMessage = error.localizedDescription
                    }
                },
                receiveValue: { [weak self] user in
                    self?.user = user
                }
            )
            .store(in: &cancellables)
    }

    // Clean cancellation
    func cancelLoading() {
        loadTask?.cancel()
        cancellables.removeAll()
        isLoading = false
    }
}
```

## Migracja Powszechnych Operatorów Combine

Niektóre operatory Combine nie mają bezpośredniego odpowiednika w async/await. Oto jak je odtworzyć.

### Odpowiednik Debounce z async

```swift
// DebounceAsync.swift
// Debounce implementation with async/await
import Foundation

actor Debouncer {
    private var task: Task<Void, Never>?
    private let duration: Duration

    init(duration: Duration) {
        self.duration = duration
    }

    // Cancels previous execution and schedules a new one
    func debounce(_ operation: @escaping @Sendable () async -> Void) {
        task?.cancel()

        task = Task {
            do {
                // Wait for the specified duration
                try await Task.sleep(for: duration)
                // Execute operation if not cancelled
                await operation()
            } catch {
                // Task cancelled - expected behavior
            }
        }
    }
}

// Usage in a ViewModel
@MainActor
class SearchViewModel: ObservableObject {
    @Published var searchText = ""
    @Published private(set) var results: [SearchResult] = []

    private let debouncer = Debouncer(duration: .milliseconds(300))
    private let searchService: SearchService

    init(searchService: SearchService) {
        self.searchService = searchService
    }

    func onSearchTextChanged(_ text: String) {
        Task {
            await debouncer.debounce { [weak self] in
                guard let self else { return }
                await self.performSearch(text)
            }
        }
    }

    private func performSearch(_ query: String) async {
        guard query.count >= 3 else {
            results = []
            return
        }

        do {
            results = try await searchService.search(query: query)
        } catch {
            // Error handling
        }
    }
}
```

### Odpowiednik Merge z TaskGroup

```swift
// MergeAsync.swift
// Combining multiple async streams with TaskGroup
import Foundation

struct AsyncMerge {
    // Executes multiple async operations in parallel and returns all results
    static func merge<T>(
        _ operations: [@Sendable () async throws -> T]
    ) async throws -> [T] {
        try await withThrowingTaskGroup(of: T.self) { group in
            // Launch all operations in parallel
            for operation in operations {
                group.addTask {
                    try await operation()
                }
            }

            // Collect results
            var results: [T] = []
            for try await result in group {
                results.append(result)
            }
            return results
        }
    }

    // Streaming version that emits results as they arrive
    static func mergeStream<T: Sendable>(
        _ operations: [@Sendable () async throws -> T]
    ) -> AsyncThrowingStream<T, Error> {
        AsyncThrowingStream { continuation in
            Task {
                await withThrowingTaskGroup(of: T.self) { group in
                    for operation in operations {
                        group.addTask {
                            try await operation()
                        }
                    }

                    do {
                        for try await result in group {
                            continuation.yield(result)
                        }
                        continuation.finish()
                    } catch {
                        continuation.finish(throwing: error)
                    }
                }
            }
        }
    }
}

// Usage
class DataAggregator {
    func fetchAllData() async throws -> AggregatedData {
        // Execute three requests in parallel
        let results = try await AsyncMerge.merge([
            { try await self.fetchUsers() },
            { try await self.fetchPosts() },
            { try await self.fetchComments() }
        ])

        return AggregatedData(
            users: results[0] as! [User],
            posts: results[1] as! [Post],
            comments: results[2] as! [Comment]
        )
    }
}
```

## Przypadki Użycia, Gdzie Combine Pozostaje Preferowane

Mimo zalet async/await niektóre scenariusze pozostają lepiej obsługiwane przez Combine.

### Reaktywne Strumienie Zdarzeń UI

SwiftUI i UIKit generują ciągłe strumienie zdarzeń, w których operatory Combine (debounce, throttle, combineLatest) błyszczą.

```swift
// UIEventsCombine.swift
// Combine remains optimal for reactive UI events
import Combine
import SwiftUI

class FormViewModel: ObservableObject {
    @Published var email = ""
    @Published var password = ""
    @Published var confirmPassword = ""

    // Derived states computed via Combine
    @Published private(set) var isEmailValid = false
    @Published private(set) var isPasswordStrong = false
    @Published private(set) var passwordsMatch = false
    @Published private(set) var canSubmit = false

    private var cancellables = Set<AnyCancellable>()

    init() {
        setupValidation()
    }

    private func setupValidation() {
        // Email validation with debounce
        $email
            .debounce(for: .milliseconds(300), scheduler: RunLoop.main)
            .map { email in
                let regex = /^[\w-\.]+@([\w-]+\.)+[\w-]{2,4}$/
                return email.wholeMatch(of: regex) != nil
            }
            .assign(to: &$isEmailValid)

        // Password strength validation
        $password
            .map { password in
                password.count >= 8 &&
                password.rangeOfCharacter(from: .uppercaseLetters) != nil &&
                password.rangeOfCharacter(from: .decimalDigits) != nil
            }
            .assign(to: &$isPasswordStrong)

        // Password matching
        Publishers.CombineLatest($password, $confirmPassword)
            .map { password, confirm in
                !password.isEmpty && password == confirm
            }
            .assign(to: &$passwordsMatch)

        // Final combination to enable submit button
        Publishers.CombineLatest3($isEmailValid, $isPasswordStrong, $passwordsMatch)
            .map { $0 && $1 && $2 }
            .assign(to: &$canSubmit)
    }
}
```

Ten deklaratywny wzorzec byłby znacznie bardziej rozwlekły z async/await.

### Zarządzanie Połączeniami WebSocket

WebSockety emitują wiadomości w sposób ciągły, co stanowi naturalny przypadek użycia dla Combine.

```swift
// WebSocketCombine.swift
// WebSocket with Combine for continuous stream
import Combine
import Foundation

class WebSocketManager: ObservableObject {
    @Published private(set) var messages: [ChatMessage] = []
    @Published private(set) var connectionState: ConnectionState = .disconnected

    private var webSocketTask: URLSessionWebSocketTask?
    private let messageSubject = PassthroughSubject<ChatMessage, Never>()
    private var cancellables = Set<AnyCancellable>()

    // Exposed Publisher for consumers
    var messagePublisher: AnyPublisher<ChatMessage, Never> {
        messageSubject.eraseToAnyPublisher()
    }

    func connect(to url: URL) {
        webSocketTask = URLSession.shared.webSocketTask(with: url)
        webSocketTask?.resume()
        connectionState = .connected

        // Start reception loop
        receiveMessages()

        // Message processing pipeline
        messageSubject
            // Buffer messages to avoid too frequent UI updates
            .collect(.byTime(RunLoop.main, .milliseconds(100)))
            // Accumulate in history
            .scan([ChatMessage]()) { accumulated, new in
                accumulated + new
            }
            .assign(to: &$messages)
    }

    private func receiveMessages() {
        webSocketTask?.receive { [weak self] result in
            switch result {
            case .success(let message):
                if case .string(let text) = message,
                   let data = text.data(using: .utf8),
                   let chatMessage = try? JSONDecoder().decode(ChatMessage.self, from: data) {
                    self?.messageSubject.send(chatMessage)
                }
                // Continue reception
                self?.receiveMessages()

            case .failure(let error):
                self?.connectionState = .error(error.localizedDescription)
            }
        }
    }
}
```

## Lista Kontrolna Progresywnej Migracji

Udana migracja podąża za metodycznym podejściem. Oto zalecane etapy.

### Faza 1: Przygotowanie

- ✅ Zidentyfikowanie Publisherów używanych w bazie kodu
- ✅ Skategoryzowanie: strumienie ciągłe vs operacje jednorazowe
- ✅ Stworzenie rozszerzeń mostkujących (firstValue, asyncMap)
- ✅ Zdefiniowanie abstrakcyjnych protokołów dla repozytoriów

### Faza 2: Migracja Operacji Jednorazowych

- ✅ Konwersja prostych żądań sieciowych do async/await
- ✅ Migracja odczytów plików
- ✅ Transformacja operacji bazodanowych
- ✅ Zachowanie Publisherów poprzez domyślne implementacje

### Faza 3: Adaptacja ViewModeli

- ✅ Dodanie metod async do istniejących ViewModeli
- ✅ Używanie `.task` w SwiftUI dla nowych ekranów
- ✅ Zachowanie powiązań @Published dla kompatybilności

### Faza 4: Czyszczenie

- ✅ Usunięcie metod Combine, które stały się bezużyteczne
- ✅ Usunięcie nieużywanych rozszerzeń mostkujących
- ✅ Udokumentowanie celowo zachowanych wzorców Combine

## Podsumowanie

Migracja z Combine do async/await stanowi naturalną ewolucję dla nowoczesnych projektów Swift. Progresywne podejście wykorzystujące dwukierunkowe wzorce mostkowania pozwala na adopcję zalet async/await bez gwałtownego zerwania.

**Kluczowe punkty do zapamiętania:**

- ✅ Combine i async/await odpowiadają na różne potrzeby
- ✅ `.values` konwertuje Publisher na AsyncSequence
- ✅ `Future` + `Task` enkapsulują kod async w Publisherze
- ✅ Abstrakcyjne protokoły ułatwiają współistnienie
- ✅ Combine pozostaje istotny dla reaktywnych strumieni UI
- ✅ Operatory takie jak debounce można odtworzyć w async
- ✅ Progresywna migracja zmniejsza ryzyko regresji

Celem nie jest eliminacja Combine, ale wybór odpowiedniego narzędzia do każdego kontekstu: async/await dla operacji jednorazowych, Combine dla ciągłych strumieni zdarzeń.

---

Source: SharpSkill (https://sharpskill.dev), tech interview preparation for your real stack.
HTML version of this page: https://sharpskill.dev/pl/blog/ios/combine-vs-async-await-swift-progressive-migration-patterns