C-Sharp

TL;DR: The Open/Closed Principle (OCP) states: classes should be open for extension, but closed for modification. You don’t need to create a plugin for every new feature, favor simpler patterns like strategy, inheritance, or composition. Start with well-named abstractions; introduce extensibility points only when real change is expected. Keep code maintainable by balancing extension points with simplicity. Overengineering is a bigger risk than occasional refactoring. The Open/Closed Principle isn’t about making everything extensible. It simply means that your core business logic should be closed to modification but open to extension. The real skill is knowing when to apply it and when you’re just over-engineering your code. ...

TL;DR: SRP means each class or module should have only one reason to change. Split validation, data access, and business logic into separate classes. SRP improves maintainability, testability, and scalability. Use C# 12 features like primary constructors and records for clean separation. Avoid “God” classes and mixing unrelated responsibilities. SRP is the foundation for applying other SOLID principles. Refactor large classes by extracting focused components and using dependency injection. The Single Responsibility Principle gets misunderstood more than any other SOLID principle. It’s not about doing one thing, it’s about having one reason to change. When your class changes for multiple business reasons, you’ve violated SRP and created a maintenance nightmare. ...

Discover why structs as dictionary keys can cause hidden allocations in C#. Learn how to implement IEquatable, use readonly and record structs, and write allocation-free, high-performance code for hot paths.

Discover how guard clauses in C# simplify validation and error handling. Learn to write fail-fast code, avoid nested conditionals, and keep business logic clean with modern language features and reusable helpers.

TL;DR: Efficient C# File Processing Strategies Prevent system crashes: Avoid naive parallel processing that launches thousands of concurrent file operations. Optimize throughput: Use SemaphoreSlim to control concurrency (start with 2x CPU cores) for balanced performance. Reduce memory consumption: Implement true async I/O with useAsync: true and process files line-by-line instead of loading them entirely. Minimize database overhead: Batch related records from multiple files before making database calls. Maximize system resources: For production systems, implement adaptive throttling that responds to CPU/memory conditions. Leverage modern C# features: Use IAsyncEnumerable for efficient streaming and TPL Dataflow for complex processing pipelines. Ever tried to build an import tool that needs to process thousands of CSV files at once? I have, and I learned the hard way that simply starting a thousand file operations simultaneously is a recipe for disaster. ...

Quick Reference Table Feature Abstract Class Interface When to Use Inheritance Single only Multiple allowed Abstract: shared logic; Interface: contracts Implementation Can provide Contract only Abstract: code reuse; Interface: flexibility Constructors Supported Not allowed Abstract: initialization; Interface: pure contracts State/Fields Yes No Abstract: data sharing; Interface: behavior only Performance Slightly faster Virtual dispatch Abstract: hot paths; Interface: most scenarios Testing Can be difficult Easy with mocks Abstract: integration tests; Interface: unit tests Common Pitfalls: ...

Discover how composition helps you follow the SOLID principles in C#. See practical examples for each principle, learn why composition is more flexible than inheritance, and get actionable tips for writing robust, testable, and maintainable code.

Discover why composition is often a better choice than inheritance in C#. This article explains the drawbacks of deep inheritance, demonstrates how to use composition for flexible and maintainable code, and provides practical tips for applying these principles in real-world projects. Includes code examples and guidance for testable, scalable software design.

TL;DR: ASP.NET Core cancels requests when the client disconnects or times out. Use HttpContext.RequestAborted and pass it through to services and EF Core/database calls. Proper cancellation avoids wasted CPU, memory leaks, and long-running queries. Always propagate the cancellation token from controller to database for graceful shutdown. Ever clicked the stop button while waiting for a web page to load? What actually happens on the server when you do that? ...

Ever used the params keyword in C#? If you write C# code regularly, you probably reach for it whenever you need to pass a variable number of arguments to a method. It’s super handy, letting you skip the tedious step of creating arrays first. But until now, there’s been a limitation: params only worked with arrays. This meant every call created memory allocations with potential performance costs. The good news? C# 14 is changing the game by extending params to work with modern collections like IEnumerable<T>, Span<T>, and more. ...