Writing
Let's Talk - Null Conditional Operator. No Thank you!
Use null-conditional calls only when skipping work is correct. Required logging and optional disposal expose the difference between nullable warnings and runtime behavior.
Watch and listen
Video and Audio
Every article with a video or an audio companion. Each card opens the article, and the video and audio boxes go straight to the recording.
Articles are the canonical pages. Where one has a recorded version or an audio companion, it appears here so you can browse the media directly rather than opening every chapter to find out which ones have it.
Writing
Prefer Composition Over Inheritance
Composition keeps a configuration provider's capabilities limited to what its project needs. The refactor uses self-contained settings providers, a shallow base, and restrained reuse.
Writing
High Performance Logging and Custom Objects
An application logging adapter can accept a DTO and expose its fields as structured state. ILogger.Log<TState> separates that context from the formatted message.
Writing
To LINQ or Not to LINQ
Repeated work can hide inside a short LINQ query. A customer-filtering benchmark separates string conversions, lookup choices, iteration and changed behavior.
Writing
Abstraction in Software Design, with Examples
Give callers domain operations while collections and gateways own the details: service orchestration, model mapping and translation of recognized failures into domain exceptions.
Writing
SOLID IS OLD: Dependency Inversion Needs a Good Abstraction
Dependency inversion needs domain-owned contracts that hide implementation knowledge. Follow a show query from source dependencies through models to a stored procedure.
Writing
Abstraction in Software Design
Useful abstractions express the caller's needs precisely. Broker, database and charting examples show where SDK types, storage details and excess generality get in the way.
Writing
Always Use the "as" Operator? No Thank You!
Use a cast instead of `as` when the type is expected, so a mismatch raises InvalidCastException. Use `is` when the type genuinely varies and keep only guards backed by a real case.
Writing
Validating Formal Arguments? No Thank You!
Validate and clean data at the front and back doors; skip checks on internal formal arguments. Immutable DTOs preserve trust, one exception reports all errors, and black box tests exercise the doors.
Writing
Creating Instances, Using Inheritance: No Thank You!
Create instances for state or polymorphism and use inheritance for a common consumer. Static behavior and composition can keep testing from dictating every class's shape.
Writing
Separate State from Behavior? Yes Please!
Business operations are easier to trace when immutable DTOs carry facts and stateless managers validate inputs and coordinate work through named methods at the call site.
Writing
So You Think You Know C#? ValueTuples and Deconstruction
Named ValueTuples make small results readable. Positional fields, copy behavior and Deconstruct methods explain the syntax and the limits of tuple return types.
Writing
Builder Pattern and C# Expressions
Test-data builders keep each scenario's chosen values visible. C# expression trees select model properties, and stored overrides preserve explicit nulls.
Writing
Adapter Design Pattern: Testing Service Bus Using RabbitMQ Locally
The Adapter pattern keeps application messaging independent of broker SDKs by translating messages, callbacks and acknowledgements between RabbitMQ and Service Bus.
Writing
Design Nugget: Evolution To Strategy
Build a working baseline, then change the design for a concrete benefit; a log parser evolves through a switch, delegates, and Strategy to test that judgment.
Writing
Custom Data Structure: A One-to-Many Mapping
A one-to-many map must enforce unique values and return a key from a value. Shared tests and four implementations show how correctness shapes a benchmark.
Writing
So You Think You Know C#? LINQ
LINQ rewrites can add work while removing repetition. Customer filters expose query projections, lookup choices and why benchmarks must compare equal results.
Writing
ASP.NET Core Web API by Hand
A terminal request delegate exposes the work behind an ASP.NET Core endpoint. A movie-service experiment compares a narrow handler with the controller pipeline.
Writing
So You Think You Know C#? The StringBuilder Myth
StringBuilder suits growing results, but can cost more for fixed concatenation. Compiler output, allocations and benchmark checks explain when to choose it.
Writing
So You Think You Know C#? Generics Under the Hood
.NET generics retain runtime type arguments. Typed lists avoid boxing value-type elements, while CLR specialization and code sharing preserve distinct types.
Writing
So You Think You Know C#? Constants and Default Parameter Values
C# embeds constants and default parameter values in compiled callers. Library-only builds and IL inspection explain why callers must be rebuilt to adopt changed values.
Writing
So You Think You Know C#? Constructors
C# construction order determines which fields are ready. Field initializers, constructor chaining, virtual dispatch and static initialization explain what runs when.
Writing
So You Think You Know C#? For vs. Foreach
The type a foreach loop sees determines its enumeration path. Array lowering, list enumerators and yield state machines explain the work behind the syntax.
Writing
So You Think You Know C#? Delegates and Higher Order Functions
Delegates let callers supply behavior to reusable methods. Lambda syntax and SingleElseException show how higher order functions add useful failure details.
Writing
So You Think You Know C#? Static Classes
Choose static classes when instances serve no purpose. Shared type state, autonomous methods and immutable inputs explain the discipline that makes them useful.
Writing
So You Think You Know C#? The Fundamentals
C# passes arguments by value by default. Integer, string and object examples explain what gets copied, how ref works and which changes reach the caller.
Writing
C# 8 - Async Streams
Async streams let callers process database rows before the full result exists. An async iterator combines await and yield return, keeping its reader open during enumeration.
Writing
Benchmarking .NET Applications
A benchmark tests whether a change improves the same operation. BenchmarkDotNet makes input choice, setup, timing and allocation costs visible for .NET code.
Writing
Programming to Exceptions, Part 2: Diagnostics and Boundaries
Specific exceptions preserve failure meaning, causes, and context. A shallow C# hierarchy, Gateway translation, and middleware enrichment carry diagnostic records across service boundaries.
Writing
Programming to Exceptions, Part 3: Logging and Progress
Structured logs preserve the facts needed to investigate failures. Application Insights custom dimensions make them searchable, while typed progress events track long-running work.
Writing
Programming to Exceptions, Part 1: Method Contracts and Failure
Method contracts let callers rely on completed work and let failures propagate. C# examples distinguish retrieval from search, validate domain entry points, and assign handling to its owner.
Writing
Mocking? No Thank You!
Test whole features through the public surface so regression tests survive later design changes. Class mocks bind tests to internals; transport doubles cover rare external failures.
Writing
Dependency Injection? No Thank You!
Dependency injection exposes private collaborators to callers when used for every internal relationship. Keep classes self-contained and let business code choose real variation.
Writing
Interfaces? No Thank You!
C# interfaces do not inherently create contracts or loose coupling. Composition handles hierarchy conflicts; capability interfaces and structural typing let consumers see only what they need.
Writing
Extension Methods? No Thank You!
Keep project-specific helpers as static methods: extension methods hide behavior behind namespaces and can change meaning with imports. Use them when they serve the wider C# community.
Writing
Factory Pattern: The Enabler of Polymorphism
A Factory selects and constructs a concrete descendant while callers program to an interface through the base class's public contract. C# thumbnailers show selection and polymorphic dispatch.
Writing
.NET Memory Allocations and Performance, Part 2
CPU caches reward useful data kept close together. Pipelines, branch prediction and cache lines explain why memory access patterns matter to .NET performance.
Writing
The Configuration Provider: Roles and Responsibilities
A Configuration Provider hides the source and returns validated, typed settings. Useful exceptions and composed settings providers keep configuration rules in one place.
Writing
The Gateway Design Pattern: Roles and Responsibilities
A Gateway presents business operations, translates service models and transforms failures into domain exceptions, keeping external service details behind one boundary.
Writing
.NET Memory Allocations and Performance
.NET allocation costs follow what gets stored and copied. Structs, classes, arrays and strings explain object layout, references and garbage collection.
Writing
Factory Method Pattern: The Most Beautiful Pattern We Lost
Factory Method lets consumer subclasses choose dependencies through an overridable creation hook. C# examples show its two class families and distinguish it from a separate Factory.
Writing
Async-Await in C#
Asynchronous I/O frees server threads during waits and can improve capacity under load. IIS request flow, Task.WhenAll, and load tests show where the benefit ends.
Nothing matches that filter.