साक्षात्कार के प्रश्न

1. निर्भरता इंजेक्शन क्या है और यह उपयोगी क्यों है?
2. क्या आप उदाहरण दे सकते हैं कि आईओएस में निर्भरता इंजेक्शन का उपयोग कैसे किया जाता है?
3. निर्भरता इंजेक्शन के विभिन्न प्रकार क्या हैं (कन्स्ट्रक्टर इंजेक्शन, सेटर इंजेक्शन, आदि), और प्रत्येक प्रकार का उपयोग कब किया जाना चाहिए?
4. आईओएस ऐप की टेस्टेबिलिटी में सुधार के लिए निर्भरता इंजेक्शन का उपयोग कैसे किया जा सकता है?
5. क्या आप आईओएस विकास में निर्भरता इंजेक्शन का उपयोग करते समय उत्पन्न होने वाली कुछ सामान्य चुनौतियों या नुकसान पर चर्चा कर सकते हैं और उनसे कैसे बचा जा सकता है?
6. कुछ लोकप्रिय आईओएस डिपेंडेंसी इंजेक्शन फ्रेमवर्क क्या हैं, और उनकी प्रमुख विशेषताएं और फायदे क्या हैं?
7. क्या आप आईओएस विकास में निर्भरता इंजेक्शन का उपयोग करने के लिए कुछ सर्वोत्तम प्रथाओं पर चर्चा कर सकते हैं?

नियंत्रण का उलटा एक सॉफ्टवेयर डिज़ाइन पैटर्न है जो डेवलपर से ढांचे में नियंत्रण के हस्तांतरण पर केंद्रित है। फ्रेमवर्क तब ऑब्जेक्ट इंस्टेंस बनाने और प्रबंधित करने के लिए ज़िम्मेदार होता है, जबकि डेवलपर ऐप विशिष्ट कॉन्फ़िगरेशन प्रदान करने के लिए ज़िम्मेदार होता है।

यह एक पैटर्न है जो आपको नियंत्रण के प्रवाह को उलटने देता है। इसे प्राप्त करने के लिए आप एक वर्ग की सभी जिम्मेदारियों को बाहर ले जाते हैं, इसके मुख्य एक को छोड़कर, उन्हें इसकी निर्भरता बनाते हैं। इस प्रकार आपकी वस्तु उन्हें बनाना नहीं जानती। यह कक्षाओं के बीच कड़े संबंधों को समाप्त करके कोड को परीक्षण योग्य और बनाए रखने योग्य बनाता है।

डिपेंडेंसी इंजेक्शन

निर्भरता इंजेक्शन कुछ पैटर्नों में से एक है जो नियंत्रण के व्युत्क्रम के सिद्धांतों को लागू करने में मदद करता है। आप DI को कई तरीकों से लागू कर सकते हैं

कंस्ट्रक्टर इंजेक्शन

कंस्ट्रक्टर इंजेक्शन में, हम सभी निर्भरताओं को कंस्ट्रक्टर के माध्यम से पैरामीटर के रूप में पास करते हैं।

protocol EngineProtocol {
  func start()
  func stop()
}

protocol TransmissionProtocol {
  func changeGear(gear: Gear)
}

final class Car {
  private let engine: EngineProtocol
  private let transmission: TransmissionProtocol

  init(engine: EngineProtocol, transmission: TransmissionProtocol) {
    self.engine = engine
    self.transmission = transmission
  }
}

final class Car {
  private var engine: EngineProtocol?
  private var transmission: TransmissionProtocol?

  func setEngine(engine: EngineProtocol) {
    self.engine = engine
  }

  func setTransmission(transmission: TransmissionProtocol) {
    self.transmission = transmission
  }
}

मुख्य विचार यह है कि कोड का एक टुकड़ा जिसके लिए कुछ निर्भरताओं की आवश्यकता होती है, उन्हें स्वयं के लिए नहीं बनाया जाएगा, बल्कि इन निर्भरताओं को प्रदान करने पर नियंत्रण कुछ उच्च अमूर्तता के लिए स्थगित कर दिया जाता है।

नियंत्रण के व्युत्क्रम का मुख्य लाभ यह है कि

• DI आपके कोड की मॉड्यूलरिटी को बेहतर बनाने में मदद करता है, समझने और बनाए रखने में आसान
• परीक्षण के दौरान नकली या नकली निर्भरताओं को इंजेक्ट करना आसान है
• आपके घटकों द्वारा उपयोग की जाने वाली निर्भरताओं को आसानी से बदलने या स्वैप करने की अनुमति देकर, आपके ऐप की लचीलापन और विस्तारशीलता।