Blog posts
Refactoring C# Code with the Chain of Responsibility Design Pattern
What is the Chain of Responsibility Design Pattern, and how can I apply it in C#. Read →Discover an Easy Trick to Simplify Your C# Test Assertions!
Crafting Elegant Test Assertions with Domain-Specific Concepts and Fluent Assertions Read →DTOs - The Good, The Bad, and The Tradeoff
Using Data Transfer Objects (DTOs) is not all good or bad. Above all, it's a tradeoff. Read →Moving from Controllers to .NET Minimal APIs
If you are wondering how to move your .NET MVC API Controllers to Minimal APIs, this blog post is for you. Read →.NET Integration Testing with Docker Compose
Testcontainers is an awesome technology, but often docker-compose is just better. Read →My Simple Testing Stack (for .NET developers) [2023]
This is the list of tools that I used on my Test projects during 2022. But also the ones I'm planning to give a chance. Read →Why I Don't Use Loops on My Tests
I don't iterate on tests. You also don't need. Read →3 TDD Techniques Most People Don’t Know
There are 3 techniques to get you from Red to Green on Test Driven Development (TDD). In this article, I apply all of them to the same problem, so you can see how to use them. Read →Why I Always Avoid InternalsVisibleTo in .NET, Unless...
I don't fall in love with InternalsVisibleTo, especially in the context of facilitating Testing. But I admit that there's at least one extremely useful use case. Read →3 Types of Unit Tests (for C# Developers)
Tests can be of one of these types. Knowing them shapes how to approach testing and how you decide on your assertions. In this video, we will use C# to find those 3 types of Unit Tests. Read →3 Fluent Assertions Features You Should be Using
Fluent Assertions is a must-have tool for .NET Testing. It's so rich and extensive that some features aren't used enough. In this post, I will show you 3 of them. Read →How to Organize your .NET Dependency Injection Configuration
How many times you need to scroll to go through your Dependency Injection configuration? Too many? Do you configure your Dependency Injection on the Startup.cs? Or in the Program.cs? In this post we will see a proven organization method for maintainable Dependency Injection configuration. Read →How Structure Sensitive Tests Make Refactoring's Fail
This is one of the most common mistakes, that cause breaking tests on refactoring. In this post, we will see how to build structure-insensitive tests, one of the key properties of a good test. Read →The Biggest Folder Structure Mistake on .NET
This is the most common mistake when organizing Projects and Solutions in .NET. It is a real onboarding nightmare for newcomers. In this post, I will show you how to use Feature Folders towards a Screaming Architecture (Clean Architecture). Read →I Built the Netflix Intro on a .NET Console, and this is how I've done it
Would it be possible to build the Netflix Intro for a .NET Console application? This is the challenge, and I will show you how I made it. Read →DateTimeOffset vs DateTime - What's the difference?
Do you know that even Microsoft doesn't recommend using DateTime by default? They recommend using DateTimeOffset instead. Let's see why. Read →How the DRY Principle can damage your tests (C# Developers)
How the DRY principle can damage the readability of your C# tests, and what you can do instead. Read →The missing Project that fixes everything in .NET
Most Clean Architecture implementations have this error. The error of missing the Main Component, or Composition Root. Here we will see how to implement it in a .NET Solution. Read →How to apply Hexagonal Architecture with .NET
A guide on how to apply Hexagonal Architecture (also known as Ports & Adapters) as a .NET Developer. By the end, you should be able to follow the same ideas and build upon this opinionated project structure. Read →Hexagonal Architecture for .NET Developers (Beginners)
A beginner's introduction to Hexagonal Architecture (AKA Ports & Adapters), where it explained the .NET concepts that you can use to bring Hexagonal Architecture to life. Read →5 things Microsoft needs to do to make Central Package Management widely used
Microsoft can change the way we manage packages in .NET forever. With a bit of effort, Central Package Management can be the default way of doing it in .NET. Read →C# 11 Required Members, the imperfectly awesome feature
Finally, Required Members are landing on C#. It's a highly expected feature, but not everything is perfect. In this post we will see why. Read →C# 11 Auto Default Structs in depth
Why C# 11 is bring Auto Default Structs and how it will work. Read →Finding .NET Transitive Dependencies and Tidying Up Your Project
In this post will will look into Snitch, an Open Source tool to find transitive dependencies that can be removed from .NET projects. Read →C# 11 UTF-8 String Literals - Ignore everything you have seen so far
UTF-8 String Literals is coming to C# but has changed during C# 11 Preview. In this blog post, I will show what UTF-8 String Literals are trying to solve, what is changing and why it's changing. Read →C# 11 Generic Attributes More Than Syntax Sugar
Generic Attributes were missing for a long time in C#. Since they are arriving, let's see what that means. Read →A Gentle Introduction to C# 11 List Patterns
What are List Patterns, and how can you use them. Read →The Complete Guide to C# 11 Raw String Literals
Wouldn't be lovely if we could copy text into and from a string without thinking about escaping? Read →The Blind Spot of C# Records Immutability
The excitement with Records immutability, has some blind spots. It's easy to fall into a trap and break the desired immutability. Nevertheless, there's a simple rule that can bring a light on potential problems. Read →Quick Wins for .NET build pipelines
Small tips to optimize your .NET build pipelines with .NET CLI. Read →