Swift में Dependency Injection: iOS/macOS के लिए सिद्धांत और उदाहरण

Swift में Dependency Injection का परिचय

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

मुख्य विचार यह है कि क्लास को अपनी निर्भरताएँ स्वयं नहीं बनानी चाहिए। इसके बजाय, निर्भरताएँ बाहर से "इंजेक्ट" की जाती हैं। यह SOLID के Dependency Inversion Principle का कार्यान्वयन है।

iOS/macOS डेवलपमेंट के लिए Dependency Injection क्यों महत्वपूर्ण है?

Swift में नेटिव एप्लिकेशन में अक्सर टाइट कपलिंग (tight coupling) की समस्या होती है। एक सामान्य उदाहरण देखें:

class UserService {    let networkManager = NetworkManager()    let database = Database()        func fetchUser(id: Int) -> User {        // लॉजिक    }}

यहाँ UserService NetworkManager और Database के विशिष्ट कार्यान्वयन से मजबूती से जुड़ा हुआ है। यह कई समस्याएँ पैदा करता है:

• परीक्षण में कठिनाई — वास्तविक सेवाओं को मॉक या स्टब से बदलना असंभव है
• कम पुन: प्रयोज्यता — क्लास का उपयोग अन्य कार्यान्वयनों के साथ नहीं किया जा सकता
• SRP का उल्लंघन — क्लास न केवल बिज़नेस लॉजिक बल्कि निर्भरताएँ बनाने का भी काम करता है

Dependency Injection इन समस्याओं को हल करता है, जिससे कंस्ट्रक्टर, प्रॉपर्टी या मेथड के माध्यम से निर्भरताएँ इंजेक्ट की जा सकती हैं।

Swift में Dependency Injection लागू करने के तरीके

1. कंस्ट्रक्टर के माध्यम से इंजेक्शन (Constructor Injection)

सबसे सामान्य और अनुशंसित तरीका। निर्भरताएँ इनिशियलाइज़र के माध्यम से पास की जाती हैं:

protocol NetworkService {    func request(endpoint: String) -> Data}

protocol DatabaseService {    func save(user: User)}

class UserService {    private let networkService: NetworkService    private let databaseService: DatabaseService        init(networkService: NetworkService, databaseService: DatabaseService) {        self.networkService = networkService        self.databaseService = databaseService    }        func fetchUser(id: Int) -> User? {        let data = networkService.request(endpoint: "users/\\(id)")        // डेटा पार्सिंग        return User(id: id, name: "John")    }}

लाभ: निर्भरताएँ स्पष्ट रूप से दिखाई देती हैं, क्लास के काम करने के लिए अनिवार्य हैं, परीक्षण करना आसान है।

2. प्रॉपर्टी के माध्यम से इंजेक्शन (Property Injection)

ऑब्जेक्ट बनाने के बाद निर्भरताएँ सेट की जाती हैं:

class AuthManager {    var networkService: NetworkService?        func login(username: String, password: String) -> Bool {        guard let service = networkService else { return false }        // प्रमाणीकरण लॉजिक        return true    }}

// उपयोगlet authManager = AuthManager()authManager.networkService = RealNetworkService()

कमी: निर्भरताएँ सेट नहीं हो सकती हैं, जिससे ऑप्शनल टाइप और संभावित क्रैश हो सकते हैं।

3. मेथड के माध्यम से इंजेक्शन (Method Injection)

निर्भरता सीधे मेथड में पास की जाती है:

class DataProcessor {    func process(data: Data, using service: NetworkService) -> ProcessedData {        let result = service.request(endpoint: "process")        // प्रोसेसिंग        return ProcessedData()    }}

यह उन मामलों के लिए उपयुक्त है जहाँ निर्भरता केवल एक मेथड के लिए आवश्यक हो।

व्यावहारिक उदाहरण: कार्य प्रबंधन एप्लिकेशन

आइए DI का उपयोग करके एक सरल iOS एप्लिकेशन बनाएँ:

// निर्भरता प्रोटोकॉलprotocol TaskRepository {    func fetchTasks() ->
```