डिपेंडेंसी इनवर्जन सिद्धांत (DIP) क्या है और C# में इसे कैसे लागू करें

उच्च-स्तरीय मॉड्यूल्स निम्न-स्तरीय मॉड्यूल्स पर निर्भर नहीं होने चाहिए। दोनों को अब्स्ट्रैक्शन पर निर्भर करना चाहिए।

अब्स्ट्रैक्शन विवरणों पर निर्भर नहीं होने चाहिए। विवरण अब्स्ट्रैक्शन पर निर्भर होने चाहिए।

यह सिद्धांत मुख्य रूप से कोड मॉड्यूल्स के बीच निर्भरता को कम करने से संबंधित है।

डिपेंडेंसी इनवर्जन लागू करने से पहले (तंग कपलिंग)

using System;

namespace SolidPrinciples.Dependency.Inversion.Before
{
    public class Email
    {
        public string ToAddress { get; set; }
        public string Subject { get; set; }
        public string Content { get; set; }
        public void SendEmail() { /* Send email */ }
    }

    public class SMS
    {
        public string PhoneNumber { get; set; }
        public string Message { get; set; }
        public void SendSMS() { /* Send sms */ }
    }

    public class Notification
    {
        private Email _email;
        private SMS _sms;

        public Notification()
        {
            _email = new Email(); // ठोस क्लास पर सीधी निर्भरता
            _sms = new SMS();
        }

        public void Send()
        {
            _email.SendEmail();
            _sms.SendSMS();
        }
    }
}

समस्याएं: Notification क्लास ठोस Email और SMS क्लासेस पर निर्भर है। नया नोटिफिकेशन प्रकार जोड़ने के लिए Notification क्लास को संशोधित करना पड़ता है (OCP उल्लंघन)।

डिपेंडेंसी इनवर्जन लागू करने के बाद (लूज कपलिंग)

using System.Collections.Generic;

namespace SolidPrinciples.Dependency.Inversion.After
{
    // अब्स्ट्रैक्शन
    public interface IMessage
    {
        void SendMessage();
    }

    // लो-लेवल मॉड्यूल्स अब्स्ट्रैक्शन लागू करते हैं
    public class Email : IMessage
    {
        public string ToAddress { get; set; }
        public string Subject { get; set; }
        public string Content { get; set; }
        public void SendMessage() { /* Send email */ }
    }

    public class SMS : IMessage
    {
        public string PhoneNumber { get; set; }
        public string Message { get; set; }
        public void SendMessage() { /* Send Sms */ }
    }

    // हाई-लेवल मॉड्यूल अब्स्ट्रैक्शन पर निर्भर करता है
    public class Notification
    {
        private ICollection<IMessage> _messages;

        // कंस्ट्रक्टर इंजेक्शन - निर्भरता बाहर से प्रदान की जाती है
        public Notification(ICollection<IMessage> messages)
        {
            this._messages = messages;
        }

        public void Send()
        {
            foreach (var message in _messages)
            {
                message.SendMessage();
            }
        }
    }
}

उपयोग

// कंपोजिशन रूट (उदाहरण: Main, Startup.cs)
var messages = new List<IMessage>
{
    new Email { ToAddress = "user@example.com", Subject = "Hello", Content = "Body" },
    new SMS { PhoneNumber = "1234567890", Message = "Hi!" }
};

var notification = new Notification(messages);
notification.Send();

DIP के लाभ

• डिकपलिंग: हाई-लेवल मॉड्यूल लो-लेवल विवरण नहीं जानता
• टेस्टेबिलिटी: मॉक IMessage कार्यान्वयन के साथ आसान यूनिट टेस्टिंग
• एक्सटेंसिबिलिटी: Notification को बदले बिना नए IMessage प्रकार जोड़ें
• पुन: उपयोगिता: IMessage कार्यान्वयन अन्य जगहों पर पुन: उपयोग योग्य

DIP बनाम DI (डिपेंडेंसी इंजेक्शन)

DIP आर्किटेक्चर को निर्देशित करता है; DI इसे लागू करने का एक तरीका है।