Method Overriding in C#: What It Is, Why It Matters, and How to Change Parent Behavior

// Base payment processor
public abstract class PaymentProcessor
{
    protected decimal _transactionFee;
    
    public virtual decimal CalculateTransactionFee(decimal amount)
    {
        return _transactionFee;
    }
    
    public virtual async Task<PaymentResult> ProcessPaymentAsync(
        PaymentDetails details, decimal amount, CancellationToken cancellationToken)
    {
        // Common validation logic
        if (amount <= 0)
            return new PaymentResult { Success = false, ErrorCode = "INVALID_AMOUNT" };
            
        // Log the payment attempt - implementation removed for brevity
        
        // This will be overridden by specific processors
        return await ExecutePaymentAsync(details, amount, cancellationToken);
    }
    
    // Method to be overridden by derived classes
    protected abstract Task<PaymentResult> ExecutePaymentAsync(
        PaymentDetails details, decimal amount, CancellationToken cancellationToken);
}

// Credit card payment implementation
public class CreditCardProcessor : PaymentProcessor
{
    public CreditCardProcessor()
    {
        _transactionFee = 0.025m; // 2.5%
    }
    
    public override decimal CalculateTransactionFee(decimal amount)
    {
        // Credit cards have a minimum fee
        decimal standardFee = base.CalculateTransactionFee(amount);
        return Math.Max(standardFee * amount, 0.50m);
    }
    
    protected override async Task<PaymentResult> ExecutePaymentAsync(
        PaymentDetails details, decimal amount, CancellationToken cancellationToken)
    {
        var cardDetails = details as CreditCardDetails 
            ?? throw new ArgumentException("Invalid payment details");
            
        // Credit card-specific implementation - details removed for brevity
        // Connect to credit card gateway, process payment, handle response
        
        return new PaymentResult { Success = true };
    }
}

// PayPal implementation
public class PayPalProcessor : PaymentProcessor
{
    public PayPalProcessor()
    {
        _transactionFee = 0.029m; // 2.9%
    }
    
    public override decimal CalculateTransactionFee(decimal amount)
    {
        // PayPal charges percentage + fixed fee
        return (base.CalculateTransactionFee(amount) * amount) + 0.30m;
    }
    
    protected override async Task<PaymentResult> ExecutePaymentAsync(
        PaymentDetails details, decimal amount, CancellationToken cancellationToken)
    {
        var paypalDetails = details as PayPalDetails 
            ?? throw new ArgumentException("Invalid payment details");
            
        // PayPal-specific implementation - details removed for brevity
        
        return new PaymentResult { Success = true };
    }
}

public class OrderService
{
    private readonly Dictionary<PaymentMethod, PaymentProcessor> _processors;
    
    public OrderService(IEnumerable<PaymentProcessor> availableProcessors)
    {
        // Initialize processors - implementation removed for brevity
    }
    
    public async Task<OrderResult> ProcessOrderAsync(
        Order order, PaymentDetails paymentDetails, CancellationToken cancellationToken)
    {
        // Get the appropriate payment processor based on the customer's choice
        if (!_processors.TryGetValue(order.PaymentMethod, out var processor))
        {
            return new OrderResult { Success = false, Error = "Payment method not supported" };
        }
        
        // Process payment - the correct implementation runs based on the processor type
        // This is where polymorphism happens - the right ExecutePaymentAsync runs
        var paymentResult = await processor.ProcessPaymentAsync(
            paymentDetails, order.TotalAmount, cancellationToken);
            
        // Result handling - removed for brevity
        
        return new OrderResult { Success = true };
    }
}

public abstract class NotificationService
{
    protected readonly ILogger _logger;
    protected readonly NotificationSettings _settings;

    protected NotificationService(ILogger logger, NotificationSettings settings)
    {
        _logger = logger;
        _settings = settings;
    }

    // Template method pattern with parts that can be overridden
    public async Task<NotificationResult> SendNotificationAsync(
        NotificationRequest request, CancellationToken cancellationToken)
    {
        try
        {
            // Common validation - removed for brevity
            
            // Format the notification (overridden by subclasses)
            var formattedContent = FormatNotificationContent(request);

            // Send notification (implementation varies by channel)
            bool success = await SendAsync(formattedContent, request, cancellationToken);

            return new NotificationResult(success);
        }
        catch (Exception ex)
        {
            return new NotificationResult(false, ex.Message);
        }
    }

    // These methods are overridden by specific notification channels
    protected abstract Task<bool> SendAsync(
        string formattedContent, 
        NotificationRequest request, 
        CancellationToken cancellationToken);

    protected virtual string FormatNotificationContent(NotificationRequest request)
    {
        return request.Message;
    }
}

// Email notification implementation
public class EmailNotificationService : NotificationService
{
    private readonly IEmailClient _emailClient;

    public EmailNotificationService(
        ILogger<EmailNotificationService> logger,
        NotificationSettings settings,
        IEmailClient emailClient) : base(logger, settings)
    {
        _emailClient = emailClient;
    }

    protected override string FormatNotificationContent(NotificationRequest request)
    {
        // Add email-specific formatting like HTML
        var baseContent = base.FormatNotificationContent(request);
        return $"<html><body>{baseContent}</body></html>";
    }

    protected override async Task<bool> SendAsync(
        string formattedContent, 
        NotificationRequest request, 
        CancellationToken cancellationToken)
    {
        // Email-specific implementation - details removed for brevity
        return await _emailClient.SendEmailAsync(new EmailRequest(), cancellationToken);
    }
}

// Push notification implementation
public class PushNotificationService : NotificationService
{
    private readonly IPushNotificationProvider _pushProvider;

    public PushNotificationService(
        ILogger<PushNotificationService> logger,
        NotificationSettings settings,
        IPushNotificationProvider pushProvider) : base(logger, settings)
    {
        _pushProvider = pushProvider;
    }

    protected override string FormatNotificationContent(NotificationRequest request)
    {
        // Push notifications need to be shorter
        var content = base.FormatNotificationContent(request);
        return content.Length <= 100 ? content : content.Substring(0, 97) + "...";
    }

    protected override async Task<bool> SendAsync(
        string formattedContent, 
        NotificationRequest request, 
        CancellationToken cancellationToken)
    {
        // Push notification-specific implementation - details removed for brevity
        return await _pushProvider.SendPushNotificationAsync(new PushRequest(), cancellationToken);
    }
}