Combine — کلیدی تصورات، Publisher اور ری ایکٹیو پروگرامنگ

Combine کیا ہے؟

Combine ایک اعلانیہ ری ایکٹیو پروگرامنگ فریم ورک ہے جو Apple SDK میں شامل ہے۔ یہ Reactive Streams پیٹرن کو نافذ کرتا ہے: Publisher اقدار پیدا کرتا ہے، Subscriber انہیں استعمال کرتا ہے، اور آپریٹرز ان کے درمیان اسٹریم کو تبدیل کرتے ہیں۔ Combine کال بیکس اور ڈیلیگیٹس کے مسئلے کو حل کرتا ہے، نیٹ ورک کے جوابات سے لے کر UI تبدیلیوں تک کسی بھی غیر متزلزل واقعہ کے لیے ایک متحد تشکیل کا ماڈل فراہم کرتا ہے۔

Combine سے پہلے، iOS ڈیویلپرز تیسرے فریق کی لائبریریاں، خاص طور پر RxSwift استعمال کرتے تھے۔ Apple نے Combine کو ایکوزسٹم میں گہرے انضمام کے ساتھ ایک مقامی متبادل کے طور پر بنایا: فریم ورک @objc برجز کے ذریعے Objective-C کو سپورٹ کرتا ہے، KVO (NSObject.keyValuePublisher کے ذریعے Key-Value Observing) اور NotificationCenter کے ساتھ کام کرتا ہے، اور SwiftUI کی بنیاد بھی ہے۔ SwiftUI میں شائع ہونے والے تمام UIKit اجزاء ویو اپ ڈیٹس کے لیے پردے کے پیچھے Combine کا استعمال کرتے ہیں۔

Combine کو Swift Concurrency کو مدنظر رکھتے ہوئے ڈیزائن کیا گیا ہے: iOS 15 سے شروع کرتے ہوئے، Publisher کو .values کے ذریعے AsyncSequence میں تبدیل کیا جا سکتا ہے اور for-await-in لوپس میں استعمال کیا جا سکتا ہے۔ async فنکشنز کا Publisher میں الٹا تبدیل Future کے ذریعے کیا جاتا ہے۔ Apple WWDC 2024 کے مطابق، ایک بار کی غیر متزلزل کالز کے لیے async/await کے متعارف ہونے کے باوجود، Combine UIKit ایپلیکیشنز میں اسٹریمنگ ڈیٹا کو ہینڈل کرنے کے لیے تجویز کردہ فریم ورک بنا ہوا ہے۔

Combine کے بنیادی تصورات

Combine تین پروٹوکولز پر مبنی ہے: Publisher (Output قسم کی اقدار جاری کرتا ہے، Failure قسم کی خرابی کے ساتھ ناکام ہو سکتا ہے)، Subscriber (اقدار وصول کرتا ہے، Demand کا انتظام کرتا ہے — درخواست کردہ عناصر کی تعداد)، Subscription (منسوخی کی صلاحیت کے ساتھ Publisher-Subscriber کنکشن کی نمائندگی کرتا ہے)۔ ڈیٹا چینل سبسکرائب کرنے پر شروع ہوتا ہے اور منسوخ، مکمل یا خرابی پر ختم ہوتا ہے۔ Demand ایک منفرد Combine تصور ہے: Subscriber Publisher کو بتاتا ہے کہ وہ کتنے عناصر پر کارروائی کرنے کے لیے تیار ہے، پروٹوکول کی سطح پر بیک پریشر نافذ کرتا ہے۔

Publisher اور Subscriber: ری ایکٹیو اسٹریم آرکیٹیکچر

Publisher ایک پروٹوکول ہے جس میں دو منسلک اقسام ہیں: Output (جاری کردہ اقدار کی قسم) اور Failure (خرابی کی قسم جو Error کو نافذ کرتی ہے)۔ اگر اسٹریم ناکام نہیں ہو سکتا، Failure کو Never کے طور پر متعین کیا جاتا ہے — یہ Subscriber کو ضمانت دیتا ہے کہ onReceive صرف Output کے ساتھ کال کیا جائے گا۔ بلٹ ان Publishers میں Just (واحد قدر)، Sequence (صف)، URLSession.DataTaskPublisher (نیٹ ورک کی درخواست)، NotificationCenter.Publisher اور @Published پراپرٹی ریپر شامل ہیں۔

import Combine

// ایک ترتیب سے Publisher بنانا
let publisher = [1, 2, 3, 4, 5].publisher

// قدر پروسیسنگ کے ساتھ Subscriber بنانا
class PrintSubscriber: Subscriber {
    typealias Input = Int
    typealias Failure = Never

    func receive(subscription: Subscription) {
        subscription.request(.unlimited)
    }

    func receive(_ input: Int) -> Subscribers.Demand {
        print("Received: \(input)")
        return .unlimited
    }

    func receive(completion: Subscribers.Completion<Never>) {
        print("مکمل")
    }
}

publisher.subscribe(PrintSubscriber())

Subscription اور Demand

Subscription ایک پروٹوکول ہے جو Publisher اور Subscriber کے درمیان فعال کنکشن کی نمائندگی کرتا ہے۔ Subscriber receive(subscription:) طریقہ میں Subscription وصول کرتا ہے اور Demand متعین کرنے کے لیے request(_:) کال کرتا ہے: .unlimited (تمام اقدار)، .max(N) (محدود تعداد) یا .none (توقف)۔ Demand متحرک طور پر تبدیل ہو سکتا ہے — Subscriber ڈیٹا وصولی کے دوران درخواست کردہ عناصر کی تعداد بڑھا یا گھٹا سکتا ہے۔ یہ Publisher کی طرف بفرنگ کے بغیر بیک پریشر فراہم کرتا ہے۔

Subject اور CurrentValueSubject

Subject ایک قسم ہے جو Publisher اور Subscriber کو یکجا کرتی ہے۔ Subject کو Publisher کے طور پر (سبسکرائبرز اسے سبسکرائب کرتے ہیں) اور ایک ہی وقت میں Subscriber کے طور پر (اس میں اقدار بھیجی جاتی ہیں) استعمال کیا جا سکتا ہے۔ Combine دو قسم کے Subject فراہم کرتا ہے: PassthroughSubject (حالت محفوظ نہیں کرتا، صرف نئی اقدار منتقل کرتا ہے) اور CurrentValueSubject (موجودہ قدر محفوظ کرتا ہے اور اسے نئے سبسکرائبرز تک پہنچاتا ہے)۔ Subject ضروری ہے کہ امپیریٹو کوڈ کو Combine ری ایکٹو چینز میں ضم کیا جا سکے۔

let subject = PassthroughSubject<String, Never>()

// Publisher کے طور پر سبسکرائب کرنا
let cancellable = subject
    .map { $0.uppercased() }
    .sink { print($0) }

// Subscriber کے طور پر اقدار بھیجنا
subject.send("hello")  // "HELLO" پرنٹ کرتا ہے
subject.send("world")  // "WORLD" پرنٹ کرتا ہے

CurrentValueSubject PassthroughSubject سے اس لحاظ سے مختلف ہے کہ اس کی ایک ابتدائی قدر اور value پراپرٹی ہے: ایک سبسکرائبر سبسکرپشن پر فوری طور پر موجودہ قدر وصول کرتا ہے، اور پھر اس کے بعد کی تمام تازہ کارییں۔ CurrentValueSubject.value پڑھنے اور لکھنے کے قابل ہے — value کو تبدیل کرنا خود بخود تمام سبسکرائبرز کو نئی قدر بھیجتا ہے۔ یہ CurrentValueSubject کو MVVM آرکیٹیکچر میں حالت کی نمائندگی کے لیے ایک مثالی انتخاب بناتا ہے: ViewModel CurrentValueSubject شائع کرتا ہے، View sink کے ذریعے تبدیلیوں کو سبسکرائب کرتی ہے۔

دونوں Subject send(completion: .finished) یا send(completion: .failure(error)) کال کر کے اسٹریم ختم کر سکتے ہیں۔ ختم ہونے کے بعد، Subject واقعات قبول کرنا اور جاری کرنا بند کر دیتا ہے۔ لمبی عمر کی اسٹریمز کے لیے جو ختم نہیں ہونی چاہئیں (مثلاً UI واقعات)، غلطی سے send(completion:) کال کرنے سے بچنے کے لیے Never Failure کے ساتھ PassthroughSubject استعمال کرنے کی سفارش کی جاتی ہے۔

تبدیلی اور یکجا کرنے والے آپریٹرز

Combine آپریٹرز Publisher کے طریقے ہیں جو ایک نیا Publisher لوٹاتے ہیں۔ ہر آپریٹر ایک نیا آبجیکٹ بناتا ہے جو اوپر اسٹریم Publisher کو سبسکرائب کرتا ہے اور تبدیل شدہ اقدار کو نیچے اسٹریم جاری کرتا ہے۔ چونکہ Publisher ایک عام قسم ہے، آپریٹرز سخت ٹائپنگ برقرار رکھتے ہیں: map Output<A> کو Output<B> میں تبدیل کرتا ہے، tryMap خرابی کا امکان شامل کرتا ہے۔ Combine میں تقریباً 100 بلٹ ان آپریٹرز ہیں۔

flatMap Combine میں RxSwift ورژن سے ایک اہم فرق رکھتا ہے: یہ ایک closure قبول کرتا ہے جو اسی Failure قسم کے ساتھ Publisher لوٹاتا ہے اور نیسٹڈ Publisher کو مرکزی اسٹریم میں چپٹا کرتا ہے۔ maxPublishers: .max(1) کے ساتھ flatMap switchMap کی طرح برتاؤ کرتا ہے — جب نئی قدر آتی ہے تو پچھلے نیسٹڈ Publisher کو منسوخ کر دیتا ہے۔ یہ تلاش کے منظرناموں کے لیے اہم ہے: جب نیا کردار ٹائپ کیا جاتا ہے، پچھلی HTTP درخواست خود بخود منسوخ ہو جاتی ہے۔

// پچھلی درخواست کو منسوخ کرنے کے ساتھ ڈیباؤنس تلاش
searchTextField.textPublisher
    .debounce(for: .seconds(0.3), scheduler: RunLoop.main)
    .removeDuplicates()
    .flatMap(maxPublishers: .max(1)) { query in
        apiService.searchPublisher(query)
            .catch { _ in Just([]) }
    }
    .receive(on: DispatchQueue.main)
    .sink { results in
        self.tableView.reloadData()
    }
    .store(in: &cancellables)

یکجا کرنے والے آپریٹرز — combineLatest اور zip — RxSwift کی طرح کام کرتے ہیں: combineLatest جب بھی کوئی Publisher تبدیل ہوتا ہے تمام Publishers کی تازہ ترین اقدار کا ایک ٹوپل جاری کرتا ہے؛ zip اقدار کو انڈیکس کے مطابق جوڑتا ہے۔ merge ایک ہی قسم کے Publisher کو ایک اسٹریم میں یکجا کرتا ہے، ترتیب کے تحفظ کی ضمانت نہیں ہے۔ Combine میں select بھی ہے — ایک نایاب آپریٹر جو متعدد میں سے پہلے مکمل ہونے والے Publisher کو منتخب کرتا ہے، اور share — دوبارہ عمل کیے بغیر ایک اسٹریم کو متعدد سبسکرائبرز تک ملٹی کاسٹ کرنا۔

Schedulers اور تھریڈ مینجمنٹ

Scheduler Combine میں ایک پروٹوکول ہے جو آپریٹرز کے لیے عملدرآمد کا سیاق و سباق متعین کرتا ہے۔ RxSwift کے 5+ بلٹ ان Schedulers کے برعکس، Combine موجودہ Apple میکانزم استعمال کرتا ہے: DispatchQueue، RunLoop اور OperationQueue۔ ان میں سے ہر قسم Scheduler پروٹوکول کی تعمیل کرتی ہے، جس سے انہیں اضافی اڈیپٹر کے بغیر براہ راست receive(on:) اور subscribe(on:) پر منتقل کیا جا سکتا ہے۔

receive(on:) نیچے اسٹریم کو متعین Scheduler پر منتقل کرتا ہے — RxSwift میں observeOn کے برابر۔ receive(on:) کے بعد تمام آپریٹرز متعین Scheduler پر عملدرآمد کرتے ہیں۔ subscribe(on:) اوپر اسٹریم کو منتقل کرتا ہے — Publisher کے عملدرآمد کو متاثر کرتا ہے۔ ایک عام نمونہ: پس منظر کے کام کے لیے subscribe(on: DispatchQueue.global()) اور UI اپ ڈیٹس کے لیے receive(on: DispatchQueue.main)۔ SwiftUI میں، .onReceive استعمال کرتے وقت، مرکزی تھریڈ سے بلٹ ان بائنڈنگ کی ضرورت نہیں ہے، لیکن sink کے لیے واضح receive(on:).main تجویز کیا جاتا ہے۔

// پس منظر لوڈنگ + مرکزی تھریڈ پر UI
URLSession.shared.dataTaskPublisher(for: url)
    .subscribe(on: DispatchQueue.global(qos: .background))
    .tryMap { data, response -> Data in
        guard let http = response as? HTTPURLResponse,
              http.statusCode == 200 else {
            throw URLError(.badServerResponse)
        }
        return data
    }
    .receive(on: DispatchQueue.main)
    .decode(type: User.self, decoder: JSONDecoder())
    .sink(receiveCompletion: { print($0) },
         receiveValue: { self.nameLabel.text = $0.name })
    .store(in: &cancellables)

RunLoop.main UI کارروائیوں کے لیے DispatchQueue.main کا ایک متبادل ہے۔ فرق یہ ہے کہ RunLoop.main موجودہ ایپلیکیشن ایونٹ لوپ سے منسلک ہے، جبکہ DispatchQueue.main عالمی مرکزی تھریڈ قطار سے منسلک ہے۔ UIKit کے لیے DispatchQueue.main تجویز کیا جاتا ہے، SwiftUI کے لیے — RunLoop.main۔ ImmediateWhenScheduler موجودہ تھریڈ پر ہم آہنگی سے کارروائیاں انجام دیتا ہے — ٹیسٹ اور سادہ Publisher کے لیے بطور ڈیفالٹ استعمال ہوتا ہے۔

Combine اور SwiftUI: ObservableObject کے ذریعے انضمام

ObservableObject SwiftUI کا ایک پروٹوکول ہے جو تبدیلیاں شائع کرنے والی اشیاء کے لیے ہے۔ ObservableObject کو نافذ کرنے والی کلاس @Published پراپرٹی ریپر کو ان خصوصیات کے لیے استعمال کر سکتی ہے جن کی تبدیلیاں خود بخود SwiftUI کو دوبارہ ڈرائنگ کی ضرورت سے آگاہ کرتی ہیں۔ پردے کے پیچھے، @Published ایک Publisher بناتا ہے جو wrappedValue تبدیل ہونے پر objectWillChange Publisher کو مطلع کرتا ہے۔ SwiftUI @StateObject، @ObservedObject یا @EnvironmentObject کے ذریعے objectWillChange کو سبسکرائب کرتا ہے۔

@Published اور @StateObject

@Published SwiftUI میں Combine کو ضم کرنے کا سب سے عام طریقہ ہے۔ جب @Published پراپرٹی کی قدر تبدیل ہوتی ہے، SwiftUI اس آبجیکٹ کو استعمال کرنے والے تمام Views کو اپ ڈیٹ کرتا ہے۔ @StateObject ایک ObservableObject مثال بناتا ہے اور اس کی تبدیلیوں کو سبسکرائب کرتا ہے۔ @StateObject کے ساتھ بنایا گیا View @Published خصوصیات کے تبدیل ہونے پر خود بخود دوبارہ کھینچتا ہے۔ اگر آبجیکٹ کو متعدد Views کے درمیان شیئر کرنے کی ضرورت ہو، تو @ObservedObject یا @EnvironmentObject استعمال کیا جاتا ہے۔

class UserViewModel: ObservableObject {
    @Published var name: String = ""
    @Published var age: Int = 0
    private var cancellables = Set<AnyCancellable>()

    init() {
        $name
            .debounce(for: .seconds(0.5), scheduler: RunLoop.main)
            .sink { [weak self] newName in
                AnalyticsService.logNameChange(newName)
            }
            .store(in: &cancellables)
    }
}

struct UserView: View {
    @StateObject var viewModel = UserViewModel()

    var body: some View {
        TextField("Name", text: $viewModel.name)
    }
}

AnyCancellable Cancellable کے لیے ایک قسم مٹانے والا ریپر ہے جو سبسکرپشن منسوخی کا ٹوکن محفوظ کرتا ہے۔ Set<AnyCancellable> سبسکرپشنز کی زندگی کے چکر کا انتظام کرتا ہے: جب مالک ڈی انیشیالائز ہوتا ہے، تمام Cancellable خود بخود منسوخ ہو جاتے ہیں۔ SwiftUI پروجیکٹس میں، Set<AnyCancellable> ObservableObject کلاس میں اعلان کیا جاتا ہے، اور سبسکرپشنز .store(in: &cancellables) کے ذریعے شامل کی جاتی ہیں۔ UIKit کے لیے، وہی میکانزم UIViewController میں &cancellables یا دستی cancel() کالز کے ذریعے اسٹوریج کے ساتھ استعمال ہوتے ہیں۔

Combine بمقابلہ RxSwift

Combine اور RxSwift ایک ہی ری ایکٹیو پروگرامنگ کے کاموں کو حل کرتے ہیں لیکن بنیادی آرکیٹیکچرل فرق رکھتے ہیں۔ Combine Apple SDK کا حصہ ہے جس میں iOS 13 تک پسماندہ مطابقت ہے، RxSwift iOS 8+ کو سپورٹ کرنے والی تیسری فریق کی لائبریری ہے۔ Combine Failure جنرک کے ذریعے سخت خرابی کی ٹائپنگ استعمال کرتا ہے، RxSwift ایک واحد Error قسم استعمال کرتا ہے۔ Combine پلیٹ فارم کی سطح پر SwiftUI کے ساتھ مربوط ہے، RxSwift کو UI ایکسٹینشنز کے لیے RxCocoa کی ضرورت ہے۔

Combine اور RxSwift کے درمیان انتخاب پروجیکٹ کی ضروریات پر منحصر ہے۔ اگر کم از کم iOS ورژن >= 13 ہے اور پروجیکٹ SwiftUI استعمال کرتا ہے — Combine بلٹ ان انضمام اور اضافی انحصار کی عدم موجودگی کی بدولت قدرتی انتخاب ہے۔ اگر پروجیکٹ iOS 11-12 کو سپورٹ کرتا ہے، موجودہ RxSwift کوڈبیس پر مشتمل ہے، یا صرف RxSwift میں دستیاب مخصوص آپریٹرز کی ضرورت ہے (مثلاً Observable.from(path:))، — RxSwift ایک جائز حل رہتا ہے۔