स्विफ्ट में डिपेंडेंसी इंजेक्शन (Dependency Injection): शुरुआती लोगों के लिए पूर्ण गाइड

परिचय: आपके कोड को डिपेंडेंसी इंजेक्शन की आवश्यकता क्यों है?

प्रत्येक iOS डेवलपर ऐसी स्थिति का सामना करता है जहां एक क्लास "मोटा" हो जाता है और विशिष्ट कार्यान्वयन से कसकर जुड़ जाता है। आप एक क्लास बदलते हैं, लेकिन दर्जनों अन्य को फिर से लिखना पड़ता है। परिचित लगता है? यह टाइट कपलिंग (tight coupling) की क्लासिक समस्या है।

Dependency Injection (DI) एक डिज़ाइन पैटर्न है जो इस समस्या को हल करता है। ऑब्जेक्ट स्वयं अपनी डिपेंडेंसी बनाने के बजाय, वे बाहर से "इंजेक्ट" की जाती हैं। यह कोड को लचीला, परीक्षण योग्य और SOLID सिद्धांतों (विशेष रूप से डिपेंडेंसी इनवर्जन सिद्धांत) के अनुरूप बनाता है।

इस लेख में, हम जानेंगे कि Swift में DI क्या है, इसे लागू करने के कौन से तरीके हैं, और यह iOS/macOS डेवलपर के जीवन को कैसे सरल बनाता है। हम सरल उदाहरणों का उपयोग करेंगे जो शुरुआती लोगों के लिए भी समझने योग्य हैं।

डिपेंडेंसी इंजेक्शन क्या है? एक सरल उदाहरण

कल्पना करें कि आप पिज्जा बना रहे हैं। DI के बिना विकल्प: आप स्वयं गेहूं उगाते हैं, आटा बनाते हैं, पनीर के लिए गाय का दूध दुहते हैं। यह टाइट कपलिंग है। DI के साथ विकल्प: आप बस एक आपूर्तिकर्ता से सामग्री (डिपेंडेंसी) ऑर्डर करते हैं। आपको यह जानने की आवश्यकता नहीं है कि आटा कैसे बनाया गया - आपके लिए केवल परिणाम मायने रखता है।

प्रोग्रामिंग में भी यही बात है। मान लीजिए, हमारे पास एक क्लास OrderService है जो ईमेल द्वारा ऑर्डर भेजता है:

// ❌ DI के बिना — टाइट कपलिंगclass OrderService {    let mailer = Mailer() // स्वयं डिपेंडेंसी बनाता है

    func process(order: Order) {        mailer.send(email: "नया ऑर्डर: \\(order.id)")    }}

समस्या: हम Mailer को टेस्ट वर्जन से बदल नहीं सकते। क्लास OrderService बहुत अधिक "जानता" है।

// ✅ DI के साथ — डिपेंडेंसी इंजेक्ट की जाती हैclass OrderService {    let mailer: MailerProtocol // कंक्रीट के बजाय एब्स्ट्रैक्शन पर निर्भर

    init(mailer: MailerProtocol) { // इनिशियलाइज़र के माध्यम से इंजेक्शन        self.mailer = mailer    }

    func process(order: Order) {        mailer.send(email: "नया ऑर्डर: \\(order.id)")    }}

अब हम MailerProtocol प्रोटोकॉल को पूरा करने वाली कोई भी ऑब्जेक्ट पास कर सकते हैं - एक वास्तविक मेलर या परीक्षण के लिए एक "स्टब" (stub)।

Swift में डिपेंडेंसी इंजेक्ट करने के तीन मुख्य तरीके

क्लास में डिपेंडेंसी पास करने के तीन लोकप्रिय तरीके हैं। आइए प्रत्येक पर विचार करें।

1. Constructor Injection (इनिशियलाइज़र के माध्यम से)

सबसे सामान्य और पसंदीदा तरीका। ऑब्जेक्ट बनाते समय डिपेंडेंसी पास की जाती है। यह सुनिश्चित करता है कि ऑब्जेक्ट हमेशा वैध स्थिति में हो।

protocol NetworkServiceProtocol {    func fetchData() -> String}

class RealNetworkService: NetworkServiceProtocol {    func fetchData() -> String { return "सर्वर से वास्तविक डेटा" }}

class MockNetworkService: NetworkServiceProtocol {    func fetchData() -> String { return "टेस्ट डेटा" }}

class DataManager {    private let network: NetworkServiceProtocol

    // डिपेंडेंसी init के माध्यम से पास की जाती है    init(network: NetworkServiceProtocol) {        self.network = network    }

    func load() -> String {        return network.fetchData()    }}

// उपयोगlet realManager = DataManager(network: RealNetworkService())let mockManager = DataManager(network: MockNetworkService())

लाभ: स्पष्ट रूप से दिखता है कि किन डिपेंडेंसी की आवश्यकता है। ऑब्जेक्ट तुरंत उपयोग के लिए तैयार है। नुकसान: यदि कई डिपेंडेंसी हैं, तो इनिशियलाइज़र बोझिल हो जाता है।

2. Property Injection (प्रॉपर्टी के माध्यम से)

डिपेंडेंसी ऑब्जेक्ट बनाने के बाद सेट की जाती है। इसका उपयोग अक्सर तब किया जाता है जब डिपेंडेंसी वैकल्पिक हो या इनिशियलाइज़ेशन के समय प्राप्त करना मुश्किल हो।

class UserViewModel {    var apiService: NetworkServiceProtocol? // वैकल्पिक डिपेंडेंसी

    func loadUser() {        apiServi