Open/Closed Principle (OCP) and Dependency Inversion Principle (DIP)

This function is part of an implementation following the Open/Closed Principle (OCP) and Dependency Inversion Principle (DIP) in C#.

🔹 What Does This Function Do?
csharp

public class PaymentProcessor
{
    public void ProcessPayment(IPaymentMethod paymentMethod) => paymentMethod.Pay();
}

The class PaymentProcessor has one method: ProcessPayment(IPaymentMethod paymentMethod).

This method accepts an object of type IPaymentMethod and calls its Pay() method.

🔹 Understanding the Components
IPaymentMethod Interface (Dependency Inversion)

csharp

public interface IPaymentMethod
{
    void Pay();
}

IPaymentMethod is an interface that enforces a Pay() method.

Different payment methods (like credit cards, PayPal, etc.) will implement this interface.

Concrete Implementations

csharp

public class CreditCardPayment : IPaymentMethod
{
    public void Pay() { Console.WriteLine("Processing credit card payment..."); }
}

public class PayPalPayment : IPaymentMethod
{
    public void Pay() { Console.WriteLine("Processing PayPal payment..."); }
}

CreditCardPayment and PayPalPayment implement IPaymentMethod.

Each provides its own version of Pay().

Using the PaymentProcessor

csharp

class Program
{
    static void Main()
    {
        PaymentProcessor processor = new PaymentProcessor();

        IPaymentMethod creditCard = new CreditCardPayment();
        IPaymentMethod paypal = new PayPalPayment();

        processor.ProcessPayment(creditCard); // Output: Processing credit card payment...
        processor.ProcessPayment(paypal);    // Output: Processing PayPal payment...
    }
}

The ProcessPayment method works with any payment method that implements IPaymentMethod.

This means we can add new payment types without modifying PaymentProcessor, keeping the code extensible.

🔹 Why Is This Useful?
✅ Follows Open/Closed Principle (OCP) → We can extend the system (e.g., add "BitcoinPayment") without modifying PaymentProcessor.
✅ Follows Dependency Inversion Principle (DIP) → PaymentProcessor depends on an abstraction (IPaymentMethod) instead of a concrete class.
✅ Flexible & Maintainable → New payment methods can be added without touching existing code.