C# मध्ये तत्त्वे लागू करणे SOLID: उदाहरणे आणि सर्वोत्तम पद्धती

Single Responsibility Principle(SRP)

हे तत्व सांगते की प्रत्येक वर्गाची एकच जबाबदारी असावी. हे यावर जोर देते की वर्गाने एक विशिष्ट कार्य केले पाहिजे आणि बदलण्याची खूप कारणे नसावीत.

उदाहरण: वापरकर्ता माहिती व्यवस्थापित करणे आणि ईमेल सूचना पाठवणे.

class UserManager {  
  public void CreateUser(UserData userData) {  
    // Logic to create a user  
  }  
}  
  
class EmailService {  
  public void SendEmail(EmailData emailData) {  
    // Logic to send an email  
  }  
}  

Open/Closed Principle(OCP)

हे तत्त्व विद्यमान कोड बदलण्याऐवजी नवीन कोड जोडून कार्यक्षमता वाढविण्यास प्रोत्साहन देते.

उदाहरण: ई-कॉमर्स ऍप्लिकेशनमध्ये विविध पेमेंट पद्धती हाताळणे.

abstract class PaymentProcessor {  
  public abstract void ProcessPayment();  
}  
  
class CreditCardPaymentProcessor: PaymentProcessor {  
  public override void ProcessPayment() {  
    // Logic to process credit card payment  
  }  
}  
  
class PayPalPaymentProcessor: PaymentProcessor {  
  public override void ProcessPayment() {  
    // Logic to process PayPal payment  
  }  
}  

Liskov Substitution Principle(LSP)

हे तत्व असे प्रतिपादन करते की व्युत्पन्न वर्गाच्या ऑब्जेक्ट्स प्रोग्रामच्या शुद्धतेवर परिणाम न करता बेस क्लासच्या ऑब्जेक्ट्ससाठी बदलण्यायोग्य असाव्यात.

उदाहरण: भौमितिक आकार व्यवस्थापित करणे.

abstract class Shape {  
  public abstract double CalculateArea();  
}  
  
class Rectangle: Shape {  
  public override double CalculateArea() {  
    // Logic to calculate area of rectangle  
  }  
}  
  
class Square: Shape {  
  public override double CalculateArea() {  
    // Logic to calculate area of square  
  }  
}  

Interface Segregation Principle(ISP)

हे तत्त्व वर्गांना आवश्यक नसलेल्या पद्धती लागू करण्यास भाग पाडू नये म्हणून इंटरफेसचे लहान तुकडे करण्याचा सल्ला देते.

उदाहरण: डेटा अपडेट करण्यासाठी आणि प्रदर्शित करण्यासाठी इंटरफेस.

interface IUpdateableFeature {  
  void UpdateFeature();  
}  
  
interface IDisplayableFeature {  
  void DisplayFeature();  
}  

Dependency Inversion Principle(DIP)

हे तत्त्व अवलंबित्व व्यवस्थापित करण्यासाठी अवलंबित्व इंजेक्शन वापरण्यास सूचित करते.

उदाहरण: अवलंबित्व व्यवस्थापित करण्यासाठी अवलंबित्व इंजेक्शन वापरणे.

class OrderProcessor {  
  private readonly DBConnection _dbConnection;  
  private readonly EmailService _emailService;  
  
  public OrderProcessor(DBConnection dbConnection, EmailService emailService) {  
    _dbConnection = dbConnection;  
    _emailService = emailService;  
  }  
}  

लक्षात ठेवा की SOLID C# मध्ये तत्त्वे लागू करणे हे तुमच्या प्रकल्पाच्या विशिष्ट उद्देशावर आणि SOLID C# बद्दलच्या तुमच्या समजुतीनुसार लवचिकपणे केले पाहिजे.