Violating SOLID for Performance: When It's Okay and How to Isolate It

// Beautiful SRP-compliant code
public class FraudDetectionService
{
    private readonly ITransactionValidator _validator;
    private readonly IVelocityChecker _velocityChecker;
    private readonly IRiskScorer _riskScorer;
    private readonly IBlacklistChecker _blacklistChecker;
    private readonly ILogger<FraudDetectionService> _logger;

    public FraudDetectionService(
        ITransactionValidator validator,
        IVelocityChecker velocityChecker,
        IRiskScorer riskScorer,
        IBlacklistChecker blacklistChecker,
        ILogger<FraudDetectionService> logger)
    {
        _validator = validator;
        _velocityChecker = velocityChecker;
        _riskScorer = riskScorer;
        _blacklistChecker = blacklistChecker;
        _logger = logger;
    }

    public async Task<FraudResult> CheckTransactionAsync(Transaction transaction)
    {
        // Each step is a separate service call
        var validationResult = await _validator.ValidateAsync(transaction);
        if (!validationResult.IsValid)
            return FraudResult.Invalid(validationResult.Errors);

        var velocityResult = await _velocityChecker.CheckVelocityAsync(transaction);
        if (velocityResult.IsBlocked)
            return FraudResult.Blocked("Velocity limit exceeded");

        var riskScore = await _riskScorer.CalculateRiskAsync(transaction);
        
        var blacklistResult = await _blacklistChecker.CheckAsync(transaction.CardNumber);
        if (blacklistResult.IsBlacklisted)
            return FraudResult.Blocked("Card blacklisted");

        return FraudResult.Approved(riskScore);
    }
}

/// <summary>
/// PERFORMANCE HOTPATH: This class intentionally violates SRP for speed.
/// It combines validation, velocity checking, risk scoring, and blacklist 
/// checking into a single optimized method to minimize allocations and 
/// async overhead in our fraud detection pipeline.
/// 
/// 
/// DO NOT follow this pattern elsewhere - use FraudDetectionService 
/// for non-critical paths.
/// </summary>
public class OptimizedFraudDetectionService
{
    private readonly IMemoryCache _blacklistCache;
    private readonly IMemoryCache _velocityCache;
    private readonly ILogger<OptimizedFraudDetectionService> _logger;
    
    // Pre-compiled regex for card validation - no allocation per call
    private static readonly Regex CardPattern = new(@"^\d{13,19}$", RegexOptions.Compiled);
    
    // Reusable StringBuilder to avoid string allocations
    private static readonly ThreadLocal<StringBuilder> StringBuilderCache = 
        new(() => new StringBuilder(256));

    public OptimizedFraudDetectionService(
        IMemoryCache blacklistCache,
        IMemoryCache velocityCache,
        ILogger<OptimizedFraudDetectionService> logger)
    {
        _blacklistCache = blacklistCache;
        _velocityCache = velocityCache;
        _logger = logger;
    }

    public ValueTask<FraudResult> CheckTransactionFastAsync(Transaction transaction)
    {
        // Inline validation - no separate service call
        if (string.IsNullOrEmpty(transaction.CardNumber) || 
            !CardPattern.IsMatch(transaction.CardNumber))
        {
            return ValueTask.FromResult(FraudResult.Invalid("Invalid card number"));
        }

        if (transaction.Amount <= 0 || transaction.Amount > 50000)
        {
            return ValueTask.FromResult(FraudResult.Invalid("Invalid amount"));
        }

        // Inline blacklist check - cache hit is synchronous
        var cardHash = transaction.CardNumber.GetHashCode();
        if (_blacklistCache.TryGetValue(cardHash, out _))
        {
            return ValueTask.FromResult(FraudResult.Blocked("Card blacklisted"));
        }

        // Inline velocity check with optimized key building
        var sb = StringBuilderCache.Value!;
        sb.Clear();
        sb.Append(transaction.MerchantId)
          .Append(':')
          .Append(cardHash)
          .Append(':')
          .Append(DateTime.UtcNow.Hour); // Hour-based velocity window

        var velocityKey = sb.ToString();
        var currentCount = _velocityCache.GetOrCreate(velocityKey, _ => 0);
        
        if (currentCount >= 10) // Max 10 transactions per hour
        {
            return ValueTask.FromResult(FraudResult.Blocked("Velocity limit exceeded"));
        }

        // Update velocity counter
        _velocityCache.Set(velocityKey, currentCount + 1, TimeSpan.FromHours(1));

        // Inline risk scoring - simplified but fast
        var riskScore = CalculateRiskScoreFast(transaction);
        
        return ValueTask.FromResult(FraudResult.Approved(riskScore));
    }

    private static double CalculateRiskScoreFast(Transaction transaction)
    {
        // Simplified risk calculation optimized for speed
        // In real system, this might use pre-computed lookup tables
        double score = 0.1; // Base score
        
        if (transaction.Amount > 1000) score += 0.2;
        if (transaction.IsInternational) score += 0.3;
        if (transaction.TimeOfDay < 6 || transaction.TimeOfDay > 22) score += 0.1;
        
        return Math.Min(score, 1.0);
    }
}

[MemoryDiagnoser]
[SimpleJob(RuntimeMoniker.Net80)]
public class FraudDetectionBenchmark
{
    private FraudDetectionService _solidService;
    private OptimizedFraudDetectionService _optimizedService;
    private Transaction _testTransaction;

    [GlobalSetup]
    public void Setup()
    {
        // Setup both services with test dependencies
        _testTransaction = new Transaction
        {
            CardNumber = "4111111111111111",
            Amount = 100.50m,
            MerchantId = 12345,
            IsInternational = false,
            TimeOfDay = 14
        };
    }

    [Benchmark(Baseline = true)]
    public async Task<FraudResult> SolidCompliant()
    {
        return await _solidService.CheckTransactionAsync(_testTransaction);
    }

    [Benchmark]
    public async Task<FraudResult> Optimized()
    {
        return await _optimizedService.CheckTransactionFastAsync(_testTransaction);
    }
}

// Keep the clean version for maintainability
public class UserService : IUserService { /* ... */ }

// Add the fast version for hot paths
public class FastUserService : IFastUserService { /* ... */ }

public class OptimizedPaymentProcessor { }
public class FastTransactionValidator { }
public class HotPathOrderCalculator { }

/// <summary>
/// PERFORMANCE OPTIMIZATION: This class violates SRP by combining
/// order validation, tax calculation, and inventory checking.
/// 
/// Benchmarks: 12ms -> 3ms per order (4x improvement)
/// Justification: Order processing is our highest-volume endpoint
/// 
/// DO NOT use this pattern elsewhere without measuring first.
/// </summary>

[Test]
public async Task FastOrderProcessor_ValidOrder_ReturnsSuccess()
{
    // Test the entire optimized flow
    var processor = CreateFastOrderProcessor();
    var order = CreateValidOrder();
    
    var result = await processor.ProcessOrderFastAsync(order);
    
    Assert.That(result.IsSuccess, Is.True);
    Assert.That(result.ProcessingTimeMs, Is.LessThan(5));
}