नियंत्रण का उलटना सॉफ्टवेयर आर्किटेक्चर का एक सामान्य डिजाइन सिद्धांत है जो पुन: प्रयोज्य, मॉड्यूलर सॉफ्टवेयर फ्रेमवर्क बनाने में सहायता करता है जिन्हें बनाए रखना आसान है।
यह एक डिजाइन सिद्धांत है जिसमें सामान्य लिखित पुस्तकालय या पुन: प्रयोज्य कोड से नियंत्रण का प्रवाह "प्राप्त" होता है।
इसे बेहतर ढंग से समझने के लिए, हम देखते हैं कि कोडिंग के पहले के दिनों में हम कैसे कोड करते थे। प्रक्रियात्मक / पारंपरिक भाषाओं में, व्यावसायिक तर्क आमतौर पर एप्लिकेशन के प्रवाह को नियंत्रित करता है और सामान्य या पुन: प्रयोज्य कोड / फ़ंक्शन को "कॉल" करता है। उदाहरण के लिए, एक साधारण कंसोल एप्लिकेशन में, मेरे प्रोग्राम के निर्देशों द्वारा मेरा नियंत्रण नियंत्रित किया जाता है, जिसमें कुछ सामान्य पुन: प्रयोज्य कार्यों के लिए कॉल शामिल हो सकते हैं।
print ("Please enter your name:");
scan (&name);
print ("Please enter your DOB:");
scan (&dob);
//More print and scan statements
<Do Something Interesting>
//Call a Library function to find the age (common code)
print Age
आईओआरसी के साथ कंट्रास्ट में, फ्रेमवर्क पुन: प्रयोज्य कोड है जो व्यापार तर्क को "कॉल" करता है।
उदाहरण के लिए, विंडोज़ आधारित प्रणाली में, यूआई तत्वों जैसे बटन, मेनू, विंडो और डायलॉग बॉक्स बनाने के लिए एक रूपरेखा पहले से ही उपलब्ध होगी। जब मैं अपने आवेदन का व्यावसायिक तर्क लिखता हूं, तो यह फ्रेमवर्क की घटनाएं होंगी जो मेरे व्यवसाय तर्क कोड (जब किसी घटना को निकाल दिया जाता है) को कॉल करेंगी और इसके विपरीत नहीं।
हालाँकि, फ्रेमवर्क कोड को मेरे व्यावसायिक तर्क के बारे में पता नहीं है, फिर भी यह पता चलेगा कि मेरे कोड को कैसे कॉल किया जाए। यह ईवेंट्स / डेलीगेट्स, कॉलबैक आदि का उपयोग करके हासिल किया जाता है। यहाँ प्रवाह का नियंत्रण "उलटा" है।
इसलिए, सांख्यिकीय रूप से बाध्य वस्तुओं पर नियंत्रण के प्रवाह के आधार पर, प्रवाह समग्र वस्तु ग्राफ और विभिन्न वस्तुओं के बीच संबंधों पर निर्भर करता है।
डिपेंडेंसी इंजेक्शन एक डिज़ाइन पैटर्न है जो वस्तुओं की निर्भरता को हल करने के लिए IoC सिद्धांत को लागू करता है।
सरल शब्दों में, जब आप कोड लिखने की कोशिश कर रहे हैं, तो आप विभिन्न वर्गों का निर्माण और उपयोग कर रहे होंगे। एक वर्ग (क्लास ए) अन्य कक्षाओं (कक्षा बी और / या डी) का उपयोग कर सकता है। तो, क्लास बी और डी क्लास ए की निर्भरता हैं।
एक साधारण सादृश्य एक क्लास कार होगा। एक कार इंजन, टायर और अन्य जैसे अन्य वर्गों पर निर्भर हो सकती है।
डिपेंडेंसी इंजेक्शन बताता है कि डिपेंडेंट क्लासेस (क्लास कार) के बजाय अपनी निर्भरता (क्लास इंजन और क्लास टायर) बनाने के लिए, क्लास को डिपेंडेंसी के ठोस उदाहरण के साथ इंजेक्ट किया जाना चाहिए।
अधिक व्यावहारिक उदाहरण से समझें। विचार करें कि आप अपना खुद का TextEditor लिख रहे हैं। अन्य बातों के अलावा, आप एक वर्तनी जाँचक हो सकते हैं जो उपयोगकर्ता को अपने पाठ में टाइपोस की जांच करने की सुविधा प्रदान करता है। इस तरह के एक कोड का एक सरल कार्यान्वयन हो सकता है:
Class TextEditor
{
//Lot of rocket science to create the Editor goes here
EnglishSpellChecker objSpellCheck;
String text;
public void TextEditor()
{
objSpellCheck = new EnglishSpellChecker();
}
public ArrayList <typos> CheckSpellings()
{
//return Typos;
}
}
पहली नजर में सब रौबीले लगते हैं। उपयोगकर्ता कुछ पाठ लिखेगा। डेवलपर टेक्स्ट को कैप्चर करेगा और CheckSpellings फ़ंक्शन को कॉल करेगा और टाइपोस की एक सूची ढूंढेगा जिसे वह उपयोगकर्ता को दिखाएगा।
सब कुछ एक महान दिन तक काम करने लगता है जब एक उपयोगकर्ता संपादक में फ्रेंच लिखना शुरू करता है।
अधिक भाषाओं के लिए सहायता प्रदान करने के लिए, हमें और अधिक SpellCheckers रखने की आवश्यकता है। संभवतः फ्रेंच, जर्मन, स्पेनिश आदि।
यहां, हमने "इंग्लिश" स्पेलचैकर के साथ हमारे TextEditor वर्ग के साथ कसकर युग्मित कोड बनाया है, जिसका अर्थ है कि हमारा TextEditor वर्ग EnglishSpellChecker पर निर्भर है या अन्य अंग्रेजी में SpellCheker TextEditor के लिए निर्भरता है। हमें इस निर्भरता को दूर करने की आवश्यकता है। इसके अलावा, हमारे पाठ संपादक को रन टाइम में डेवलपर के विवेक के आधार पर किसी भी वर्तनी परीक्षक के ठोस संदर्भ को रखने का एक तरीका चाहिए।
इसलिए, जैसा कि हमने DI के परिचय में देखा, यह सुझाव देता है कि वर्ग को अपनी निर्भरता के साथ इंजेक्ट किया जाना चाहिए। तो, यह कॉलिंग कोड की जिम्मेदारी होनी चाहिए कि वह सभी निर्भरता को इंजेक्टेड क्लास / कोड को बताए। इसलिए हम अपने कोड का पुनर्गठन कर सकते हैं
interface ISpellChecker
{
Arraylist<typos> CheckSpelling(string Text);
}
Class EnglishSpellChecker : ISpellChecker
{
public override Arraylist<typos> CheckSpelling(string Text)
{
//All Magic goes here.
}
}
Class FrenchSpellChecker : ISpellChecker
{
public override Arraylist<typos> CheckSpelling(string Text)
{
//All Magic goes here.
}
}
हमारे उदाहरण में, TextEditor वर्ग को ISpellChecker प्रकार का ठोस उदाहरण प्राप्त करना चाहिए।
अब, निर्भरता को कंस्ट्रक्टर, एक सार्वजनिक संपत्ति या एक विधि में इंजेक्ट किया जा सकता है।
कंस्ट्रक्टर डि का उपयोग करके हमारी कक्षा को बदलने की कोशिश करें। परिवर्तित TextEditor वर्ग कुछ इस तरह दिखाई देगा:
Class TextEditor
{
ISpellChecker objSpellChecker;
string Text;
public void TextEditor(ISpellChecker objSC)
{
objSpellChecker = objSC;
}
public ArrayList <typos> CheckSpellings()
{
return objSpellChecker.CheckSpelling();
}
}
ताकि टेक्स्ट एडिटर बनाते समय कॉलिंग कोड, टेक्स्ट एडिटर के उदाहरण के लिए उपयुक्त SpellChecker प्रकार को इंजेक्ट कर सके।
पूरा लेख आप यहां पढ़ सकते हैं
