C# में डिपेंडेंसी इंजेक्शन: उदाहरणों के साथ व्यावहारिक मार्गदर्शिका

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

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

C# और .NET इकोसिस्टम में DI डी-फैक्टो मानक बन गया है। .NET Core से शुरू करके, प्लेटफ़ॉर्म में एक अंतर्निहित डिपेंडेंसी इंजेक्शन कंटेनर शामिल है, जिसका उपयोग ASP.NET Core, बैकग्राउंड सेवाओं और यहाँ तक कि कंसोल एप्लिकेशन में भी किया जाता है। DI की समझ के बिना C# पर आधुनिक विकास की कल्पना करना असंभव है।

इस लेख में हम DI को वास्तविक उदाहरणों के साथ समझेंगे: मैन्युअल इंजेक्शन से लेकर .NET के अंतर्निहित कंटेनर के उपयोग तक। आप देखेंगे कि कठोर कनेक्शन से कैसे छुटकारा पाया जाए और कोड को मॉड्यूलर टेस्टिंग के लिए उपयुक्त कैसे बनाया जाए।

डिपेंडेंसी इंजेक्शन के बिना समस्या

एक सामान्य परिदृश्य की कल्पना करें: क्लास OrderService ऑर्डर प्रोसेस करता है और ईमेल सूचनाएँ भेजता है। DI के बिना कोड इस तरह दिखता है:

public class EmailSender\n{\n    public void Send(string to, string subject, string body)\n    {\n        Console.WriteLine($"ईमेल भेजा जा रहा है {to} को: {subject}");\n    }\n}\n\npublic class OrderService\n{\n    private EmailSender _emailSender;\n\n    public OrderService()\n    {\n        // कठोर कनेक्शन — क्लास स्वयं डिपेंडेंसी बनाता है\n        _emailSender = new EmailSender();\n    }\n\n    public void ProcessOrder(int orderId)\n    {\n        // ऑर्डर प्रोसेसिंग का तर्क...\n        _emailSender.Send("user@example.com", "ऑर्डर कन्फर्म", $"आपका ऑर्डर #{orderId} स्वीकार कर लिया गया।");\n    }\n}

समस्या क्या है? OrderService EmailSender के एक विशिष्ट कार्यान्वयन से कठोर रूप से जुड़ा हुआ है। यदि हम ईमेल भेजने को SMS या लॉगिंग से बदलना चाहते हैं, तो हमें OrderService का कोड बदलना होगा। परीक्षण भी जटिल हो जाता है: वास्तविक EmailSender को mock-ऑब्जेक्ट से बदलना असंभव है।

समाधान: कंस्ट्रक्टर के माध्यम से डिपेंडेंसी इंजेक्शन

DI की ओर पहला कदम — एक एब्स्ट्रैक्शन (इंटरफ़ेस) बनाना और डिपेंडेंसी को कंस्ट्रक्टर के माध्यम से पास करना है। इसे कंस्ट्रक्टर इंजेक्शन (Constructor Injection) कहा जाता है।

चरण 1: इंटरफ़ेस बनाएँ

public interface INotificationService\n{\n    void Send(string to, string subject, string body);\n}

चरण 2: इंटरफ़ेस को लागू करें

public class EmailSender : INotificationService\n{\n    public void Send(string to, string subject, string body)\n    {\n        Console.WriteLine($"ईमेल भेजा गया: {subject} -> {to}");\n    }\n}\n\npublic class SmsSender : INotificationService\n{\n    public void Send(string to, string subject, string body)\n    {\n        Console.WriteLine($"SMS भेजा गया: {subject} -> {to}");\n    }\n}

चरण 3: कंस्ट्रक्टर के माध्यम से डिपेंडेंसी इंजेक्ट करें

public class OrderService\n{\n    private readonly INotificationService _notificationService;\n\n    // डिपेंडेंसी बाहर से पास की जाती है\n    public OrderService(INotificationService notificationService)\n    {\n        _notificationService = notificationService;\n    }\n\n    public void ProcessOrder(int orderId)\n    {\n        // ऑर्डर प्रोसेसिंग का तर्क...\n        _notificationService.Send("user@example.com", "ऑर्डर कन्फर्म", $"आपका ऑर्डर #{orderId} स्वीकार कर लिया गया।");\n    }\n}

अब OrderService को यह नहीं पता कि कौन सा कार्यान्वयन उपयोग किया जा रहा है। हम EmailSender, SmsSender या कोई अन्य क्लास जो INotificationService को लागू करता है, डाल सकते हैं। कोड लचीला और परीक्षण योग्य हो गया है।

.NET में अंतर्निहित IoC-कंटेनर का उपयोग

सभी डिपेंडेंसी को मैन्युअल रूप से बनाना असुविधाजनक है। .NET में एक अंतर्निहित कंटेनर (IoC-कंटेनर) है, जो स्वचालित रूप से ऑब्जेक्ट के जीवनचक्र का प्रबंधन करता है। कंसोल एप्लिकेशन के लिए एक उदाहरण देखें।

चरण 1: पैकेज स्थापित करें