DEV Community: Serhii Korol

Design Patterns #12: Let the Visitor In — A Deep Dive into the Visitor Pattern.

Serhii Korol — Fri, 31 Oct 2025 14:06:41 +0000

Hello, everyone. Today, I want to discuss a pattern you might have encountered, even though it's not very common. This pattern is rarely used, but let's take a closer look at it. We'll explore when it should be applied and examine its advantages and disadvantages.

What's the Visitor pattern?

The main point of this pattern is that it allows you to separate an algorithm from the object structure. In other words, if you have a complex class hierarchy and want to perform different operations without modifying these classes, the Visitor pattern is ideal.

For example, consider having employees of two types: full-time and contractors. You may want to calculate taxes for each group, generate reports, or compute bonuses. Instead of adding new methods to every employee class, you can use the Visitor pattern to implement these operations externally.

Scenario

Let's consider a real-world scenario: we want to display a file tree and show the size of each file. There are two concrete types of items: files and folders, both of which are considered file elements. Additionally, we want to generate a file report. For this example, let's look at the bin executable folder.

Ordinary approach

How would you complete this task? You would first create a base type for the hierarchy, which should be an abstract class. This class represents the general structure of a file, regardless of whether it is a file or a folder. Each type should have a Name property, a method to get the Size, and a Report method.

public abstract class FileSystemElement(string name)
{
    protected string Name { get; } = string.IsNullOrEmpty(name) ? "root" : name;

    public abstract long GetSize();
    public abstract void PrintReport(int depth = 0);
}

Next, we should implement the folder type. Starting from the root folder, we retrieve the sizes of its child files and print the folder's name. The GetSize() method calculates the total size of the root folder, while the PrintReport() method displays the folder name and manages spacing to reflect the tree hierarchy.

public class DirectoryElement(string name) : FileSystemElement(name)
{
    private List<FileSystemElement> Children { get; } = [];

    public void Add(FileSystemElement element)
    {
        Children.Add(element);
    }

    public override long GetSize()
    {
        long total = 0;
        foreach (var child in Children)
            total += child.GetSize();
        return total;
    }

    public override void PrintReport(int depth = 0)
    {
        Console.WriteLine($"{new string(' ', depth * 2)}📁 {Name}");
        foreach (var child in Children)
            child.PrintReport(depth + 1);
    }
}

Currently, we display only folders. We need to add the file type. Here, we also set the file size and display all relevant information.

public class FileElement(string name, long size) : FileSystemElement(name)
{
    private long Size { get; } = size;

    public override long GetSize() => Size;

    public override void PrintReport(int depth = 0)
    {
        Console.WriteLine($"{new string(' ', depth * 2)}📄 {Name} ({Size / 1024.0:F2} KB)");
    }
}

How do we use it? First, we obtain the target path, then build the tree hierarchy, print the entire tree, and display the total size.

    public void OrdinaryApproach()
    {
        string targetPath = Path.Combine(AppContext.BaseDirectory);
        Console.WriteLine($"Building file tree from: {targetPath}\n");

        var root = BuildDirectoryTreeForOrdinary(targetPath);

        Console.WriteLine("=== File tree ===");
        root.PrintReport();

        Console.WriteLine($"\nTotal size: {root.GetSize() / 1024.0:F2} KB");
    }

    private static Ordinary.DirectoryElement BuildDirectoryTreeForOrdinary(string path)
    {
        var directory = new Ordinary.DirectoryElement(Path.GetFileName(path));

        foreach (var file in Directory.GetFiles(path))
        {
            var fileInfo = new FileInfo(file);
            directory.Add(new Ordinary.FileElement(fileInfo.Name, fileInfo.Length));
        }

        foreach (var dir in Directory.GetDirectories(path))
        {
            directory.Add(BuildDirectoryTreeForOrdinary(dir));
        }

        return directory;
    }

After launching, you should see a result that looks something like this:

=== File tree ===
📁 root
  📄 Gee.External.Capstone.dll (282,50 KB)
  📄 Microsoft.DotNet.PlatformAbstractions.dll (22,88 KB)
  📄 System.Management.dll (69,38 KB)
  📄 VisitorPattern.runtimeconfig.json (0,32 KB)
  📄 Microsoft.Extensions.Logging.dll (30,99 KB)
  📄 BenchmarkDotNet.dll (1175,50 KB)
  📄 JetBrains.FormatRipper.dll (85,00 KB)
  📄 Microsoft.Extensions.Logging.Abstractions.dll (46,52 KB)
  📄 BenchmarkDotNet.Annotations.dll (28,00 KB)
  📄 Microsoft.Diagnostics.FastSerialization.dll (73,43 KB)
  📄 Microsoft.CodeAnalysis.CSharp.dll (5794,62 KB)
  📄 JetBrains.Profiler.Api.dll (18,00 KB)
  📄 JetBrains.HabitatDetector.dll (59,50 KB)
  📄 Iced.dll (1824,00 KB)
  📄 Microsoft.Extensions.Configuration.dll (24,99 KB)
  📄 Perfolizer.dll (193,50 KB)
  📄 JetBrains.Profiler.SelfApi.dll (55,50 KB)
  📄 VisitorPattern.deps.json (24,26 KB)
  📄 VisitorPattern (106,16 KB)
  📄 Microsoft.Extensions.Primitives.dll (34,99 KB)
  📄 Microsoft.Diagnostics.NETCore.Client.dll (126,87 KB)
  📄 TraceReloggerLib.dll (22,67 KB)
  📄 Microsoft.Diagnostics.Runtime.dll (531,89 KB)
  📄 Microsoft.Extensions.Configuration.Abstractions.dll (19,99 KB)
  📄 Microsoft.Extensions.Options.dll (39,49 KB)
  📄 VisitorPattern.pdb (15,33 KB)
  📄 Microsoft.Extensions.Configuration.Binder.dll (24,49 KB)
  📄 Microsoft.CodeAnalysis.dll (2620,62 KB)
  📄 BenchmarkDotNet.Diagnostics.dotTrace.dll (19,50 KB)
  📄 Settings.pdb (13,14 KB)
  📄 Microsoft.Extensions.DependencyInjection.Abstractions.dll (35,99 KB)
  📄 VisitorPattern.dll (9,50 KB)
  📄 Microsoft.Diagnostics.Tracing.TraceEvent.dll (3088,44 KB)
  📄 System.CodeDom.dll (178,88 KB)
  📄 Settings.dll (4,50 KB)
  📄 CommandLine.dll (220,00 KB)
  📄 Microsoft.Bcl.AsyncInterfaces.dll (14,57 KB)
  📄 Dia2Lib.dll (57,64 KB)
  📁 zh-Hans
    📄 Microsoft.CodeAnalysis.resources.dll (40,11 KB)
    📄 Microsoft.CodeAnalysis.CSharp.resources.dll (327,15 KB)
  📁 zh-Hant
    📄 Microsoft.CodeAnalysis.resources.dll (41,12 KB)
    📄 Microsoft.CodeAnalysis.CSharp.resources.dll (327,15 KB)
  📁 pl
    📄 Microsoft.CodeAnalysis.resources.dll (45,62 KB)
    📄 Microsoft.CodeAnalysis.CSharp.resources.dll (387,65 KB)
  📁 ja
    📄 Microsoft.CodeAnalysis.resources.dll (48,65 KB)
    📄 Microsoft.CodeAnalysis.CSharp.resources.dll (420,12 KB)
  📁 it
    📄 Microsoft.CodeAnalysis.resources.dll (45,62 KB)
    📄 Microsoft.CodeAnalysis.CSharp.resources.dll (381,65 KB)
  📁 cs
    📄 Microsoft.CodeAnalysis.resources.dll (43,62 KB)
    📄 Microsoft.CodeAnalysis.CSharp.resources.dll (360,62 KB)
  📁 amd64
    📄 msdia140.dll (1756,43 KB)
    📄 KernelTraceControl.dll (260,45 KB)
  📁 runtimes
    📁 osx-x64
      📁 native
        📄 libcapstone.dylib (4576,90 KB)
    📁 linux-arm
      📁 native
        📄 libcapstone.so (4956,35 KB)
    📁 linux-arm64
      📁 native
        📄 libcapstone.so (7129,93 KB)
    📁 win
      📁 lib
        📁 netcoreapp2.0
          📄 System.Management.dll (287,88 KB)
    📁 linux-x86
      📁 native
        📄 libcapstone.so (5081,67 KB)
    📁 win-x86
      📁 native
        📄 capstone.dll (4714,00 KB)
    📁 osx-arm64
      📁 native
        📄 libcapstone.dylib (4533,16 KB)
    📁 win-x64
      📁 native
        📄 capstone.dll (5465,50 KB)
    📁 linux-x64
      📁 native
        📄 libcapstone.so (6713,03 KB)
    📁 win-arm64
      📁 native
        📄 capstone.dll (5028,00 KB)
  📁 ru
    📄 Microsoft.CodeAnalysis.resources.dll (54,62 KB)
    📄 Microsoft.CodeAnalysis.CSharp.resources.dll (507,65 KB)
  📁 x86
    📄 msdia140.dll (1467,92 KB)
    📄 KernelTraceControl.dll (181,45 KB)
    📄 KernelTraceControl.Win61.dll (156,20 KB)
  📁 pt-BR
    📄 Microsoft.CodeAnalysis.resources.dll (44,65 KB)
    📄 Microsoft.CodeAnalysis.CSharp.resources.dll (369,65 KB)
  📁 de
    📄 Microsoft.CodeAnalysis.resources.dll (45,62 KB)
    📄 Microsoft.CodeAnalysis.CSharp.resources.dll (384,15 KB)
  📁 ko
    📄 Microsoft.CodeAnalysis.resources.dll (45,62 KB)
    📄 Microsoft.CodeAnalysis.CSharp.resources.dll (387,12 KB)
  📁 fr
    📄 Microsoft.CodeAnalysis.resources.dll (45,62 KB)
    📄 Microsoft.CodeAnalysis.CSharp.resources.dll (384,15 KB)
  📁 es
    📄 Microsoft.CodeAnalysis.resources.dll (45,12 KB)
    📄 Microsoft.CodeAnalysis.CSharp.resources.dll (375,65 KB)
  📁 arm64
    📄 msdia140.dll (3412,89 KB)
    📄 KernelTraceControl.dll (252,45 KB)
  📁 tr
    📄 Microsoft.CodeAnalysis.resources.dll (44,12 KB)
    📄 Microsoft.CodeAnalysis.CSharp.resources.dll (366,65 KB)
  📁 BenchmarkDotNet.Artifacts
    📄 VisitorPattern.Program-20251029-141418.log (14350,01 KB)
    📄 VisitorPattern.Program-20251029-154029.log (10672,75 KB)
    📄 VisitorPattern.Program-20251029-140100.log (14349,62 KB)
    📄 VisitorPattern.Program-20251029-141341.log (14349,80 KB)
    📄 VisitorPattern.Program-20251029-140513.log (14349,81 KB)
    📄 VisitorPattern.Program-20251029-141256.log (21517,92 KB)
    📄 VisitorPattern.Program-20251029-153910.log (10672,97 KB)
    📄 VisitorPattern.Program-20251029-153953.log (10672,72 KB)
    📄 VisitorPattern.Program-20251029-141211.log (10765,70 KB)
    📁 results
      📄 VisitorPattern.Program-report.html (1,18 KB)

Total size: 200239,73 KB

It's a very simple implementation, but there's a significant problem: it's difficult to scale. If you want to add new actions, you have to modify each class. Imagine having many more types or needing to handle each extension type individually—it would be a nightmare to add new actions in such a setup.

Visitor approach

Here is a completely different approach. However, you should also include the base type, which is associated with the Visitor. This type only has a Name and does not contain any actions.

public interface IFileSystemElement
{
    string Name { get; }
    void Accept(IFileSystemVisitor visitor);
}

Only the Visitor knows the concrete types. It includes all types, but not their corresponding actions. Instead, it simply associates types with individual concrete visitors.

public interface IFileSystemVisitor
{
    void Visit(FileElement file);
    void Visit(DirectoryElement directory);
}

As you can see, the types themselves no longer perform any calculations; instead, they delegate this responsibility to the concrete visitors. Additionally, you may notice that DirectoryElement no longer calculates Size, unlike in the traditional approach.

public class DirectoryElement(string name) : IFileSystemElement
{
    public string Name { get; } = string.IsNullOrEmpty(name) ? "root" : name;
    public List<IFileSystemElement> Children { get; } = [];

    public void Add(IFileSystemElement element)
    {
        Children.Add(element);
    }

    public void Accept(IFileSystemVisitor visitor)
    {
        visitor.Visit(this);
    }
}

public class FileElement(string name, long size) : IFileSystemElement
{
    public string Name { get; } = name;
    public long Size { get; } = size;

    public void Accept(IFileSystemVisitor visitor)
    {
        visitor.Visit(this);
    }
}

Now, let's add a visitor that will handle size calculation.

public class SizeCalculatorVisitor : IFileSystemVisitor
{
    public long TotalSize { get; private set; }

    public void Visit(FileElement file)
    {
        TotalSize += file.Size;
    }

    public void Visit(DirectoryElement directory)
    {
        foreach (var child in directory.Children)
        {
            child.Accept(this);
        }
    }
}

The visitor focuses primarily on reporting. Unlike the traditional method, where each type managed its own reports, the visitor handles reports for both types.

public class ReportVisitor : IFileSystemVisitor
{
    private int _depth = 0;

    public void Visit(FileElement file)
    {
        Console.WriteLine($"{new string(' ', _depth * 2)}📄 {file.Name} ({file.Size / 1024.0:F2} KB)");
    }

    public void Visit(DirectoryElement directory)
    {
        Console.WriteLine($"{new string(' ', _depth * 2)}📁 {directory.Name}");
        _depth++;
        foreach (var child in directory.Children)
        {
            child.Accept(this);
        }

        _depth--;
    }
}

How can you use it? This approach is slightly different. First, obtain the target path and build the tree hierarchy as before. Then, create the report visitor and apply it to the folder type. Next, create and use the size visitor in a similar way. Finally, display the total size.

public void VisitorApproach()
    {
        string targetPath = Path.Combine(AppContext.BaseDirectory);
        Console.WriteLine($"Building file tree from: {targetPath}\n");

        var root = BuildDirectoryTreeForVisitor(targetPath);

        var reportVisitor = new Visitor.ReportVisitor();
        Console.WriteLine("=== File tree ===");
        root.Accept(reportVisitor);

        var sizeVisitor = new Visitor.SizeCalculatorVisitor();
        root.Accept(sizeVisitor);
        Console.WriteLine($"\nTotal size: {sizeVisitor.TotalSize / 1024.0:F2} KB");
    }

    private static Visitor.DirectoryElement BuildDirectoryTreeForVisitor(string path)
    {
        var directory = new Visitor.DirectoryElement(Path.GetFileName(path));

        foreach (var file in Directory.GetFiles(path))
        {
            var info = new FileInfo(file);
            directory.Add(new Visitor.FileElement(info.Name, info.Length));
        }

        foreach (var dir in Directory.GetDirectories(path))
        {
            directory.Add(BuildDirectoryTreeForVisitor(dir));
        }

        return directory;
    }

The result should be identical.

=== File tree ===
📁 root
  📄 Gee.External.Capstone.dll (282,50 KB)
  📄 Microsoft.DotNet.PlatformAbstractions.dll (22,88 KB)
  📄 System.Management.dll (69,38 KB)
  📄 VisitorPattern.runtimeconfig.json (0,32 KB)
  📄 Microsoft.Extensions.Logging.dll (30,99 KB)
  📄 BenchmarkDotNet.dll (1175,50 KB)
  📄 JetBrains.FormatRipper.dll (85,00 KB)
  📄 Microsoft.Extensions.Logging.Abstractions.dll (46,52 KB)
  📄 BenchmarkDotNet.Annotations.dll (28,00 KB)
  📄 Microsoft.Diagnostics.FastSerialization.dll (73,43 KB)
  📄 Microsoft.CodeAnalysis.CSharp.dll (5794,62 KB)
  📄 JetBrains.Profiler.Api.dll (18,00 KB)
  📄 JetBrains.HabitatDetector.dll (59,50 KB)
  📄 Iced.dll (1824,00 KB)
  📄 Microsoft.Extensions.Configuration.dll (24,99 KB)
  📄 Perfolizer.dll (193,50 KB)
  📄 JetBrains.Profiler.SelfApi.dll (55,50 KB)
  📄 VisitorPattern.deps.json (24,26 KB)
  📄 VisitorPattern (106,16 KB)
  📄 Microsoft.Extensions.Primitives.dll (34,99 KB)
  📄 Microsoft.Diagnostics.NETCore.Client.dll (126,87 KB)
  📄 TraceReloggerLib.dll (22,67 KB)
  📄 Microsoft.Diagnostics.Runtime.dll (531,89 KB)
  📄 Microsoft.Extensions.Configuration.Abstractions.dll (19,99 KB)
  📄 Microsoft.Extensions.Options.dll (39,49 KB)
  📄 VisitorPattern.pdb (15,33 KB)
  📄 Microsoft.Extensions.Configuration.Binder.dll (24,49 KB)
  📄 Microsoft.CodeAnalysis.dll (2620,62 KB)
  📄 BenchmarkDotNet.Diagnostics.dotTrace.dll (19,50 KB)
  📄 Settings.pdb (13,14 KB)
  📄 Microsoft.Extensions.DependencyInjection.Abstractions.dll (35,99 KB)
  📄 VisitorPattern.dll (9,50 KB)
  📄 Microsoft.Diagnostics.Tracing.TraceEvent.dll (3088,44 KB)
  📄 System.CodeDom.dll (178,88 KB)
  📄 Settings.dll (4,50 KB)
  📄 CommandLine.dll (220,00 KB)
  📄 Microsoft.Bcl.AsyncInterfaces.dll (14,57 KB)
  📄 Dia2Lib.dll (57,64 KB)
  📁 zh-Hans
    📄 Microsoft.CodeAnalysis.resources.dll (40,11 KB)
    📄 Microsoft.CodeAnalysis.CSharp.resources.dll (327,15 KB)
  📁 zh-Hant
    📄 Microsoft.CodeAnalysis.resources.dll (41,12 KB)
    📄 Microsoft.CodeAnalysis.CSharp.resources.dll (327,15 KB)
  📁 pl
    📄 Microsoft.CodeAnalysis.resources.dll (45,62 KB)
    📄 Microsoft.CodeAnalysis.CSharp.resources.dll (387,65 KB)
  📁 ja
    📄 Microsoft.CodeAnalysis.resources.dll (48,65 KB)
    📄 Microsoft.CodeAnalysis.CSharp.resources.dll (420,12 KB)
  📁 it
    📄 Microsoft.CodeAnalysis.resources.dll (45,62 KB)
    📄 Microsoft.CodeAnalysis.CSharp.resources.dll (381,65 KB)
  📁 cs
    📄 Microsoft.CodeAnalysis.resources.dll (43,62 KB)
    📄 Microsoft.CodeAnalysis.CSharp.resources.dll (360,62 KB)
  📁 amd64
    📄 msdia140.dll (1756,43 KB)
    📄 KernelTraceControl.dll (260,45 KB)
  📁 runtimes
    📁 osx-x64
      📁 native
        📄 libcapstone.dylib (4576,90 KB)
    📁 linux-arm
      📁 native
        📄 libcapstone.so (4956,35 KB)
    📁 linux-arm64
      📁 native
        📄 libcapstone.so (7129,93 KB)
    📁 win
      📁 lib
        📁 netcoreapp2.0
          📄 System.Management.dll (287,88 KB)
    📁 linux-x86
      📁 native
        📄 libcapstone.so (5081,67 KB)
    📁 win-x86
      📁 native
        📄 capstone.dll (4714,00 KB)
    📁 osx-arm64
      📁 native
        📄 libcapstone.dylib (4533,16 KB)
    📁 win-x64
      📁 native
        📄 capstone.dll (5465,50 KB)
    📁 linux-x64
      📁 native
        📄 libcapstone.so (6713,03 KB)
    📁 win-arm64
      📁 native
        📄 capstone.dll (5028,00 KB)
  📁 ru
    📄 Microsoft.CodeAnalysis.resources.dll (54,62 KB)
    📄 Microsoft.CodeAnalysis.CSharp.resources.dll (507,65 KB)
  📁 x86
    📄 msdia140.dll (1467,92 KB)
    📄 KernelTraceControl.dll (181,45 KB)
    📄 KernelTraceControl.Win61.dll (156,20 KB)
  📁 pt-BR
    📄 Microsoft.CodeAnalysis.resources.dll (44,65 KB)
    📄 Microsoft.CodeAnalysis.CSharp.resources.dll (369,65 KB)
  📁 de
    📄 Microsoft.CodeAnalysis.resources.dll (45,62 KB)
    📄 Microsoft.CodeAnalysis.CSharp.resources.dll (384,15 KB)
  📁 ko
    📄 Microsoft.CodeAnalysis.resources.dll (45,62 KB)
    📄 Microsoft.CodeAnalysis.CSharp.resources.dll (387,12 KB)
  📁 fr
    📄 Microsoft.CodeAnalysis.resources.dll (45,62 KB)
    📄 Microsoft.CodeAnalysis.CSharp.resources.dll (384,15 KB)
  📁 es
    📄 Microsoft.CodeAnalysis.resources.dll (45,12 KB)
    📄 Microsoft.CodeAnalysis.CSharp.resources.dll (375,65 KB)
  📁 arm64
    📄 msdia140.dll (3412,89 KB)
    📄 KernelTraceControl.dll (252,45 KB)
  📁 tr
    📄 Microsoft.CodeAnalysis.resources.dll (44,12 KB)
    📄 Microsoft.CodeAnalysis.CSharp.resources.dll (366,65 KB)
  📁 BenchmarkDotNet.Artifacts
    📄 VisitorPattern.Program-20251029-141418.log (14350,01 KB)
    📄 VisitorPattern.Program-20251029-154029.log (10672,75 KB)
    📄 VisitorPattern.Program-20251029-140100.log (14349,62 KB)
    📄 VisitorPattern.Program-20251029-141341.log (14349,80 KB)
    📄 VisitorPattern.Program-20251029-140513.log (14349,81 KB)
    📄 VisitorPattern.Program-20251029-141256.log (21517,92 KB)
    📄 VisitorPattern.Program-20251029-153910.log (10672,97 KB)
    📄 VisitorPattern.Program-20251029-153953.log (10672,72 KB)
    📄 VisitorPattern.Program-20251029-141211.log (10765,70 KB)
    📁 results
      📄 VisitorPattern.Program-report.html (1,18 KB)

Total size: 200239,73 KB

As you can see, the types do not contain any actions. If you want to add another action, you don't need to change the types; you only need to create a new visitor.

Benchmark

How can this affect performance? Let's find out together.

As expected, the visitor approach is somewhat slower because of the additional classes involved.

Extension

Now, imagine you need to make some changes and add a new action. Let's implement item counting for each folder. In a non-Visitor scenario, you'd modify the DirectoryElement class by adding a new method and updating the PrintReport method. This example might seem straightforward, but I want to highlight the core idea.

    public override void PrintReport(int depth = 0)
    {
        Console.WriteLine($"{new string(' ', depth * 2)}📁 {Name} ({CountElementsInCurrentDirectory()} items)");
        foreach (var child in Children)
            child.PrintReport(depth + 1);
    }

    private int CountElementsInCurrentDirectory() => Children.Count;

In the Visitor pattern, you do not modify DirectoryElement. Instead, you create a new visitor class and implement the required functionality there.

public class CountingVisitor : IFileSystemVisitor
{
    private int TotalFiles { get; set; }
    private int TotalDirectories { get; set; }

    public void Visit(FileElement file)
    {
        TotalFiles++;
    }

    public void Visit(DirectoryElement directory)
    {
        TotalDirectories++;

        foreach (var child in directory.Children)
            child.Accept(this);
    }
}

And also need to add showing in the report.

Console.WriteLine($"{new string(' ', _depth * 2)}📁 {directory.Name} ({directory.Children.Count} items)");

And don't forget to call the visitor.

var count = new Visitor.CountingVisitor();
root.Accept(count);

Conclusion

The Visitor pattern is a great approach for working with trees or hierarchical structures. It enables you to separate objects from the actions performed on them. Each visitor follows the single responsibility principle.

Pros

Easily add a new behavior
Flexibility
Good in trees, file systems

Cons

Performance
Complicated
Hard add a new type

Where can you use it? It is an excellent choice if you work with tree hierarchies or file systems, especially when you frequently add or modify behavior.

If you found this article helpful, I would appreciate your support.

This article's example, along with others, highlights the design patterns featured in my repository.

SergKorol / DesignPatterns

Design Patterns #11: Controlled Extensibility in C#

Serhii Korol — Wed, 08 Oct 2025 10:01:23 +0000

Hello. Today, I want to discuss a topic you're probably familiar with but might not consider very important: the Template Method pattern. We'll explore how it functions, when to apply it, and what problems it can solve.

Beginners often make this mistake by ignoring this pattern, which can impact readability, extendability, and performance. Let's examine a common scenario where it can be applied.

Scenario

Imagine you run an e-shop with various payment methods — the simplest way is to add a payment service for each method.

public class PayPalService
{
    public async Task ProcessPaymentAsync(decimal amount)
    {
        await ValidatePaymentAsync();
        await AuthorizePaymentAsync(amount);
        await ExecutePaymentAsync(amount);
        await SendReceiptAsync();
        await Task.CompletedTask;
    }

    private Task ValidatePaymentAsync()
    {
        Console.WriteLine("✅ Checking PayPal-account...");
        return Task.CompletedTask;
    }

    private Task AuthorizePaymentAsync(decimal amount)
    {
        Console.WriteLine($"🔐 Authorizing PayPal to {amount:C}...");
        return Task.CompletedTask;
    }

    private Task ExecutePaymentAsync(decimal amount)
    {
        Console.WriteLine($"💰 Executing PayPal payment to {amount:C}...");
        return Task.CompletedTask;
    }

    private Task SendReceiptAsync()
    {
        Console.WriteLine("📧 Sending receipt via email...");
        return Task.CompletedTask;
    }
}

public class StripeService
{
    public async Task ProcessPaymentAsync(decimal amount)
    {
        await ValidatePaymentAsync();
        await AuthorizePaymentAsync(amount);
        await ExecutePaymentAsync(amount);
        await SendReceiptAsync();
        await Task.CompletedTask;
    }

    private Task ValidatePaymentAsync()
    {
        Console.WriteLine("✅ Checking Stripe-account...");
        return Task.CompletedTask;
    }

    private Task AuthorizePaymentAsync(decimal amount)
    {
        Console.WriteLine($"🔐 Authorizing Stripe to {amount:C}...");
        return Task.CompletedTask;
    }

    private Task ExecutePaymentAsync(decimal amount)
    {
        Console.WriteLine($"💰 Executing Stripe payment to {amount:C}...");
        return Task.CompletedTask;
    }

    private Task SendReceiptAsync()
    {
        Console.WriteLine("📧 Sending receipt via email...");
        return Task.CompletedTask;
    }
}

Payment methods generally share similar functions and perform identical tasks. However, they are often separated to accommodate future extensions. This can result in redundant code, even though the code functions correctly. At first glance, this approach appears advantageous because it allows service expansion from a single location.

Template method

The Template Method pattern solves the problem of redundant code by following the DRY principle.

The Template method is an abstract class consisting of three parts:

a public or template method, which is a non-abstract method that encapsulates all protected methods in the class;
abstract methods, which are meant to be overridden by derived classes;
virtual methods or hooks, which may have a default implementation or not.

public abstract class PaymentProcessor
{
    public async Task ProcessPaymentAsync(decimal amount)
    {
        await ValidatePaymentAsync();
        await AuthorizePaymentAsync(amount);
        await ExecutePaymentAsync(amount);
        await SendReceiptAsync();
    }

    protected abstract Task ValidatePaymentAsync();
    protected abstract Task AuthorizePaymentAsync(decimal amount);
    protected abstract Task ExecutePaymentAsync(decimal amount);

    protected virtual Task SendReceiptAsync()
    {
        Console.WriteLine("📧 Sending receipt via email...");
        return Task.CompletedTask;
    }
}

Payments typically include common features like public methods and sending receipts. We can extract these methods into an abstract class to prevent code duplication.

public class PayPalPaymentProcessor : PaymentProcessor
{
    protected override Task ValidatePaymentAsync()
    {
        Console.WriteLine("✅ Checking PayPal-account...");
        return Task.CompletedTask;
    }

    protected override Task AuthorizePaymentAsync(decimal amount)
    {
        Console.WriteLine($"🔐 Authorizing PayPal to {amount:C}...");
        return Task.CompletedTask;
    }

    protected override Task ExecutePaymentAsync(decimal amount)
    {
        Console.WriteLine($"💰 Executing PayPal payment to {amount:C}...");
        return Task.CompletedTask;
    }
}

public class StripePaymentProcessor : PaymentProcessor
{
    protected override Task ValidatePaymentAsync()
    {
        Console.WriteLine("✅ Checking Stripe-account...");
        return Task.CompletedTask;
    }

    protected override Task AuthorizePaymentAsync(decimal amount)
    {
        Console.WriteLine($"🔐 Authorizing Stripe to {amount:C}...");
        return Task.CompletedTask;
    }

    protected override Task ExecutePaymentAsync(decimal amount)
    {
        Console.WriteLine($"💰 Executing Stripe payment to {amount:C}...");
        return Task.CompletedTask;
    }
}

Derived classes override abstract methods solely for their specific purpose. This approach addresses the problem of duplicated code.

However, consider a situation where you need to extend a service. In the previous approach, this can be done easily. Here's an update to the base class:

public abstract class PaymentProcessor
{
    public async Task ProcessPaymentAsync(decimal amount)
    {
        await ValidatePaymentAsync();
        await AuthorizePaymentAsync(amount);
        await ExecutePaymentAsync(amount);


        await CashbackPaymentAsync(amount);

        await SendReceiptAsync();
    }

    ...

    protected virtual Task CashbackPaymentAsync(decimal amount)
    {
        return Task.CompletedTask;
    }

    ...
}

You should add an additional hook. Because it is only required for one service, we included an empty virtual method for you to override as needed, ensuring other services remain unaffected.

public class StripePaymentProcessor : PaymentProcessor
{
    ...
    protected override Task CashbackPaymentAsync(decimal amount)
    {
        var cashback = Math.Round(amount * 0.05m, 2);
        Console.WriteLine($"🎁 Cashback is credited {cashback:C} to your Stripe-account!");
        return Task.CompletedTask;
    }
    ...
}

Behavior you can adopt in the targeted service.

Performance

What about performance? The results will impress you. Despite having one additional class and an extended service, we still deliver the best performance.

| Method                | Mean     | Error      | StdDev   |
|---------------------- |---------:|-----------:|---------:|
| TemplatePaymentMethod | 263.6 us | 1,562.5 us | 85.65 us |
| NaivePaymentMethod    | 375.4 us | 1,119.0 us | 61.34 us |

Conclusion

Don't underestimate the significance of this pattern. The Template Method pattern addresses key challenges:

Readability: Each service includes only its specific code, improving clarity.
Extendability: It offers flexibility to add or modify multiple services.
Avoiding Repetition: Supports the DRY principle by preventing duplicate code.
Performance: Ensures optimal performance.

If you found this article helpful, please consider supporting me.

This article's sample, along with others, focuses on design patterns available in my repository.

SergKorol / DesignPatterns

Meet the new IT events app.

Serhii Korol — Mon, 06 Oct 2025 10:33:00 +0000

Kommunist is an unofficial app that lets you view IT events from the WeAreCommunity portal by EPAM Systems. It allows you to see descriptions for each event. If you're interested in specific events, you can use a calendar — whether for multiple events or just one. The app also lets you save iCal files to storage and share them via email. It supports filtering events by tags, community details, authors, and countries, and users can switch to a Dark theme. Please note that this app is a Beta version and may contain bugs. If you would like to participate in testing, you can join the testers by clicking link. I would appreciate any feedback or bug reports you may find. You can also support me by clicking another link, and I'll release the app for iOS.

The app was created using .NET MAUI and has an open-source repository. However, I think you should be familiar with the license agreement.

SergKorol / Kommunist

Mobile App for WeAreCommunity. The Kommunist title didn't dedicate to Communism. It's derivative from Community.

Kommunist

The Kommunist mobile app allows you to view IT events from the WeAreCommunity portal and add them to your personal calendar on your mobile device. Additionally, you can save the calendar file to internal storage and share it with yourself or friends.

Android: Play Market

View on GitHub

Design Patterns #10: Breaking the Chain of Irresponsibility

Serhii Korol — Mon, 01 Sep 2025 13:11:23 +0000

Hi everyone! Today, I’d like to talk about a design pattern that you’ve probably heard of but might not use very often. In fact, many of us apply it without even realizing it—the Chain of Responsibility pattern.
We’ll look at the key benefits it provides, walk through a relatable real-life scenario, and implement it step by step. Afterwards, we’ll see how we can take the example further and improve upon it.
Let’s get started!

What's the Chain of Responsibility?

The core idea of this pattern is that you have several ordered handlers linked together in a chain. When the client sends a request, it first reaches the initial handler. That handler can choose to:

process the request and pass it along,
simply forward it to the next handler, or
stop the chain entirely by rejecting the request.

Each handler makes its own decision about what happens next. In essence, the Chain of Responsibility is a pipeline where the request must pass through handlers in a defined order.
A familiar example of this pattern can be found in ASP.NET projects:

var app = builder.Build();
app.UseHttpsRedirection();
app.UseRouting();
app.UseAuthorization();
app.MapStaticAssets();
app.Run();

You can’t skip a handler or change their order without breaking the expected behavior, which can easily lead to errors.

Yes, you can. Let’s look at a scenario where requests must be processed in a strict order.
Consider a common case—purchasing products in an online shop. Before the payment is made, you first need to verify product availability, then validate the customer’s payment details. Once these checks are complete, the customer proceeds with the payment.
At this stage, several outcomes are possible:

The payment may fail due to insufficient funds.
The bank may decline the transaction.
In both cases, you must return the reserved product to the warehouse.

If the payment succeeds, the next step is shipping the product. However, the customer may later cancel the order. In that situation, you’ll need to refund the payment and restock the product.
How would this process look in a straightforward, non-pattern-based implementation?
Let’s start with a simple Customer model containing an ID, Name, and Balance:

public class Customer(int id, string name, decimal balance)
{
    public int Id { get; set; } = id;
    public string Name { get; set; } = name ?? throw new ArgumentNullException(nameof(name));

    public decimal Balance { get; set; } =
        balance >= 0 ? balance : throw new ArgumentException("Balance cannot be negative", nameof(balance));
}

We also have a Product model, which includes ID, Name, Price, and Stock.

public class Product(int id, string name, decimal price, int stock)
{
    public int Id { get; set; } = id;
    public string Name { get; set; } = name ?? throw new ArgumentNullException(nameof(name));

    public decimal Price { get; set; } =
        price >= 0 ? price : throw new ArgumentException("Price cannot be negative", nameof(price));

    public int Stock { get; set; } =
        stock >= 0 ? stock : throw new ArgumentException("Stock cannot be negative", nameof(stock));
}

Now we need to create an order processing flow, where each request is handled step by step.

public class Order(
    IInventoryService inventoryService,
    IPaymentService paymentService,
    IShippingService shippingService)
{
    private readonly IInventoryService _inventoryService = inventoryService ?? throw new ArgumentNullException(nameof(inventoryService));
    private readonly IPaymentService _paymentService = paymentService ?? throw new ArgumentNullException(nameof(paymentService));
    private readonly IShippingService _shippingService = shippingService ?? throw new ArgumentNullException(nameof(shippingService));

    public PurchaseResponse Purchase(Customer? customer, Product? product, int quantity = 1)
    {
        if (customer == null)
            return CreateErrorResponse(PurchaseResult.InvalidInput, "Customer cannot be null", 0, 0);

        if (product == null)
            return CreateErrorResponse(PurchaseResult.InvalidInput, "Product cannot be null", 0, 0);

        if (quantity <= 0)
            return CreateErrorResponse(PurchaseResult.InvalidInput, "Quantity must be greater than zero",
                customer.Balance, product.Stock);


        var totalPrice = product.Price * quantity;

        if (product.Stock < quantity)
        {
            var message = $"Purchase failed: Insufficient stock. Required: {quantity}, Available: {product.Stock}";
            return CreateErrorResponse(PurchaseResult.OutOfStock, message, customer.Balance, product.Stock);
        }

        if (customer.Balance < totalPrice)
        {
            var message =
                $"Purchase failed: Insufficient funds. Required: {totalPrice:C}, Available: {customer.Balance:C}";
            return CreateErrorResponse(PurchaseResult.InsufficientFunds, message, customer.Balance, product.Stock);
        }

        if (!_inventoryService.ReserveProduct(product, quantity))
        {
            const string message = "Purchase failed: Unable to reserve product";
            return CreateErrorResponse(PurchaseResult.OutOfStock, message, customer.Balance, product.Stock);
        }


        try
        {
            if (!_paymentService.ProcessPayment(customer, totalPrice))
            {
                _inventoryService.ReleaseProduct(product, quantity);
                const string message = "Purchase failed: Payment processing failed";
                return CreateErrorResponse(PurchaseResult.PaymentFailed, message, customer.Balance, product.Stock);
            }

            if (!_shippingService.ShipProduct(customer, product))
            {
                _inventoryService.ReleaseProduct(product, quantity);
                _paymentService.RefundPayment(customer, totalPrice);
                const string message = "Purchase failed: Shipment processing failed";
                return CreateErrorResponse(PurchaseResult.ShippingFailed, message, customer.Balance, product.Stock);
            }

            var successMessage =
                $"Purchase completed successfully! Customer: {customer.Name}, Product: {product.Name}, Quantity: {quantity}, Total: {totalPrice:C}";

            return new PurchaseResponse
            {
                Result = PurchaseResult.Success,
                Message = successMessage,
                RemainingBalance = customer.Balance,
                RemainingStock = product.Stock,
                ProcessedAt = DateTime.Now
            };
        }
        catch (Exception ex)
        {
            _paymentService.RefundPayment(customer, totalPrice);
            _inventoryService.ReleaseProduct(product, quantity);

            var errorMessage = $"Purchase failed due to unexpected error: {ex.Message}";
            return CreateErrorResponse(PurchaseResult.InvalidInput, errorMessage, customer.Balance, product.Stock);
        }
    }

    private static PurchaseResponse CreateErrorResponse(PurchaseResult result, string message, decimal balance,
        int stock)
    {
        return new PurchaseResponse
        {
            Result = result,
            Message = message,
            RemainingBalance = balance,
            RemainingStock = stock
        };
    }
}

First, we need to validate the input data: the Customer must not be null, and the Product must also be valid. If either check fails, we return an error response.

public class PurchaseResponse
{
    public PurchaseResult Result { get; init; }
    public string? Message { get; init; }
    public decimal RemainingBalance { get; init; }
    public int RemainingStock { get; init; }
    public DateTime ProcessedAt { get; init; }

    public bool IsSuccessful => Result == PurchaseResult.Success;
}

public enum PurchaseResult
{
    Success,
    OutOfStock,
    InsufficientFunds,
    InvalidInput,
    PaymentFailed,
    ShippingFailed
}

Next, we check the product’s stock and the customer’s balance. If the customer requests a quantity greater than what’s available, we return an error. Similarly, if the customer has insufficient funds, we also return an error. In a real-world application, these checks could be delegated to separate services, but here we’ll keep things simple.

When all conditions are met, you can reserve products in Stock.

public interface IInventoryService
{
    bool ReserveProduct(Product product, int quantity = 1);
    void ReleaseProduct(Product product, int quantity = 1);
}

public class InventoryService : IInventoryService
{
    public bool ReserveProduct(Product product, int quantity = 1)
    {
        if (product.Stock < quantity) return false;
        product.Stock -= quantity;
        return true;
    }

    public void ReleaseProduct(Product product, int quantity = 1)
    {
        product.Stock += quantity;
    }
}

The service is responsible for adjusting product stock—decreasing it when items are reserved and increasing it when they’re returned. The ReserveProduct method indicates whether the product was successfully reserved or if it’s already unavailable.

The next step is for the customer to complete the payment, which is handled by a separate payment service.

public interface IPaymentService
{
    bool ProcessPayment(Customer customer, decimal amount);
    void RefundPayment(Customer customer, decimal amount);
}

public class PaymentService : IPaymentService
{
    public bool ProcessPayment(Customer customer, decimal amount)
    {
        if (customer.Balance < amount) return false;
        customer.Balance -= amount;
        return true;
    }

    public void RefundPayment(Customer customer, decimal amount)
    {
        customer.Balance += amount;
    }
}

This service deducts the payment from the customer’s balance and reports whether the transaction was successful. If something goes wrong, the money should be refunded to the customer.

Finally, the last step in the chain is Shipment, where the service confirms that the product has been dispatched.

public interface IShippingService
{
    bool ShipProduct(Customer customer, Product product);
}

public class ShippingService() : IShippingService
{
    public bool ShipProduct(Customer customer, Product product)
    {
        try
        {
            Console.WriteLine($"Product '{product.Id}' shipped to customer '{customer.Id}'");
            return true;
        }
        catch (Exception)
        {
            return false;
        }
    }
}

If the Customer cancels a purchase, issue a refund and return the item to inventory. In the event of critical errors, issue a full refund.

In testing, we can consistently reproduce one successful request and two failed requests.

    public void NaiveApproach()
    {
        var inventoryService = new InventoryService();
        var paymentService = new PaymentService();
        var shippingService = new ShippingService();

        var orderService = new Order(inventoryService, paymentService, shippingService);

        var customer = new Customer(1, "John Doe", 1000m);
        var product = new Product(1, "Gaming Laptop", 899.99m, 5);

        Console.WriteLine("=== Successful Purchase ===");
        var result1 = orderService.Purchase(customer, product);

        PrintResult(result1.Result.ToString(),
            result1.Message,
            result1.RemainingBalance,
            result1.RemainingStock,
            result1.IsSuccessful,
            result1.ProcessedAt);

        Console.WriteLine("\n=== Insufficient Funds ===");
        var expensiveProduct = new Product(2, "Luxury Car", 50000m, 2);
        var result2 = orderService.Purchase(customer, expensiveProduct);

        PrintResult(result2.Result.ToString(),
            result2.Message,
            result2.RemainingBalance,
            result2.RemainingStock,
            result2.IsSuccessful,
            result2.ProcessedAt);

        Console.WriteLine("\n=== Out of Stock ===");
        var result3 = orderService.Purchase(customer, product, 10);
        PrintResult(result3.Result.ToString(),
            result3.Message,
            result3.RemainingBalance,
            result3.RemainingStock,
            result3.IsSuccessful,
            result3.ProcessedAt);
    }

Taken together, this code is tightly coupled. It works now, but it is likely to be brittle and difficult to maintain over time.

How can we improve it?

We will refactor the code and refine the Chain of Responsibility pattern. The Customer and Product models remain unchanged. We will introduce a Context model to carry request-specific data (similar to HttpContext).

public class PurchaseContext
{
    public Customer? Customer { get; init; }
    public Product? Product { get; init; }
    public int Quantity { get; init; }
    public decimal TotalPrice { get; set; }
    public bool IsProcessed { get; set; }
    public PurchaseResult Result { get; set; }
    public string? ErrorMessage { get; set; }
    public DateTime ProcessedAt { get; set; }
    public bool ProductReserved { get; set; }
    public bool PaymentProcessed { get; set; }
}

Next, we’ll implement the pipeline using handlers instead of services. This component will create the context, execute the pipeline, and return the response.

public class OrderProcessingService
{
    private readonly PurchaseHandler _handlerChain;

    public OrderProcessingService()
    {
        var inputValidator = new InputValidationHandler();
        var stockValidator = new StockValidationHandler();
        var balanceValidator = new BalanceValidationHandler();
        var inventoryReservation = new InventoryReservationHandler();
        var paymentProcessor = new PaymentProcessingHandler();
        var shippingHandler = new ShippingHandler();

        inputValidator
            .SetNext(stockValidator)
            .SetNext(balanceValidator)
            .SetNext(inventoryReservation)
            .SetNext(paymentProcessor)
            .SetNext(shippingHandler);

        _handlerChain = inputValidator;
    }

    public PurchaseResponse ProcessOrder(Customer customer, Product product, int quantity = 1)
    {
        var context = new PurchaseContext
        {
            Customer = customer,
            Product = product,
            Quantity = quantity
        };

        var processedContext = _handlerChain.Handle(context);

        var response = new PurchaseResponse
        {
            Result = processedContext.Result,
            Message = processedContext.Result == PurchaseResult.Success
                ? "Purchase completed successfully!"
                : processedContext.ErrorMessage,
            RemainingBalance = customer.Balance,
            RemainingStock = product.Stock,
            ProcessedAt = processedContext.ProcessedAt
        };

        return response;
    }
}

The handlers are composed in a specific order. We define six handlers, each with a single responsibility. The pipeline performs the same business actions as before, but the logic is now encapsulated within handlers. Each handler derives from a base handler that provides two methods: one to process the request using the context, and another to set the next handler in the chain.

public abstract class PurchaseHandler
{
    private PurchaseHandler? _nextHandler;

    public PurchaseHandler SetNext(PurchaseHandler handler)
    {
        _nextHandler = handler;
        return handler;
    }

    public PurchaseContext Handle(PurchaseContext context)
    {
        if (context.IsProcessed)
            return context;

        try
        {
            ProcessRequest(context);

            if (!context.IsProcessed && _nextHandler != null)
            {
                return _nextHandler.Handle(context);
            }
        }
        catch (Exception ex)
        {
            context.Result = PurchaseResult.InvalidInput;
            context.ErrorMessage = ex.Message;
            context.IsProcessed = true;

            Rollback(context);
        }

        return context;
    }

    protected abstract void ProcessRequest(PurchaseContext context);

    protected virtual void Rollback(PurchaseContext context)
    {
    }
}

Here, handlers are responsible for specific action.

public class BalanceValidationHandler : PurchaseHandler
{
    protected override void ProcessRequest(PurchaseContext context)
    {
        if (context.Customer == null || context.Customer.Balance >= context.TotalPrice) return;
        context.Result = PurchaseResult.InsufficientFunds;
        context.ErrorMessage =
            $"Insufficient funds. Required: {context.TotalPrice:C}, Available: {context.Customer.Balance:C}";
        context.IsProcessed = true;
    }
}

public class InputValidationHandler : PurchaseHandler
{
    protected override void ProcessRequest(PurchaseContext context)
    {
        if (context.Customer == null)
        {
            context.Result = PurchaseResult.InvalidInput;
            context.ErrorMessage = "Customer cannot be null";
            context.IsProcessed = true;
            return;
        }

        if (context.Product == null)
        {
            context.Result = PurchaseResult.InvalidInput;
            context.ErrorMessage = "Product cannot be null";
            context.IsProcessed = true;
            return;
        }

        if (context.Quantity <= 0)
        {
            context.Result = PurchaseResult.InvalidInput;
            context.ErrorMessage = "Quantity must be greater than zero";
            context.IsProcessed = true;
            return;
        }

        context.TotalPrice = context.Product.Price * context.Quantity;
    }
}

public class InventoryReservationHandler : PurchaseHandler
{
    protected override void ProcessRequest(PurchaseContext context)
    {
        if (context.Product == null) return;
        context.Product.Stock -= context.Quantity;
        context.ProductReserved = true;
    }

    protected override void Rollback(PurchaseContext context)
    {
        if (!context.ProductReserved) return;
        if (context.Product != null) context.Product.Stock += context.Quantity;
        context.ProductReserved = false;
    }
}

public class PaymentProcessingHandler : PurchaseHandler
{
    protected override void ProcessRequest(PurchaseContext context)
    {
        if (context.Customer != null && context.Customer.Balance >= context.TotalPrice)
        {
            context.Customer.Balance -= context.TotalPrice;
            context.PaymentProcessed = true;
        }
        else
        {
            context.Result = PurchaseResult.PaymentFailed;
            context.ErrorMessage = "Payment processing failed";
            context.IsProcessed = true;
        }
    }

    protected override void Rollback(PurchaseContext context)
    {
        if (context.PaymentProcessed)
        {
            if (context.Customer != null) context.Customer.Balance += context.TotalPrice;
            context.PaymentProcessed = false;
        }

        if (!context.ProductReserved) return;
        if (context.Product != null) context.Product.Stock += context.Quantity;
        context.ProductReserved = false;
    }
}

public class ShippingHandler : PurchaseHandler
{
    protected override void ProcessRequest(PurchaseContext context)
    {
        try
        {
            context.Result = PurchaseResult.Success;
            context.ProcessedAt = DateTime.Now;
            context.IsProcessed = true;
        }
        catch (Exception ex)
        {
            context.Result = PurchaseResult.ShippingFailed;
            context.ErrorMessage = $"Shipping failed: {ex.Message}";
            context.IsProcessed = true;
            throw;
        }
    }

    protected override void Rollback(PurchaseContext context)
    {
        if (context.PaymentProcessed)
        {
            if (context.Customer != null) context.Customer.Balance += context.TotalPrice;
            context.PaymentProcessed = false;
        }

        if (!context.ProductReserved) return;
        if (context.Product != null) context.Product.Stock += context.Quantity;
        context.ProductReserved = false;
    }
}

public class StockValidationHandler : PurchaseHandler
{
    protected override void ProcessRequest(PurchaseContext context)
    {
        if (context.Product == null || context.Product.Stock >= context.Quantity) return;
        context.Result = PurchaseResult.OutOfStock;
        context.ErrorMessage = $"Insufficient stock. Required: {context.Quantity}, Available: {context.Product.Stock}";
        context.IsProcessed = true;
    }
}

The code for testing is almost the same.

    public void CoRApproach()
    {
        var orderService = new OrderProcessingService();

        var customer = new CoR.Models.Customer(1, "John Doe", 1000m);
        var product = new CoR.Models.Product(1, "Gaming Laptop", 899.99m, 5);

        Console.WriteLine("=== Successful Purchase ===");
        var result1 = orderService.ProcessOrder(customer, product);
        PrintResult(result1.Result.ToString(),
            result1.Message,
            result1.RemainingBalance,
            result1.RemainingStock,
            result1.IsSuccessful,
            result1.ProcessedAt);

        Console.WriteLine("\n=== Insufficient Funds ===");
        var expensiveProduct = new CoR.Models.Product(2, "Luxury Car", 50000m, 2);
        var result2 = orderService.ProcessOrder(customer, expensiveProduct);
        PrintResult(result2.Result.ToString(),
            result2.Message,
            result2.RemainingBalance,
            result2.RemainingStock,
            result2.IsSuccessful,
            result2.ProcessedAt);

        Console.WriteLine("\n=== Out of Stock ===");
        var result3 = orderService.ProcessOrder(customer, product, 10);
        PrintResult(result3.Result.ToString(),
            result3.Message,
            result3.RemainingBalance,
            result3.RemainingStock,
            result3.IsSuccessful,
            result3.ProcessedAt);
    }

-In summary, the code is now less coupled and more cohesive. You can extend the service without friction—simply add a new handler.

Benchmarks

With the refactor complete, we can now compare the performance of the two approaches.

As shown, the Chain of Responsibility approach excels not only in readability and extensibility, but also in performance.

Conclusion

There’s no reason not to use the Chain of Responsibility pattern. It offers:

Top performance
Excellent readability
Strong extensibility
Low coupling
High cohesion

I hope you found this guide helpful and that it encourages you to implement similar solutions in your own projects.

SergKorol / DesignPatterns

☕ If you liked this post, consider supporting me:

Train Your Own Model with ML.NET: A Step-by-Step Guide to Personalized AI

Serhii Korol — Wed, 30 Jul 2025 13:47:35 +0000

Hi friends!

Today we’re diving into something quietly revolutionary: how AI, when personalized, can drastically improve our digital experiences. As developers, many of us use AI tools daily. Often, they feel like magic — you ask a question, and AI responds with context-aware suggestions. Behind the scenes, this magic is powered by Large Language Models (LLMs).

These models are trained on massive datasets and can learn from feedback. But there's a catch: what’s relevant for one person might not be for another. Take email filtering, for example. One user’s spam is another’s important newsletter. General spam filters can’t always adapt to individual preferences.

Wouldn’t it be great to train your own model — one that evolves with your feedback, works offline, and respects your privacy? Thanks to ML.NET, Microsoft’s machine learning library for .NET, you can. In this article, we'll build a personalized spam detector using C# and ML.NET that learns from your emails and improves over time.

Step 1: Create a New Project

Create a simple Console Application:

dotnet new console -n SpamDetector

Step 2: Add Required Packages

Add the following NuGet packages to your project:

Microsoft.ML
Microsoft.ML.FastTree

dotnet add package Microsoft.ML
dotnet add package Microsoft.ML.FastTree

Step 3: Prepare the Dataset

Add a TSV (Tab-Separated Values) file for training data. TSV is preferred over CSV since commas can appear in the body of emails. It is needed for the correct parsing of your data. The full dataset can be found in the source code.

Example: email_dataset.tsv

Sender  Subject Body    IsSpam
reports@company.com Monthly Report  Attached is the report for the current month    False
meetings@calendar.com   Meeting Tomorrow    Don't forget about the meeting tomorrow at 10:00    False
hr@company.com  Documents   Sending the necessary documents False
pm@projecthub.com   Project Ready   The project is completed and ready for review   False
vacations@company.com   Vacation    Submitting a vacation request   False
win@lottery-prize.com   Win a Million!  You won a million dollars! Click here!  True
loans@fastcash-now.com  Online Loan Get a loan without documents in 5 minutes   True
deals@superdiscounts.com    90% Discount    Incredible 90% discount on all products! Hurry! True
help@urgent-finance.org Urgent Help Urgent financial help without refusals  True
homejobs@easyprofit.net Earn at Home    Make $5000 at home without leaving the house    True
promo@freeiphones.com   Free iPhone Get a free iPhone right now True
info@national-lottery.ua    Lottery Congratulations! You won $1,000,000 in the lottery  True
cash@quickmoney.co  Quick Money Quick money without checks and certificates True
jobs@dream-career.net   Dream Job   Dream job with a salary of $100,000 True
ads@miraclepills.org    Miracle Pills   Lose 20 kg in a week with our pills True
admin@company.com   Meeting Tomorrow at 14:00 there is a meeting in the conference room False
support@company.com Tech Support    Your request to tech support has been processed False
sales@onlinestore.com   Order   Your order #12345 is ready for pickup   False
schedule@university.edu Schedule    New class schedule for next week    False
notices@subscription.com    Subscription    Your subscription expires in 3 days False

Add to Project File

Optionally, you can add the created TSV file to the cproj file for copy to the output directory.

    <ItemGroup>
        <None Update="email_dataset.tsv">
            <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
        </None>
    </ItemGroup>

Step 4: Define Data Models

Once you have added the dataset, you should create the model that has the same columns — the attributes needed for detecting columns and their order.

Input Data Model

public class EmailData
{
    [LoadColumn(0)] public string Sender { get; set; } = string.Empty;

    [LoadColumn(1)] public string Subject { get; set; } = string.Empty;

    [LoadColumn(2)] public string Body { get; set; } = string.Empty;

    [LoadColumn(3)] public bool IsSpam { get; set; }
}

Another model is needed to show prediction information.

Prediction Output Model

public class SpamPrediction
{
    [ColumnName("PredictedLabel")] public bool IsSpam { get; set; }

    [ColumnName("Probability")] public float Probability { get; set; }

    [ColumnName("Score")] public float Score { get; set; }
}

Step 5: Define File Paths

You need to add the paths for the entry dataset, the trained model, and the user's correction file.

static class Program
{
    private const string DataPath = "email_dataset.tsv";
    private const string ModelPath = "spam_model.zip";
    private const string FeedbackPath = "feedback.tsv";

    static void Main() {}
}

Step 6: Create ML Context

This is the entry point for using ML.NET — similar to a DbContext in EF Core.

    static void Main()
    {
        Console.WriteLine("=== System for checking emails for spam ===\n");

        var mlContext = new MLContext();
    }

Step 7: Build the Pipeline

The pipeline transforms the text in each column into numerical features. These features are then combined into a single feature vector. At the end of the pipeline, we specify the FastTree algorithm as our trainer. FastTree uses this feature vector along with the target label column, IsSpam, which is not included in the feature vector itself.

While there are other available algorithms, FastTree is a well-suited choice for this task. It is a gradient boosting machine (GBM) algorithm designed for binary classification, regression, and ranking problems. In this context, it is used for binary classification — specifically, to distinguish between spam and non-spam emails.

FastTree is optimized for speed and performs well on tabular data. However, it has an important limitation: it requires a dataset with at least 1,000 samples to achieve acceptable accuracy. Smaller datasets may result in poor model performance.

static void Main()
    {
        Console.WriteLine("=== System for checking emails for spam ===\n");

        var mlContext = new MLContext();

        var pipeline = BuildPipeline(mlContext);
    }

private static IEstimator<ITransformer> BuildPipeline(MLContext mlContext)
    {
        return mlContext.Transforms.Text
            .FeaturizeText("SenderFeatures", nameof(EmailData.Sender))
            .Append(mlContext.Transforms.Text.FeaturizeText("SubjectFeatures", nameof(EmailData.Subject)))
            .Append(mlContext.Transforms.Text.FeaturizeText("BodyFeatures", nameof(EmailData.Body)))
            .Append(mlContext.Transforms.Concatenate("Features", "SenderFeatures", "SubjectFeatures", "BodyFeatures"))
            .Append(mlContext.Transforms.NormalizeLpNorm("Features"))
            .Append(mlContext.BinaryClassification.Trainers.FastTree(
                labelColumnName: nameof(EmailData.IsSpam), featureColumnName: "Features"));
    }

Step 8: Train the Model

Step 8.1: Load or Train

Check for a saved model. If none exists, load the dataset or train a new one. We should avoid retraining unless necessary.

if (File.Exists(ModelPath))
...

Step 8.2: Load Datasets

If no trained model is available, we need to load the text data into a DataView using the correct separator. Failing to do so will result in an error during training.

In addition to the main email dataset, we also load the user's feedback dataset. This is important for scenarios where the trained model has been deleted and needs to be retrained — ensuring that any user-provided corrections are preserved and included in the new model.

var allData = LoadAllData(mlContext);
...

Step 8.3: Split the Data

The test set ratio determines how much of the data is reserved for evaluation.

In general, a smaller test fraction allows for better training, as more data is used to train the model. However, having a test set is essential for measuring the model’s performance objectively. Without it, the model might simply "memorize" the training data, giving a false impression of accuracy.

The test set helps validate how well the model generalizes to unseen data and is used to compute key performance metrics. For small datasets, it's acceptable to allocate less than 20% to testing. Otherwise, a test split of 20–30% is typically recommended.

var split = mlContext.Data.TrainTestSplit(allDataView, testFraction: 0.2);
...

Step 8.4: Train and Evaluate

After data splitting, we use the training set for training the model and the test set for evaluation.

Console.WriteLine("Training model...");
model = pipeline.Fit(split.TrainSet);

Console.WriteLine("Evaluating model...");
var predictions = model.Transform(split.TestSet);
...

Step 8.5: Generate Metrics

After training, we evaluate the model's performance using several key metrics based on its predictions. These include Accuracy, AUC, and F1 Score:

Accuracy measures the percentage of correct predictions made by the model.
AUC (Area Under the ROC Curve) indicates how well the model distinguishes between spam and non-spam emails. A value of 1.0 represents perfect classification.
F1 Score is the harmonic mean of precision and recall, providing a balanced measure of the model’s ability to correctly identify spam while minimizing false positives and false negatives.

var metrics = mlContext.BinaryClassification.Evaluate(predictions, labelColumnName: nameof(EmailData.IsSpam));
...

Step 8.6: Save the Data

Once you have generated the model and metrics, you should save the trained model for further use.

mlContext.Model.Save(model, allDataView.Schema, ModelPath);
...

Optionally, you can copy the model to the project directory. If you did everything properly, you'll see a zip archive in your project.

CopyFileToProjectDirectory(ModelPath);
...

The ultimate code:

    static void Main()
    {
        Console.WriteLine("=== System for checking emails for spam ===\n");

        var mlContext = new MLContext();

        var pipeline = BuildPipeline(mlContext);

        ITransformer model = LoadOrTrainModel(mlContext, pipeline);
    }

    private static ITransformer LoadOrTrainModel(MLContext mlContext, IEstimator<ITransformer> pipeline)
    {
        if (File.Exists(ModelPath))
        {
            Console.WriteLine("Loading saved model...");
            return mlContext.Model.Load(ModelPath, out _);
        }

        Console.WriteLine("The model is not found. Training the new model...");
        var allData = LoadAllData(mlContext);
        return TrainEvaluateSaveModel(mlContext, pipeline, allData, saveFeedback: false);
    }

    private static List<EmailData> LoadAllData(MLContext mlContext)
    {
        IDataView originalData = mlContext.Data.LoadFromTextFile<EmailData>(
            DataPath, separatorChar: '\t', hasHeader: true);

        var allExamples = mlContext.Data
            .CreateEnumerable<EmailData>(originalData, reuseRowObject: false)
            .ToList();

        if (File.Exists(FeedbackPath))
        {
            Console.WriteLine("Found feedback data. Including it in training...");
            IDataView feedbackData = mlContext.Data.LoadFromTextFile<EmailData>(
                FeedbackPath, separatorChar: '\t', hasHeader: false);

            var feedbackList = mlContext.Data
                .CreateEnumerable<EmailData>(feedbackData, reuseRowObject: false)
                .ToList();

            allExamples.AddRange(feedbackList);
        }
        return allExamples;
    }

    private static ITransformer TrainEvaluateSaveModel(
        MLContext mlContext,
        IEstimator<ITransformer> pipeline,
        List<EmailData> allData,
        bool saveFeedback)
    {
        var allDataView = mlContext.Data.LoadFromEnumerable(allData);
        var split = mlContext.Data.TrainTestSplit(allDataView, testFraction: 0.2);

        Console.WriteLine("Training model...");
        var model = pipeline.Fit(split.TrainSet);

        Console.WriteLine("Evaluating model...");
        var predictions = model.Transform(split.TestSet);
        var metrics = mlContext.BinaryClassification.Evaluate(predictions, labelColumnName: nameof(EmailData.IsSpam));

        Console.WriteLine($"Accuracy: {metrics.Accuracy:P2}");
        Console.WriteLine($"AUC: {metrics.AreaUnderRocCurve:P2}");
        Console.WriteLine($"F1 Score: {metrics.F1Score:P2}\n");

        mlContext.Model.Save(model, allDataView.Schema, ModelPath);
        CopyFileToProjectDirectory(ModelPath);
        if (saveFeedback)
            CopyFileToProjectDirectory(FeedbackPath);

        Console.WriteLine($"The model saved to {ModelPath}\n");
        return model;
    }

    private static void CopyFileToProjectDirectory(string fileName)
    {
        string currentDir = Directory.GetCurrentDirectory();
        string projectDir = Path.GetFullPath(Path.Combine(currentDir, "..", "..", ".."));
        string sourcePath = Path.Combine(currentDir, fileName);
        string destPath = Path.Combine(projectDir, fileName);
        File.Copy(sourcePath, destPath, overwrite: true);
    }

Step 9: Make Predictions

Create a PredictionEngine to test individual emails.

    static void Main()
    {
        Console.WriteLine("=== System for checking emails for spam ===\n");

        var mlContext = new MLContext();

        var pipeline = BuildPipeline(mlContext);

        ITransformer model = LoadOrTrainModel(mlContext, pipeline);
        var predictionEngine = mlContext.Model.CreatePredictionEngine<EmailData, SpamPrediction>(model);
    }

Step 10: Interactive Input & Feedback Loop

This code allows you to input user data and get a prediction of SPAM/NOT SPAM.

static void Main()
    {
        Console.WriteLine("=== System for checking emails for spam ===\n");

        var mlContext = new MLContext();

        var pipeline = BuildPipeline(mlContext);

        ITransformer model = LoadOrTrainModel(mlContext, pipeline);
        var predictionEngine = mlContext.Model.CreatePredictionEngine<EmailData, SpamPrediction>(model);

        RunInteractiveCheck(mlContext, pipeline, ref model, ref predictionEngine);

        Console.WriteLine("The app completed successfully. Goodbye!");
    }

Step 10.1: Correction

From time to time, you may encounter cases where you disagree with the model’s prediction. For example, an important email might be incorrectly marked as spam, and you manually reclassify it as not spam.

We’ve implemented a similar mechanism: users can correct incorrect predictions, and the system will use this feedback to retrain the model and save the updated version. This helps improve accuracy over time by learning from real-world corrections.

var feedback = PromptInput("Do you agree with the result? (y/n): ", toLower: true);
if (feedback == "n")
...

private static string? PromptInput(string message, bool toLower = false)
    {
        Console.Write(message);
        var input = Console.ReadLine();
        if (input?.ToLower() == "q") return null;
        return toLower ? input?.ToLower() : input;
    }

Step 10.2: Save the Feedback

Once you have made the correction, you should save this data for retraining the model in the future.

SaveFeedback(sender, subject, body, userLabel);
...

Step 12: Testing

Let’s run the application and test it.
After launching and exiting the app, you’ll notice that a new model was trained during the first run. If you check the project directory, you’ll find a .zip file containing the trained model.

Now, let's run the app again.
As you can see, we loaded a pre-trained model.

Next, let’s input some data. The machine learning model predicts that the email is not spam.
However, if a stranger sends you an email offering to sell you an elephant, it's clear the prediction is incorrect — and you'd likely disagree with it.

In this case, we need to correct the prediction. Type "n" to indicate that the email is spam.
As you can see, the model has been updated accordingly. You can also find the user feedback dataset saved in your project directory.

Now, we have created the new rule for this email.

Now, let's repeat the actions and enter the same data again. Now, this email is detected as SPAM.

Conclusion

The ML.NET library is a powerful tool for training custom machine learning models using your own datasets. You can also find a wide variety of high-quality datasets on platforms like Kaggle.com. Unlike popular AI services such as OpenAI or Claude, which often raise privacy concerns, ML.NET keeps all your data securely on your own server.

However, ML.NET does have some challenges. It has a relatively steep learning curve, requiring a solid understanding of machine learning algorithms. You also need to source or create appropriate datasets, and the quality of your trained model heavily depends on the quality of the data you use.

I hope you found this guide helpful and that it encourages you to implement similar solutions in your own projects.

For your convenience, the complete source code is available on my GitHub repository for reference and further exploration.

SergKorol / SpamDetector

☕ If you liked this post, consider supporting me:

Design Patterns #9: A Hands-On Comparison of Mediator Pattern Approaches

Serhii Korol — Tue, 08 Jul 2025 14:41:48 +0000

Today, let’s explore the Mediator design pattern—an approach that promotes loose coupling between components by centralizing their communication. This pattern becomes especially relevant now that the popular MediatR library has switched to a commercial license. While many companies can still use it for free, the license terms could change in the future. So, it’s wise to be prepared with alternatives.

That said, licensing concerns shouldn't discourage you from using the Mediator pattern itself - it remains a powerful architectural tool.

🤔 What Is the Mediator Pattern?

The Mediator is a behavioral design pattern that allows components (often called colleagues) to communicate through a central mediator rather than referencing each other directly.

In traditional designs, components talk to one another directly:

Over time, this tight coupling creates a tangled web of dependencies, making the system hard to change and test. The Mediator pattern addresses this by introducing a central object to handle all communication:

🧪 Implementing the Mediator Pattern in Code

Let’s consider a simple chat application. We’ll use the Mediator pattern to decouple users from each other.

Step 1: Define the Mediator Interface

public interface IChatMediator
{
    void SendMessage(string message, User sender);
    void AddUser(User user);
}

Step 2: Create the Concrete Mediator (Chat Room)

The chat room will be the Mediator that has two concrete methods that are implementing adding a user to the chat room and sending a message.

public class ChatRoom : IChatMediator
{
    private readonly List<User> _users = new();

    public void AddUser(User user)
    {
        _users.Add(user);
    }

    public void SendMessage(string message, User sender)
    {
        foreach (var user in _users)
        {
            if (user != sender)
            {
                user.ReceiveMessage(message, sender);
            }
        }
    }
}

Step 3: Define the User

Let's also create a user who can initiate sending and receiving messages.

public class User
{
    private readonly IChatMediator _mediator;
    private string Name { get; }

    public User(string name, IChatMediator mediator)
    {
        Name = name;
        _mediator = mediator;
        _mediator.AddUser(this);
    }

    public void Send(string message)
    {
        Console.WriteLine($"{Name} sends: {message}");
        _mediator.SendMessage(message, this);
    }

    public void ReceiveMessage(string message, User sender)
    {
        Console.WriteLine($"{Name} receives from {sender.Name}: {message}");
    }
}

Step 4: Run the Example

Let's use it, create more users, and send messages.

    public void MediatorApproach()
    {
        IChatMediator chatRoom = new ChatRoom();

        var user1 = new User("Alice", chatRoom);
        var user2 = new User("Bob", chatRoom);
        var user3 = new User("Charlie", chatRoom);

        user1.Send("Hello everyone!");
        user2.Send("Hi Alice!");
        user3.Send("Hey folks!");
    }

If you run it, you'll see this result.

Alice sends: Hello everyone!
Bob receives from Alice: Hello everyone!
Charlie receives from Alice: Hello everyone!
Bob sends: Hi Alice!
Alice receives from Bob: Hi Alice!
Charlie receives from Bob: Hi Alice!
Charlie sends: Hey folks!
Alice receives from Charlie: Hey folks!
Bob receives from Charlie: Hey folks!

Process finished with exit code 0.

Communication occurs through the chat room, also known as the Mediator.

🧩 Using MediatR Instead

As I mentioned earlier, there is an ultimate solution, and you can use the NuGet package MediatR. This implementation is more straightforward. MediatR provides a clean and popular solution. You need to implement the notification class and handler.

public class ChatMessage(string sender, string message) : INotification
{
    public string Sender { get; } = sender;
    public string Message { get; } = message;
}

public class ChatRoomHandler : INotificationHandler<ChatMessage>
{
    private static readonly List<string> Users = ["Alice", "Bob", "Charlie"];

    public Task Handle(ChatMessage notification, CancellationToken cancellationToken)
    {
        Console.WriteLine($"{notification.Sender} sends: {notification.Message}");
        foreach (var user in Users.Where(user => user != notification.Sender))
        {
            Console.WriteLine($"{user} receives from {notification.Sender}: {notification.Message}");
        }

        return Task.CompletedTask;
    }
}

This approach requires only two interface implementations and the addition of specific logic. As a rule, each handler is responsible for one action and also has its own notification. In an extensive application, it leads to a large number of messages and handlers. However, each pair of a message and a handler is isolated and doesn't affect other handlers.

The use is also different. You must register MediatR. Next, you should publish only messages. MedaitR by type will call the target handler.

public static async Task MediatrApproach()
    {
        var services = new ServiceCollection();

        services.AddMediatR(cfg => cfg.RegisterServicesFromAssemblyContaining<Program>());

        var provider = services.BuildServiceProvider();
        var mediator = provider.GetRequiredService<IMediator>();

        await mediator.Publish(new ChatMessage("Alice", "Hello everyone!"));
        await mediator.Publish(new ChatMessage("Bob", "Hi Alice!"));
        await mediator.Publish(new ChatMessage("Charlie", "Hey folks!"));
    }

🚫 When Not to Use a Mediator

If your app is small, unlikely to scale, or contains only a few components, you might not need a Mediator at all.

Here’s a naive implementation using direct coupling:

public class ChatRoom
{
    private readonly List<User> _users = [];

    public void RegisterUser(User user)
    {
        _users.Add(user);
    }

    public void Broadcast(string message, User sender)
    {
        foreach (var user in _users)
        {
            if (user != sender)
            {
                user.ReceiveMessage(message, sender);
            }
        }
    }
}

public class User
{
    private string Name { get; }
    private readonly ChatRoom _chatRoom;

    public User(string name, ChatRoom chatRoom)
    {
        Name = name;
        _chatRoom = chatRoom;
        _chatRoom.RegisterUser(this);
    }

    public void Send(string message)
    {
        Console.WriteLine($"{Name} sends: {message}");
        _chatRoom.Broadcast(message, this);
    }

    public void ReceiveMessage(string message, User sender)
    {
        Console.WriteLine($"{Name} received from {sender.Name}: {message}");
    }
}

The use of this approach is similar to that of Mediator. You create the chat room, new users, and send messages. The code is almost the same.

    public static void NaiveApproach()
    {
        var chatRoom = new MediatorPattern.Naive.ChatRoom();

        var alice = new MediatorPattern.Naive.User("Alice", chatRoom);
        var bob = new MediatorPattern.Naive.User("Bob", chatRoom);
        var charlie = new MediatorPattern.Naive.User("Charlie", chatRoom);

        alice.Send("Hello everyone!");
        bob.Send("Hi Alice!");
        charlie.Send("Hey folks!");
    }

📊 What About Performance?

As you can guess, the difference between the first and third approaches is minimal. The key difference is only in maintainability and scalability. However, how can a third-party library affect performance? You don't know what was done under the hood, where you don't have control.

As expected, third-party libraries like MediatR do introduce slight overhead.

✅ Conclusion

The Mediator pattern is not about performance - it’s about maintainability, modularity, and scalability.

✅ Use the naive approach for quick prototypes or small apps.
✅ Implement your own Mediator for full control and clarity.
✅ Use MediatR for larger applications or when you want to embrace a fully decoupled architecture - but keep the licensing in mind.

SergKorol / DesignPatterns

☕ If you liked this post, consider supporting me:

Design Patterns #8: If Repository Is Not Enough – Exploring Real-World Data Patterns

Serhii Korol — Thu, 22 May 2025 13:25:53 +0000

Today, I’d like to talk about a design pattern that many developers use by default in almost every project — the Repository pattern. It's a popular approach for abstracting data access, and in many cases, it gets the job done.

But what happens when it’s not enough?

In this article, I’ll walk you through alternative approaches built on top of the Repository pattern, including Unit of Work and Lazy Loading Proxies. These patterns can help you tackle more complex scenarios while keeping your code clean and maintainable.

Let’s dive in.

Repository

First, let’s start with a typical implementation of the Repository pattern. We’ll use a SQLite database and implement the basic CRUD operations — Create, Read, Update, and Delete.
The database file used in this example is included in the repository for this article.

To keep things simple, we’ll define a pair of related entities that demonstrate how the pattern works in practice.

public class Album
{
    public int AlbumId { get; set; }
    public string? Title { get; set; }
    public int ArtistId { get; set; }
    public Artist? Artist { get; set; }
}

public class Artist
{
    public int ArtistId { get; set; }
    public string? Name { get; set; }
    public List<Album>? Albums { get; set; }
}

What’s a Repository without a database context?
Let’s add the DbContext, where we configure the connection string and define the relationships between our tables.

public class MusicDbContext : DbContext
{
    public DbSet<Artist> Artists { get; set; }
    public DbSet<Album> Albums { get; set; }

    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
    {
        optionsBuilder.UseSqlite("Data Source=chinook.db");
    }

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.Entity<Artist>(entity =>
        {
            entity.ToTable("artists");
            entity.HasKey(e => e.ArtistId);
            entity.Property(e => e.ArtistId).HasColumnName("ArtistId");
            entity.Property(e => e.Name).HasColumnName("Name").HasMaxLength(120);

            entity.HasMany(a => a.Albums)
                .WithOne(b => b.Artist)
                .HasForeignKey(b => b.ArtistId);
        });

        modelBuilder.Entity<Album>(entity =>
        {
            entity.ToTable("albums");
            entity.HasKey(e => e.AlbumId);
            entity.Property(e => e.AlbumId).HasColumnName("AlbumId");
            entity.Property(e => e.Title).HasColumnName("Title").HasMaxLength(160);
            entity.Property(e => e.ArtistId).HasColumnName("ArtistId");
        });
    }
}

Now, let’s implement the Repository itself. Since most repositories share the same basic CRUD operations, we’ll start by creating a generic base Repository to avoid duplication and keep things clean.

public interface IRepository<T> where T : class
{
    Task<IEnumerable<T>> GetAllAsync();
    Task<T?> GetByIdAsync(int id);
    Task AddAsync(T entity);
    Task UpdateAsync(T entity);
    Task DeleteAsync(int id);
}

public abstract class Repository<T> : IRepository<T> where T : class
{
    private readonly MusicDbContext _context;
    private readonly DbSet<T> _dbSet;

    protected Repository(MusicDbContext context)
    {
        _context = context;
        _dbSet = _context.Set<T>();
    }

    public virtual async Task<IEnumerable<T>> GetAllAsync()
    {
        return await _dbSet.ToListAsync();
    }

    public virtual async Task<T?> GetByIdAsync(int id)
    {
        return await _dbSet.FindAsync(id);
    }

    public virtual async Task AddAsync(T entity)
    {
        await _dbSet.AddAsync(entity);
        await _context.SaveChangesAsync();
    }

    public virtual async Task UpdateAsync(T entity)
    {
        _dbSet.Update(entity);
        await _context.SaveChangesAsync();
    }

    public virtual async Task DeleteAsync(int id)
    {
        var entity = await GetByIdAsync(id);
        if (entity != null)
        {
            _dbSet.Remove(entity);
            await _context.SaveChangesAsync();
        }
    }
}

Now, let’s create concrete repositories for each entity. In this example, all methods are overridden, but if you need entity-specific queries, you can add them only to the corresponding repository. Notice that we include related tables using eager loading—this ensures the related data is loaded alongside the main entity, whether it's used or not. While eager loading can be convenient, including too many related tables may lead to performance issues due to unnecessary data retrieval.

public class AlbumRepository(MusicDbContext context)  : Repository<Album>(context)
{
    public override async Task<IEnumerable<Album>> GetAllAsync()
    {
        return await context.Albums.Include(x => x.Artist).ToListAsync();
    }

    public override async Task<Album?> GetByIdAsync(int id)
    {
        return await context.Albums.Include(x => x.Artist).FirstOrDefaultAsync(x => x.AlbumId == id);
    }

    public override async Task AddAsync(Album album)
    {
        await base.AddAsync(album);
    }

    public override async Task UpdateAsync(Album album)
    {
        await base.UpdateAsync(album);
    }

    public override async Task DeleteAsync(int id)
    {
        var entity = await GetByIdAsync(id);
        if (entity != null)
        {
            await base.DeleteAsync(id);
        }
    }
}

public class ArtistRepository(MusicDbContext context) : Repository<Artist>(context)
{
    public override async Task<IEnumerable<Artist>> GetAllAsync()
    {
        return await context.Artists.Include(x => x.Albums).ToListAsync();
    }

    public override async Task<Artist?> GetByIdAsync(int id)
    {
        return await context.Artists.Include(x => x.Albums).FirstOrDefaultAsync(x => x.ArtistId == id);
    }

    public override async Task AddAsync(Artist artist)
    {
        await base.AddAsync(artist);
    }

    public override async Task UpdateAsync(Artist artist)
    {
        await base.UpdateAsync(artist);
    }

    public override async Task DeleteAsync(int id)
    {
        var entity = await GetByIdAsync(id);
        if (entity != null)
        {
            await base.DeleteAsync(id);
        }
    }
}

Optionally, you can introduce services to handle data retrieval and modification. While it's possible to call repositories directly, using services is more common in real-world applications, as it helps encapsulate business logic and maintain separation of concerns.

public class ArtistService(IRepository<Artist> artistRepository)
{
    public Task<IEnumerable<Artist>> GetAllArtistsAsync() => artistRepository.GetAllAsync();

    public Task<Artist?> GetArtistByIdAsync(int id) => artistRepository.GetByIdAsync(id);

    public Task AddArtistAsync(Artist artist) => artistRepository.AddAsync(artist);

    public Task UpdateArtistAsync(Artist artist) => artistRepository.UpdateAsync(artist);

    public Task DeleteArtistAsync(int id) => artistRepository.DeleteAsync(id);
}

public class AlbumService(IRepository<Album> albumRepository)
{
    public Task DeleteAlbumAsync(int id) => albumRepository.DeleteAsync(id);
}

To test and run the scenario, define the following method:

public static async Task RunRepository()
    {
        //init
        await using var dbContext = new Repository.Context.MusicDbContext();
        var artistRepository = new ArtistRepository(dbContext);
        var albumRepository = new AlbumRepository(dbContext);
        var artistService = new Repository.Services.ArtistService(artistRepository);
        var albumService = new Repository.Services.AlbumService(albumRepository);

        //get all artists
        Console.WriteLine("All artists:");
        var artists = await artistService.GetAllArtistsAsync();
        foreach (var artist in artists)
        {
            var albums = artist.Albums != null && artist.Albums.Any()
                ? artist.Albums.Select(x => x.Title).ToList()
                : ["No albums"];
            Console.WriteLine($"{artist.ArtistId}: {artist.Name}. Discography: {string.Join(", ", albums)}");
        }

        // Add new artist
        var newArtist = new Artist
            { Name = "EF Core Artist", Albums = new List<Album> { new Album { Title = "EF Core Album" } } };
        await artistService.AddArtistAsync(newArtist);
        Console.WriteLine($"Added artist with ID {newArtist.ArtistId}");

        // Update artist
        newArtist.Name = "Updated EF Core Artist";
        await artistService.UpdateArtistAsync(newArtist);
        Console.WriteLine("Updated artist.");

        // Get by ID
        var artistById = await artistService.GetArtistByIdAsync(newArtist.ArtistId);
        if (artistById?.Albums != null)
        {
            var albums = artistById.Albums.Select(x => x.Title).ToList();
            Console.WriteLine(
                $"Artist by ID: {artistById.ArtistId} - {artistById.Name} ({string.Join(", ", albums.Count > 0 ? albums : ["No albums"])})");

            //Delete album
            await albumService.DeleteAlbumAsync(artistById.Albums.First().AlbumId);
            artistById = await artistService.GetArtistByIdAsync(newArtist.ArtistId);
            if (artistById?.Albums != null) albums = artistById.Albums.Select(x => x.Title).ToList();
            Console.WriteLine(
                $"Artist by ID: {artistById?.ArtistId} - {artistById?.Name} ({string.Join(", ", albums.Count > 0 ? albums : ["No albums"])})");
        }

        // Delete artist
        await artistService.DeleteArtistAsync(newArtist.ArtistId);
        Console.WriteLine("Deleted artist.");

        Console.WriteLine("Done.");
    }

The result should be like this:

All artists:
1: AC/DC. Discography: For Those About To Rock We Salute You, Let There Be Rock
2: Accept. Discography: Balls to the Wall, Restless and Wild
3: Aerosmith. Discography: Big Ones
...
273: C. Monteverdi, Nigel Rogers - Chiaroscuro; London Baroque; London Cornett & Sackbu. Discography: Monteverdi: L'Orfeo
274: Nash Ensemble. Discography: Mozart: Chamber Music
275: Philip Glass Ensemble. Discography: Koyaanisqatsi (Soundtrack from the Motion Picture)
Added artist with ID 280
Updated artist.
Artist by ID: 280 - Updated EF Core Artist (EF Core Album)
Artist by ID: 280 - Updated EF Core Artist (No albums)
Deleted artist.
Done.

Process finished with exit code 0.

Let's examine the strengths and weaknesses of this approach:

✅ Pros:

Simple and straightforward to implement
Widely adopted and well-understood
Delivers high performance in most scenarios

❌ Cons:

Requires manual inclusion of related tables for each query
Eager loading can negatively impact performance if overused
Code readability can suffer when managing many repositories

How can we improve this?

UnitOfWork

This approach aims to improve readability without compromising performance. It requires only minimal changes to your existing codebase. The core idea behind this pattern is to introduce a class that encapsulates all your repositories, providing a single entry point for data access.

public interface IUnitOfWork : IAsyncDisposable
{
    public IRepository<Artist> ArtistRepository { get; }
    public IRepository<Album> AlbumRepository { get; }

    Task<int> SaveChangesAsync();
}

public class UnitOfWork : IUnitOfWork
{
    private readonly MusicDbContext _context;
    public IRepository<Artist> ArtistRepository { get; }

    public IRepository<Album> AlbumRepository { get; }

    public UnitOfWork(MusicDbContext context)
    {
        _context = context;
        ArtistRepository = new ArtistRepository(_context);
        AlbumRepository = new AlbumRepository(_context);
    }

    public async Task<int> SaveChangesAsync()
    {
        return await _context.SaveChangesAsync();
    }

    public async ValueTask DisposeAsync()
    {
        await _context.DisposeAsync();
    }
}

Next, update your services to use the UnitOfWork instead of individual repositories.

public class ArtistService(IUnitOfWork uow)
{
    public Task<IEnumerable<Artist>> GetAllArtistsAsync() => uow.ArtistRepository.GetAllAsync();

    public Task<Artist?> GetArtistByIdAsync(int id) => uow.ArtistRepository.GetByIdAsync(id);

    public Task AddArtistAsync(Artist artist) => uow.ArtistRepository.AddAsync(artist);

    public Task UpdateArtistAsync(Artist artist) => uow.ArtistRepository.UpdateAsync(artist);

    public Task DeleteArtistAsync(int id) => uow.ArtistRepository.DeleteAsync(id);
}

public class AlbumService(IUnitOfWork uow)
{
    public Task DeleteAlbumAsync(int id) => uow.AlbumRepository.DeleteAsync(id);
}

To try this out, add the following code:

    public static async Task RunUnitOfWork()
    {
        //init
        await using var dbContext = new UnitOfWork.Context.MusicDbContext();
        var uow = new UnitOfWork.UoW.UnitOfWork(dbContext);
        var artistService = new UnitOfWork.Services.ArtistService(uow);
        var albumService = new UnitOfWork.Services.AlbumService(uow);

        //get all artists
        Console.WriteLine("All artists:");
        var artists = await artistService.GetAllArtistsAsync();
        foreach (var artist in artists)
        {
            var albums = artist.Albums.Any() ? artist.Albums.Select(x => x.Title).ToList() : ["No albums"];
            Console.WriteLine($"{artist.ArtistId}: {artist.Name}. Discography: {string.Join(", ", albums)}");
        }

        // Add new artist
        var newArtist = new UnitOfWork.Models.Artist
        {
            Name = "EF Core Artist",
            Albums = new List<UnitOfWork.Models.Album> { new UnitOfWork.Models.Album { Title = "EF Core Album" } }
        };
        await artistService.AddArtistAsync(newArtist);
        Console.WriteLine($"Added artist with ID {newArtist.ArtistId}");

        // Update artist
        newArtist.Name = "Updated EF Core Artist";
        await artistService.UpdateArtistAsync(newArtist);
        Console.WriteLine("Updated artist.");

        // Get by ID
        var artistById = await artistService.GetArtistByIdAsync(newArtist.ArtistId);
        if (artistById?.Albums != null)
        {
            var albums = artistById.Albums.Select(x => x.Title).ToList();
            Console.WriteLine(
                $"Artist by ID: {artistById.ArtistId} - {artistById.Name} ({string.Join(", ", albums.Count > 0 ? albums : ["No albums"])})");

            //Delete album
            await albumService.DeleteAlbumAsync(artistById.Albums.First().AlbumId);
            artistById = await artistService.GetArtistByIdAsync(newArtist.ArtistId);
            if (artistById?.Albums != null) albums = artistById.Albums.Select(x => x.Title).ToList();
            Console.WriteLine(
                $"Artist by ID: {artistById?.ArtistId} - {artistById?.Name} ({string.Join(", ", albums.Count > 0 ? albums : ["No albums"])})");
        }

        // Delete artist
        await artistService.DeleteArtistAsync(newArtist.ArtistId);
        Console.WriteLine("Deleted artist.");

        Console.WriteLine("Done.");
    }

The result should be the same as before. Now, let’s take a look at the pros and cons:

✅ Pros

Improved readability
Retains the same benefits as the Repository pattern

❌ Cons

Uses eager loading, which can potentially impact performance
May be overkill for small databases

The main drawback of both previous approaches is the use of eager loading. How can this be addressed? The answer is lazy loading, which I will explain in the next chapter.

Naive lazy loading

I’ll show you an approach that doesn’t rely on third-party packages and involves working with additional tables manually. This method requires more substantial changes to your codebase. The main goal of this implementation is to apply the Proxy pattern, which I’ll cover in more detail in future articles.

With this approach, we don’t access entities directly when querying data—instead, we use proxy entities to act on their behalf.

public delegate Task<List<Album>> LazyAlbumsLoader(int artistId);

public class LazyArtist : Artist
{
    private readonly LazyAlbumsLoader _lazyLoader;
    private List<Album>? _albums;
    private bool _isLoaded;
    private readonly SemaphoreSlim _semaphore = new(1, 1);

    public LazyArtist(Artist artist, LazyAlbumsLoader lazyLoader)
    {
        ArtistId = artist.ArtistId;
        Name = artist.Name;
        _lazyLoader = lazyLoader;
        _isLoaded = false;
    }

    public new Task<List<Album>?> Albums => GetAlbumsAsync();

    private async Task<List<Album>?> GetAlbumsAsync()
    {
        if (_isLoaded) return _albums;

        await _semaphore.WaitAsync();
        try
        {
            if (!_isLoaded)
            {
                _albums = await _lazyLoader(ArtistId);
                _isLoaded = true;
            }
        }
        finally
        {
            _semaphore.Release();
        }

        return _albums;
    }
}

This class inherits from the base entity and loads related data on demand. The private method used for this is fully thread-safe.

Next, you’ll need to update your repositories and remove all Include statements.

public class AlbumRepository(MusicDbContext context) : Repository<Album>(context)
{
    public override async Task<IEnumerable<Album>> GetAllAsync()
    {
        return await context.Albums.ToListAsync();
    }

    public override async Task<Album?> GetByIdAsync(int id)
    {
        return await context.Albums.FirstOrDefaultAsync(x => x.AlbumId == id);
    }

    public async Task<List<Album>> GetByForeignKeyAsync(int id)
    {
        return await context.Albums.Where(x => x.ArtistId == id).ToListAsync();
    }

    public override async Task AddAsync(Album album)
    {
        await base.AddAsync(album);
    }

    public override async Task UpdateAsync(Album album)
    {
        await base.UpdateAsync(album);
    }

    public override async Task DeleteAsync(int id)
    {
        var entity = await GetByIdAsync(id);
        if (entity != null)
        {
            await base.DeleteAsync(id);
        }
    }
}

public class ArtistRepository(MusicDbContext context) : Repository<Artist>(context)
{
    public override async Task<IEnumerable<Artist>> GetAllAsync()
    {
        return await context.Artists.ToListAsync();
    }

    public override async Task<Artist?> GetByIdAsync(int id)
    {
        return await context.Artists.FirstOrDefaultAsync(x => x.ArtistId == id);
    }

    public override async Task AddAsync(Artist artist)
    {
        await base.AddAsync(artist);
    }

    public override async Task UpdateAsync(Artist artist)
    {
        await base.UpdateAsync(artist);
    }

    public override async Task DeleteAsync(int id)
    {
        var entity = await GetByIdAsync(id);
        if (entity != null)
        {
            await base.DeleteAsync(id);
        }
    }
}

To enable lazy loading, an intermediate layer is also required. This class loads the necessary data on demand.

public class LazyFactory(ArtistRepository artistRepo, AlbumRepository albumRepo) : ILazyFactory
{
    public async Task<List<LazyArtist>> GetAllLazyArtistsAsync()
    {
        var artists = await artistRepo.GetAllAsync();
        var lazyArtists = artists.Select(a => new LazyArtist(a, artistId => albumRepo.GetByForeignKeyAsync(artistId)))
            .ToList();
        return lazyArtists;
    }

    public async Task<LazyArtist?> GetLazyArtistByIdAsync(int id)
    {
        var artist = await artistRepo.GetByIdAsync(id);
        if (artist == null) return null;

        var lazyArtist = new LazyArtist(artist, async artistId =>
            (await albumRepo.GetByForeignKeyAsync(artistId)).ToList());
        return lazyArtist;
    }
}

public interface ILazyFactory
{
    Task<List<LazyArtist>> GetAllLazyArtistsAsync();
    Task<LazyArtist?> GetLazyArtistByIdAsync(int id);
}

Use this class in your service implementation:

public class ArtistService(IRepository<Artist> artistRepository, ILazyFactory lazyFactory)
{
    public Task<List<LazyArtist>> GetAllArtistsAsync() => lazyFactory.GetAllLazyArtistsAsync();

    public Task<LazyArtist?> GetArtistByIdAsync(int id) => lazyFactory.GetLazyArtistByIdAsync(id);

    public Task AddArtistAsync(Artist artist) => artistRepository.AddAsync(artist);

    public Task UpdateArtistAsync(Artist artist) => artistRepository.UpdateAsync(artist);

    public Task DeleteArtistAsync(int id) => artistRepository.DeleteAsync(id);
}

You can test it by adding this method:

public static async Task RunLazyLoadingProxyNaive()
    {
        await using var dbContext = new LazyLoadingProxyNaive.Context.MusicDbContext();
        var artistRepository = new LazyLoadingProxyNaive.Repositories.ArtistRepository(dbContext);
        var albumRepository = new LazyLoadingProxyNaive.Repositories.AlbumRepository(dbContext);
        var lazyFactory = new LazyFactory(artistRepository, albumRepository);
        var artistService = new LazyLoadingProxyNaive.Services.ArtistService(artistRepository, lazyFactory);
        var albumService = new LazyLoadingProxyNaive.Services.AlbumService(albumRepository);

        Console.WriteLine("All artists:");
        var artists = await artistService.GetAllArtistsAsync();
        foreach (var artist in artists)
        {
            var albums = await artist.Albums;
            List<string?> albumTitles;
            if (albums != null)
            {
                albumTitles = albums.Any() ? albums.Select(x => x.Title).ToList() : ["No albums"];
            }
            else
            {
                albumTitles = ["No albums"];
            }

            Console.WriteLine($"{artist.ArtistId}: {artist.Name}. Discography: {string.Join(", ", albumTitles)}");
        }

        // Add new artist
        var newArtist = new LazyLoadingProxyNaive.Models.Artist
        {
            Name = "EF Core Artist",
            Albums = new List<LazyLoadingProxyNaive.Models.Album>
                { new LazyLoadingProxyNaive.Models.Album { Title = "EF Core Album" } }
        };
        await artistService.AddArtistAsync(newArtist);
        Console.WriteLine($"Added artist with ID {newArtist.ArtistId}");

        // Update artist
        newArtist.Name = "Updated EF Core Artist";
        await artistService.UpdateArtistAsync(newArtist);
        Console.WriteLine("Updated artist.");

        // Get by ID
        var artistById = await artistService.GetArtistByIdAsync(newArtist.ArtistId);
        if (artistById?.Albums != null)
        {
            var albumsSingleArtist = await artistById.Albums;
            if (albumsSingleArtist != null)
            {
                var albums = albumsSingleArtist.Select(x => x.Title).ToList();
                Console.WriteLine(
                    $"Artist by ID: {artistById.ArtistId} - {artistById.Name} ({string.Join(", ", albums.Count > 0 ? albums : ["No albums"])})");

                //Delete album
                await albumService.DeleteAlbumAsync(albumsSingleArtist.First().AlbumId);
                artistById = await artistService.GetArtistByIdAsync(newArtist.ArtistId);
                if (artistById?.Albums != null) albums = (await artistById.Albums).Select(x => x.Title).ToList();
                Console.WriteLine(
                    $"Artist by ID: {artistById?.ArtistId} - {artistById?.Name} ({string.Join(", ", albums.Count > 0 ? albums : ["No albums"])})");
            }
        }

        // Delete artist
        await artistService.DeleteArtistAsync(newArtist.ArtistId);
        Console.WriteLine("Deleted artist.");

        Console.WriteLine("Done.");
    }

If you’re seeing the same result, let’s go over the pros and cons:

✅ Pros

No need for Include statements
Lazy loading happens on demand

❌ Cons

More complex implementation
Potential performance overhead

You might be wondering: Can this be simplified?
The answer is yes—there’s an alternative approach.

Microsoft.EntityFrameworkCore.Proxies

You’ll need to install the Microsoft.EntityFrameworkCore.Proxies package and make a small modification to your DbContext.

public class MusicDbContext : DbContext
{
    public DbSet<Artist> Artists { get; set; }
    public DbSet<Album> Albums { get; set; }

    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
    {
        optionsBuilder.UseSqlite("Data Source=chinook.db")
            .UseLazyLoadingProxies();
    }

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.Entity<Artist>(entity =>
        {
            entity.ToTable("artists");
            entity.HasKey(e => e.ArtistId);
            entity.Property(e => e.ArtistId).HasColumnName("ArtistId");
            entity.Property(e => e.Name).HasColumnName("Name").HasMaxLength(120);

            entity.HasMany(a => a.Albums)
                .WithOne(b => b.Artist)
                .HasForeignKey(b => b.ArtistId);
        });

        modelBuilder.Entity<Album>(entity =>
        {
            entity.ToTable("albums");
            entity.HasKey(e => e.AlbumId);
            entity.Property(e => e.AlbumId).HasColumnName("AlbumId");
            entity.Property(e => e.Title).HasColumnName("Title").HasMaxLength(160);
            entity.Property(e => e.ArtistId).HasColumnName("ArtistId");
        });
    }
}

You’ll also need to make a small change to your entities: any navigation properties should be marked as virtual.

public class Album
{
    public int AlbumId { get; set; }
    public string? Title { get; set; }
    public int ArtistId { get; set; }
    public virtual Artist? Artist { get; set; }
}

public class Artist
{
    public int ArtistId { get; set; }
    public string? Name { get; set; }
    public virtual List<Album>? Albums { get; set; }
}

The rest of the code remains the same as in the Repository approach. This package also uses proxies under the hood, so minimal changes are required.

To verify the setup:

    public static async Task RunLazyLoadingProxyPackage()
    {
        //init
        await using var dbContext = new LazyLoadingProxyPackage.Context.MusicDbContext();
        var artistRepository = new LazyLoadingProxyPackage.Repositories.ArtistRepository(dbContext);
        var albumRepository = new LazyLoadingProxyPackage.Repositories.AlbumRepository(dbContext);
        var artistService = new LazyLoadingProxyPackage.Services.ArtistService(artistRepository);
        var albumService = new LazyLoadingProxyPackage.Services.AlbumService(albumRepository);

        //get all artists
        Console.WriteLine("All artists:");
        var artists = await artistService.GetAllArtistsAsync();
        foreach (var artist in artists)
        {
            var albums = artist.Albums != null && artist.Albums.Any()
                ? artist.Albums.Select(x => x.Title).ToList()
                : ["No albums"];
            Console.WriteLine($"{artist.ArtistId}: {artist.Name}. Discography: {string.Join(", ", albums)}");
        }

        // Add new artist
        var newArtist = new LazyLoadingProxyPackage.Models.Artist
        {
            Name = "EF Core Artist",
            Albums = new List<LazyLoadingProxyPackage.Models.Album>
                { new LazyLoadingProxyPackage.Models.Album { Title = "EF Core Album" } }
        };
        await artistService.AddArtistAsync(newArtist);
        Console.WriteLine($"Added artist with ID {newArtist.ArtistId}");

        // Update artist
        newArtist.Name = "Updated EF Core Artist";
        await artistService.UpdateArtistAsync(newArtist);
        Console.WriteLine("Updated artist.");

        // Get by ID
        var artistById = await artistService.GetArtistByIdAsync(newArtist.ArtistId);
        if (artistById?.Albums != null)
        {
            var albums = artistById.Albums.Select(x => x.Title).ToList();
            Console.WriteLine(
                $"Artist by ID: {artistById.ArtistId} - {artistById.Name} ({string.Join(", ", albums.Count > 0 ? albums : ["No albums"])})");

            //Delete album
            await albumService.DeleteAlbumAsync(artistById.Albums.First().AlbumId);
            artistById = await artistService.GetArtistByIdAsync(newArtist.ArtistId);
            if (artistById?.Albums != null) albums = artistById.Albums.Select(x => x.Title).ToList();
            Console.WriteLine(
                $"Artist by ID: {artistById?.ArtistId} - {artistById?.Name} ({string.Join(", ", albums.Count > 0 ? albums : ["No albums"])})");
        }

        // Delete artist
        await artistService.DeleteArtistAsync(newArtist.ArtistId);
        Console.WriteLine("Deleted artist.");

        Console.WriteLine("Done.");
    }

This approach is simpler than the previous one but comes with a significant drawback: reduced performance. The performance impact stems from the use of generated proxy classes, which can introduce overhead.

Let’s summarize this approach:

✅ Pros

Simpler implementation
Supports lazy loading

❌ Cons

Lower performance due to proxy generation

Benchmark

Let's evaluate the performance of all four approaches.

As you can see, the last approach is the slowest because it uses a dynamic proxy.

Conclusion

When should you use these data access patterns?

Repository: This is the default and de facto standard approach for data access.
UnitOfWork: Use this pattern when working with multiple repositories, as it simplifies managing and coordinating access across them.
Custom Lazy Loading: Choose this if you need fine-grained control over data loading to optimize performance.
Lazy Loading Proxy Package: Ideal when dealing with many related data entities, helping improve performance by avoiding unnecessary loading of unused related data.

I hope you found this guide helpful and that it encourages you to implement similar solutions in your own projects.

For your convenience, the complete source code is available on my GitHub repository for reference and further exploration.

SergKorol / DesignPatterns

Design Patterns #7: From Chaos to Clarity with the State Pattern.

Serhii Korol — Wed, 14 May 2025 11:03:11 +0000

Hi! Today, we’re going to talk about managing state. In fact, even this article has a state — it started as an idea and is now evolving as I write it.

To explore the concept of state management, we’ll use a simple example and gradually implement the logic in code. Let’s begin with a naive approach, assuming you’ve never heard of the State pattern.

We’ll use a coffee vending machine as our example because it's intuitive and easy to follow.

Here’s a typical flow when you buy coffee:

The machine starts in a waiting-for-money state.
Once you insert money, it transitions to a has-money state.
You then select a beverage, moving it to a beverage-selected state.
Finally, the machine prepares and dispenses the drink, entering a dispensing state.

So, there are four basic states:

No money
Has money
Beverage selected
Dispensing beverage

However, things can get a bit more complex in real life.

For example:

The machine is waiting for money.
You insert some coins, and it moves to the has-money state.
You select a beverage, but it costs more than what you inserted.
The machine transitions back to the waiting-for-money state.
You insert more coins, and it returns to the has-money state.
You choose the same beverage again, but now it’s out of stock.
The machine switches to the out-of-stock state.
You select a different, available drink, and it enters the beverage-selected state.
You press the start button, the drink is prepared, and the machine transitions to the dispensing state.

Let’s now implement this logic using a naive approach to better understand how state management works without relying on the State pattern.

Naive approach

To implement this functionality, we only need an enum to represent the possible states and a class to manage the transitions between them. Since there are just four main states, the logic remains relatively simple.

At this point, I’m not aiming to build a highly realistic simulation—just a straightforward example to demonstrate how state management can be implemented.

public enum CoffeeMachineState
{
    NoMoneyState,
    HasMoneyState,
    BeverageSelectedState,
    OutOfStockState
}

The class initializes with a starting state and handles transitions between other states. However, as you can see, the implementation quickly becomes messy. It relies heavily on conditional logic, which negatively impacts performance, readability, and flexibility.

public class CoffeeMachine(int beverageCount)
{
    private CoffeeMachineState _currentState =
        beverageCount <= 0 ? CoffeeMachineState.OutOfStockState : CoffeeMachineState.NoMoneyState;

    private int BeverageCount { get; set; } = beverageCount;
    private decimal CurrentBalance { get; set; }
    private const decimal BeveragePrice = 1.50M;

    public void InsertMoney(decimal amount)
    {
        switch (_currentState)
        {
            case CoffeeMachineState.NoMoneyState:
                if (amount > 0)
                {
                    AddMoney(amount);
                    _currentState = CoffeeMachineState.HasMoneyState;
                }
                else
                {
                    Console.WriteLine("Please insert a valid amount of money");
                }

                break;

            case CoffeeMachineState.HasMoneyState:
                AddMoney(amount);
                break;

            case CoffeeMachineState.BeverageSelectedState:
                Console.WriteLine("Beverage already selected. Please wait for beverage to be dispensed.");
                break;

            case CoffeeMachineState.OutOfStockState:
                Console.WriteLine("Sorry, the machine is out of beverages. Returning your money.");
                break;
            default:
                throw new ArgumentOutOfRangeException();
        }
    }

    public void SelectBeverage()
    {
        switch (_currentState)
        {
            case CoffeeMachineState.NoMoneyState:
                Console.WriteLine("Please insert money first");
                break;

            case CoffeeMachineState.HasMoneyState:
                if (BeverageCount <= 0)
                {
                    Console.WriteLine("Sorry, out of beverages");
                    _currentState = CoffeeMachineState.OutOfStockState;
                    return;
                }

                if (CurrentBalance >= BeveragePrice)
                {
                    Console.WriteLine("Beverage selected!");
                    _currentState = CoffeeMachineState.BeverageSelectedState;
                }
                else
                {
                    Console.WriteLine(
                        $"Insufficient funds. Please insert more money. Current balance: ${CurrentBalance}, Beverage price: ${BeveragePrice}");
                }

                break;

            case CoffeeMachineState.BeverageSelectedState:
                Console.WriteLine("Beverage already selected. Please wait for beverage to be dispensed.");
                break;

            case CoffeeMachineState.OutOfStockState:
                Console.WriteLine("Sorry, the machine is out of beverages");
                break;
            default:
                throw new ArgumentOutOfRangeException();
        }
    }

    public void DispenseBeverage()
    {
        switch (_currentState)
        {
            case CoffeeMachineState.NoMoneyState:
                Console.WriteLine("Please insert money first");
                break;

            case CoffeeMachineState.HasMoneyState:
                Console.WriteLine("Please select a beverage first");
                break;

            case CoffeeMachineState.BeverageSelectedState:
                if (BeverageCount > 0)
                {
                    BeverageCount--;
                    Console.WriteLine("Beverage dispensed!");

                    decimal changeAmount = CurrentBalance - BeveragePrice;
                    if (changeAmount > 0)
                    {
                        Console.WriteLine($"Returning change: ${changeAmount}");
                    }

                    CurrentBalance = 0;

                    _currentState = BeverageCount <= 0
                        ? CoffeeMachineState.OutOfStockState
                        : CoffeeMachineState.NoMoneyState;
                }
                else
                {
                    Console.WriteLine("Sorry, out of beverages");
                    ReturnMoney();
                    _currentState = CoffeeMachineState.OutOfStockState;
                }

                break;

            case CoffeeMachineState.OutOfStockState:
                Console.WriteLine("Sorry, the machine is out of beverages");
                break;
            default:
                throw new ArgumentOutOfRangeException();
        }
    }

    public void CancelTransaction()
    {
        switch (_currentState)
        {
            case CoffeeMachineState.NoMoneyState:
                Console.WriteLine("No transaction to cancel");
                break;

            case CoffeeMachineState.HasMoneyState:
            case CoffeeMachineState.BeverageSelectedState:
                ReturnMoney();
                _currentState = CoffeeMachineState.NoMoneyState;
                break;

            case CoffeeMachineState.OutOfStockState:
                ReturnMoney();
                break;
            default:
                throw new ArgumentOutOfRangeException();
        }
    }

    private void AddMoney(decimal amount)
    {
        CurrentBalance += amount;
        Console.WriteLine($"Money added: ${amount}. Current balance: ${CurrentBalance}");
    }

    private void ReturnMoney()
    {
        if (CurrentBalance <= 0) return;
        Console.WriteLine($"Returning ${CurrentBalance} to customer");
        CurrentBalance = 0;
    }

    public string GetCurrentState()
    {
        return _currentState.ToString();
    }
}

Now, let's implement a usage scenario. The main idea is to simulate the following sequence of actions:

Set the available beverages.
Attempt to select a beverage with a zero balance.
Insert money and try selecting the beverage again.
Encounter insufficient funds.
Insert more money and select the beverage again.
Repeat the selection process.
Dispense the beverage.
Try selecting a beverage without any money.
Cancel a transaction with no money inserted.
Cancel a transaction after inserting money.
Set the stock of a beverage to zero.
Attempt to insert money when the selected beverage is out of stock.

public static void RunNaive()
    {
        Naive.CoffeeMachine coffeeMachine = new Naive.CoffeeMachine(5);

        // Try operations in NoMoney state
        Console.WriteLine("\n[NoMoneyState]");
        Console.WriteLine($"\nCurrent State: {coffeeMachine.GetCurrentState()}");
        coffeeMachine.SelectBeverage();

        // Insert money and move to HasMoney state
        Console.WriteLine("\n[Moving to HasMoneyState]");
        coffeeMachine.InsertMoney(1.00M);
        Console.WriteLine($"Current State: {coffeeMachine.GetCurrentState()}");

        // Insufficient funds
        coffeeMachine.SelectBeverage();

        // Add more money
        coffeeMachine.InsertMoney(1.00M);

        // Now select beverage to move to BeverageSelected state
        Console.WriteLine("\n[Moving to BeverageSelectedState]");
        coffeeMachine.SelectBeverage();
        Console.WriteLine($"Current State: {coffeeMachine.GetCurrentState()}");

        // Try to select again or insert money
        coffeeMachine.SelectBeverage();
        coffeeMachine.InsertMoney(0.50M);

        // Dispense beverage and go back to NoMoney state
        Console.WriteLine("\n[Dispensing Beverage]");
        coffeeMachine.DispenseBeverage();
        Console.WriteLine($"Current State: {coffeeMachine.GetCurrentState()}");

        // We're back in NoMoney state, try operations
        Console.WriteLine("\n[Back to NoMoneyState]");
        coffeeMachine.SelectBeverage();

        // Try cancel transaction
        Console.WriteLine("\n[Cancel transaction from different states]");
        coffeeMachine.CancelTransaction();
        coffeeMachine.InsertMoney(2.00M);
        Console.WriteLine($"Current State: {coffeeMachine.GetCurrentState()}");
        coffeeMachine.CancelTransaction();
        Console.WriteLine($"Current State: {coffeeMachine.GetCurrentState()}");

        // Create a vending machine with 0 beverages to demonstrate OutOfStock state
        Console.WriteLine("\n[Out Of Stock]");
        Naive.CoffeeMachine emptyMachine = new Naive.CoffeeMachine(0);
        Console.WriteLine($"Current State: {emptyMachine.GetCurrentState()}");
        emptyMachine.InsertMoney(1.00M);
    }

Let's check this out.

[NoMoneyState]

Current State: NoMoneyState
Please insert money first

[Moving to HasMoneyState]
Money added: $1,00. Current balance: $1,00
Current State: HasMoneyState
Insufficient funds. Please insert more money. Current balance: $1,00, Beverage price: $1,50
Money added: $1,00. Current balance: $2,00

[Moving to BeverageSelectedState]
Beverage selected!
Current State: BeverageSelectedState
Beverage already selected. Please wait for beverage to be dispensed.
Beverage already selected. Please wait for beverage to be dispensed.

[Dispensing Beverage]
Beverage dispensed!
Returning change: $0,50
Current State: NoMoneyState

[Back to NoMoneyState]
Please insert money first

[Cancel transaction from different states]
No transaction to cancel
Money added: $2,00. Current balance: $2,00
Current State: HasMoneyState
Returning $2,00 to customer
Current State: NoMoneyState

[Out Of Stock]
Current State: OutOfStockState
Sorry, the machine is out of beverages. Returning your money.

Process finished with exit code 0.

The main drawback of this approach is that adding a new state, such as an "in-progress" state where the machine is preparing the beverage, requires modifying the code in multiple places. As the complexity of the scenario increases beyond a simple coffee machine, managing these changes becomes increasingly difficult and error-prone.

Fortunately, there’s a better solution. Let’s take a look at it.

State Pattern Approach

In this approach, each state is implemented as a class that inherits from a common abstraction. State transitions and behaviors are encapsulated within dedicated methods, making it easier to manage and extend the system. This design allows each state to handle its own logic and define how and when transitions to other states occur.

public interface ICoffeeMachineState
{
    void InsertMoney(decimal amount);
    void SelectBeverage();
    void DispenseBeverage();
    void CancelTransaction();
}

Each state is represented by a class that implements a common interface. These classes define the specific behavior for each action relevant to their state.

public class BeverageSelectedState(CoffeeMachine coffeeMachine) : ICoffeeMachineState
{
    private const decimal BeveragePrice = 1.50M;

    public void InsertMoney(decimal amount)
    {
        Console.WriteLine("Beverage already selected. Please wait for beverage to be dispensed.");
    }

    public void SelectBeverage()
    {
        Console.WriteLine("Beverage already selected. Please wait for beverage to be dispensed.");
    }

    public void DispenseBeverage()
    {
        if (coffeeMachine.BeverageCount > 0)
        {
            coffeeMachine.DecrementBeverageCount();
            Console.WriteLine("Beverage dispensed!");

            decimal changeAmount = coffeeMachine.CurrentBalance - BeveragePrice;
            if (changeAmount > 0)
            {
                Console.WriteLine($"Returning change: ${changeAmount}");
            }

            coffeeMachine.SetState(new NoMoneyState(coffeeMachine));
            coffeeMachine.CurrentBalance = 0;
        }
        else
        {
            Console.WriteLine("Sorry, out of beverages");
            coffeeMachine.ReturnMoney();
            coffeeMachine.SetState(new NoMoneyState(coffeeMachine));
        }
    }

    public void CancelTransaction()
    {
        coffeeMachine.ReturnMoney();
        coffeeMachine.SetState(new NoMoneyState(coffeeMachine));
    }
}

public class HasMoneyState(CoffeeMachine coffeeMachine) : ICoffeeMachineState
{
    private const decimal BeveragePrice = 1.50M;

    public void InsertMoney(decimal amount)
    {
        coffeeMachine.AddMoney(amount);
    }

    public void SelectBeverage()
    {
        if (coffeeMachine.BeverageCount <= 0)
        {
            Console.WriteLine("Sorry, out of beverages");
            return;
        }

        if (coffeeMachine.CurrentBalance >= BeveragePrice)
        {
            Console.WriteLine("Beverage selected!");
            coffeeMachine.SetState(new BeverageSelectedState(coffeeMachine));
        }
        else
        {
            Console.WriteLine(
                $"Insufficient funds. Please insert more money. Current balance: ${coffeeMachine.CurrentBalance}, Beverage price: ${BeveragePrice}");
        }
    }

    public void DispenseBeverage()
    {
        Console.WriteLine("Please select a beverage first");
    }

    public void CancelTransaction()
    {
        coffeeMachine.ReturnMoney();
        coffeeMachine.SetState(new NoMoneyState(coffeeMachine));
    }
}

public class NoMoneyState(CoffeeMachine coffeeMachine) : ICoffeeMachineState
{
    public void InsertMoney(decimal amount)
    {
        if (amount > 0)
        {
            coffeeMachine.AddMoney(amount);
            coffeeMachine.SetState(new HasMoneyState(coffeeMachine));
        }
        else
        {
            Console.WriteLine("Please insert a valid amount of money");
        }
    }

    public void SelectBeverage()
    {
        Console.WriteLine("Please insert money first");
    }

    public void DispenseBeverage()
    {
        Console.WriteLine("Please insert money first");
    }

    public void CancelTransaction()
    {
        Console.WriteLine("No transaction to cancel");
    }
}

public class OutOfStockState(CoffeeMachine coffeeMachine) : ICoffeeMachineState
{
    public void InsertMoney(decimal amount)
    {
        Console.WriteLine("Sorry, the machine is out of beverages. Returning your money.");
    }

    public void SelectBeverage()
    {
        Console.WriteLine("Sorry, the machine is out of beverages");
    }

    public void DispenseBeverage()
    {
        Console.WriteLine("Sorry, the machine is out of beverages");
    }

    public void CancelTransaction()
    {
        coffeeMachine.ReturnMoney();
    }
}

Let’s take a look at the NoMoneyState class. This state checks the current balance, and if it's greater than zero, it transitions to a different state. It also defines how the machine should respond to actions that aren't valid in this state, such as trying to select a beverage without inserting money.

The same principle applies to the other state classes, each of which defines its own valid transitions and behaviors. Since we have four states, we should create four corresponding classes.

The main logic for managing the balance, handling beverage stock, and switching between states remains in a central context class, just like in the previous approach. However, this version is much cleaner, more organized, and easier to maintain.

public class CoffeeMachine
{
    private ICoffeeMachineState _state;

    public int BeverageCount { get; set; }
    public decimal CurrentBalance { get; internal set; }

    public CoffeeMachine(int beverageCount)
    {
        if (beverageCount <= 0)
        {
            _state = new OutOfStockState(this);
        }
        else
        {
            _state = new NoMoneyState(this);
        }

        BeverageCount = beverageCount;
        CurrentBalance = 0;
    }

    public void SetState(ICoffeeMachineState state)
    {
        _state = state;
    }

    public void InsertMoney(decimal amount)
    {
        _state.InsertMoney(amount);
    }

    public void SelectBeverage()
    {
        _state.SelectBeverage();
    }

    public void DispenseBeverage()
    {
        _state.DispenseBeverage();
    }

    public void CancelTransaction()
    {
        _state.CancelTransaction();
    }

    public void AddMoney(decimal amount)
    {
        CurrentBalance += amount;
        Console.WriteLine($"Money added: ${amount}. Current balance: ${CurrentBalance}");
    }

    public void ReturnMoney()
    {
        Console.WriteLine($"Returning ${CurrentBalance} to customer");
        CurrentBalance = 0;
    }

    public void DecrementBeverageCount()
    {
        if (BeverageCount > 0)
        {
            BeverageCount--;
        }
    }

    public string GetCurrentState()
    {
        return _state.GetType().Name;
    }
}

The usage scenario remains the same, with the only difference being that each state-specific behavior is now handled by the appropriate class.

public static void RunState()
    {
        State.CoffeeMachine coffeeMachine = new State.CoffeeMachine(5);

        // Try operations in NoMoneyState
        Console.WriteLine("\n[NoMoneyState]");
        Console.WriteLine($"\nCurrent State: {coffeeMachine.GetCurrentState()}");
        coffeeMachine.SelectBeverage(); // Should fail

        // Insert money and move to HasMoneyState
        Console.WriteLine("\n[Moving to HasMoneyState]");
        coffeeMachine.InsertMoney(1.00M);
        Console.WriteLine($"\nCurrent State: {coffeeMachine.GetCurrentState()}");

        // Insufficient funds
        coffeeMachine.SelectBeverage();

        // Add more money
        coffeeMachine.InsertMoney(1.00M);

        // Now select beverage to move to BeverageSelectedState
        Console.WriteLine("\n[Moving to BeverageSelectedState]");
        coffeeMachine.SelectBeverage();
        Console.WriteLine($"Current State: {coffeeMachine.GetCurrentState()}");

        // Try to select again or insert money
        coffeeMachine.SelectBeverage();
        coffeeMachine.InsertMoney(0.50M);

        // Dispense beverage and go back to NoMoneyState
        Console.WriteLine("\n[Dispensing Beverage]");
        coffeeMachine.DispenseBeverage();
        Console.WriteLine($"Current State: {coffeeMachine.GetCurrentState()}");

        // We're back in NoMoneyState, try operations
        Console.WriteLine("\n[Back to NoMoneyState]");
        coffeeMachine.SelectBeverage();

        // Try cancel transaction
        Console.WriteLine("\n[Cancel transaction from different states]");
        coffeeMachine.CancelTransaction();
        coffeeMachine.InsertMoney(2.00M);
        Console.WriteLine($"Current State: {coffeeMachine.GetCurrentState()}");
        coffeeMachine.CancelTransaction();
        Console.WriteLine($"Current State: {coffeeMachine.GetCurrentState()}");

        Console.WriteLine("\n[Out Of Stock]");
        State.CoffeeMachine emptyMachine = new State.CoffeeMachine(0);
        Console.WriteLine($"Current State: {emptyMachine.GetCurrentState()}");
        emptyMachine.InsertMoney(1.00M);
    }

Check this out also.

[NoMoneyState]

Current State: NoMoneyState
Please insert money first

[Moving to HasMoneyState]
Money added: $1,00. Current balance: $1,00

Current State: HasMoneyState
Insufficient funds. Please insert more money. Current balance: $1,00, Beverage price: $1,50
Money added: $1,00. Current balance: $2,00

[Moving to BeverageSelectedState]
Beverage selected!
Current State: BeverageSelectedState
Beverage already selected. Please wait for beverage to be dispensed.
Beverage already selected. Please wait for beverage to be dispensed.

[Dispensing Beverage]
Beverage dispensed!
Returning change: $0,50
Current State: NoMoneyState

[Back to NoMoneyState]
Please insert money first

[Cancel transaction from different states]
No transaction to cancel
Money added: $2,00. Current balance: $2,00
Current State: HasMoneyState
Returning $2,00 to customer
Current State: NoMoneyState

[Out Of Stock]
Current State: OutOfStockState
Sorry, the machine is out of beverages. Returning your money.

Process finished with exit code 0.

As you can see, the end result is the same. However, this approach requires creating more classes. So, how does that impact performance? Let’s find out.

Benchmark

Let’s test this using DotNetBenchmark.

As you can see, the naive approach performs significantly slower. And this is with a simple scenario. In more complex scenarios, it will likely perform even worse due to the numerous conditions and logic checks.

Conclusion

The naive approach may be acceptable for small projects. However, for larger and more complex applications, I highly recommend adopting the State pattern. It offers significant improvements in flexibility, extensibility, readability, and performance.

Thank you for reading! I hope you found this article helpful. See you next time, and happy coding!

You can find the source code for this example here.

Design Patterns #6: Filtering Made Elegant with the Specification Pattern

Serhii Korol — Wed, 07 May 2025 10:53:02 +0000

Hi! Today, I want to talk about something we do almost every day as developers: fetching data. Nearly every project involves a database, and rarely do we retrieve all the data - we usually need to apply filters.

For simple applications with straightforward data structures, filtering with LINQ works just fine. But as the application grows, things get more complex. Data models become richer, queries more intricate, and filtering logic harder to manage and reuse.

In most cases, we use the Repository pattern, join related entities, and apply various filtering conditions. In this article, I’ll start with a naive implementation and show you how we can make it more robust and maintainable.

Let’s dive in.

The Naive Implementation

Let’s start by implementing a simple filtering mechanism using a basic repository.

Imagine we’re working with a Customer entity. We’ll begin by defining a straightforward model and see how we might typically filter data from the repository.

public record Customer(int Id, string Name, bool IsActive, decimal TotalPurchases)
{
    public string Name { get; init; } = Name ?? throw new ArgumentNullException(nameof(Name));
    public bool IsActive { get; set; } = IsActive;

    public override string ToString() =>
        $"ID: {Id}, Name: {Name}, Active: {IsActive}, Purchases: {TotalPurchases:C}";
}

The next step is to simulate a data repository and apply basic filtering to retrieve the relevant data.

public class LinqWayCustomerService
{
    private readonly IEnumerable<Customer> _customers =
    [
        new(1, "Alice", true, 1500m),
        new(2, "Bob", false, 800m),
        new(3, "Charlie", true, 200m),
        new(4, "David", true, 1200m),
        new(5, "Eve", false, 2500m)
    ];

    const decimal PremiumThreshold = 1000m;

    public IEnumerable<Customer> GetActiveCustomers()
        => _customers.Where(x => x.IsActive);

    public IEnumerable<Customer> GetPremiumCustomers()
        => _customers.Where(x => x.TotalPurchases >= PremiumThreshold);

    public IEnumerable<Customer> GetActiveAndPremiumCustomers()
        => _customers.Where(x => x is { IsActive: true, TotalPurchases: >= PremiumThreshold });

    public IEnumerable<Customer> GetActiveOrPremiumCustomers()
        => _customers.Where(x => x.IsActive || x.TotalPurchases >= PremiumThreshold);

    public IEnumerable<Customer> GetInactiveCustomers()
        => _customers.Where(x => !x.IsActive);

    public IEnumerable<Customer> GetInactiveAndPremiumCustomers()
        => _customers.Where(x => x is { IsActive: false, TotalPurchases: >= PremiumThreshold });

    public IEnumerable<Customer> GetInactiveOrPremiumCustomers()
        => _customers.Where(x => !x.IsActive || x.TotalPurchases >= PremiumThreshold);

    public bool CheckIsActivePremiumCustomerByName(string name)
    {
        Customer? customer = _customers.FirstOrDefault(x => x.Name == name);

        return customer is { IsActive: true, TotalPurchases: >= PremiumThreshold };
    }
}

Here, we retrieve data based on a single condition and then combine multiple conditions.
To run this, let’s create an additional method:

public class Program
{
    private const string CustomerName = "Bob";

    public static void Main()
    {
        RunLinqWay();
    }

    public static void RunLinqWay()
    {
        var linq = new LinqWayCustomerService();

        Print(linq.GetActiveCustomers());
        Print(linq.GetPremiumCustomers());
        Print(linq.GetActiveAndPremiumCustomers());
        Print(linq.GetActiveOrPremiumCustomers());
        Print(linq.GetInactiveCustomers());
        Print(linq.GetInactiveAndPremiumCustomers());
        Print(linq.GetInactiveOrPremiumCustomers());
        Print(CustomerName, linq.CheckIsActivePremiumCustomerByName(CustomerName));
    }

    private static void Print<T>(IEnumerable<T> customers) where T : class
    {
        foreach (var customer in customers)
        {
            Console.WriteLine(customer.ToString());
        }

        Console.WriteLine("\n");
    }

    private static void Print(string title, bool isActivePremiumCustomer)
    {
        Console.WriteLine($"{title} is active premium customer: {isActivePremiumCustomer}");
    }
}

If you run this code, you’ll see the following result:

ID: 1, Name: Alice, Active: True, Purchases: 1 500,00 UAH
ID: 3, Name: Charlie, Active: True, Purchases: 200,00 UAH
ID: 4, Name: David, Active: True, Purchases: 1 200,00 UAH


ID: 1, Name: Alice, Active: True, Purchases: 1 500,00 UAH
ID: 4, Name: David, Active: True, Purchases: 1 200,00 UAH
ID: 5, Name: Eve, Active: False, Purchases: 2 500,00 UAH


ID: 1, Name: Alice, Active: True, Purchases: 1 500,00 UAH
ID: 4, Name: David, Active: True, Purchases: 1 200,00 UAH


ID: 1, Name: Alice, Active: True, Purchases: 1 500,00 UAH
ID: 3, Name: Charlie, Active: True, Purchases: 200,00 UAH
ID: 4, Name: David, Active: True, Purchases: 1 200,00 UAH
ID: 5, Name: Eve, Active: False, Purchases: 2 500,00 UAH


ID: 2, Name: Bob, Active: False, Purchases: 800,00 UAH
ID: 5, Name: Eve, Active: False, Purchases: 2 500,00 UAH


ID: 5, Name: Eve, Active: False, Purchases: 2 500,00 UAH


ID: 1, Name: Alice, Active: True, Purchases: 1 500,00 UAH
ID: 2, Name: Bob, Active: False, Purchases: 800,00 UAH
ID: 4, Name: David, Active: True, Purchases: 1 200,00 UAH
ID: 5, Name: Eve, Active: False, Purchases: 2 500,00 UAH


Bob is active premium customer: False

Process finished with exit code 0.

This is a very basic implementation—one you’ve likely used many times when retrieving data. Whenever you need a new filter, you create a new method and write a new LINQ query. For simple scenarios, this approach works just fine. But as your queries grow more complex, it becomes harder to manage, and that’s where improving and reusing existing logic can really pay off.

Enhanced Implementation

The core idea of this approach is to create reusable static extension methods. These methods encapsulate filtering logic and can be easily composed with other LINQ queries, making your code cleaner and more maintainable.

public static class CustomerFilteringExtensions
{
    public static IEnumerable<Customer> FilterActive(this IEnumerable<Customer> customers)
        => customers.Where(c => c.IsActive);

    public static IEnumerable<Customer> FilterInactive(this IEnumerable<Customer> customers)
        => customers.Where(c => !c.IsActive);

    public static IEnumerable<Customer> FilterPremium(this IEnumerable<Customer> customers,
        decimal minimumPurchaseAmount)
        => customers.Where(c => c.TotalPurchases >= minimumPurchaseAmount);

    public static IEnumerable<Customer> FilterActiveOrPremium(this IEnumerable<Customer> customers, decimal minAmount)
        => customers.Where(c => c.IsActive || c.TotalPurchases >= minAmount);

    public static IEnumerable<Customer> FilterInactiveOrPremium(this IEnumerable<Customer> customers, decimal minAmount)
        => customers.Where(c => !c.IsActive || c.TotalPurchases >= minAmount);

    public static bool CheckActivePremiumCustomer(this IEnumerable<Customer> customers, string name, decimal minAmount)
    {
        Customer? customer = customers.FirstOrDefault(x => x.Name == name);

        return customer is { IsActive: true } && customer.TotalPurchases >= minAmount;
    }
}

This keeps the service code cleaner by avoiding direct access to filtering logic or raw data queries.

public class ExpressionWayCustomerService
{
    private readonly IEnumerable<Customer> _customers =
    [
        new(1, "Alice", true, 1500m),
        new(2, "Bob", false, 800m),
        new(3, "Charlie", true, 200m),
        new(4, "David", true, 1200m),
        new(5, "Eve", false, 2500m)
    ];

    const decimal PremiumThreshold = 1000m;

    public IEnumerable<Customer> GetActiveCustomers()
        => _customers.FilterActive();

    public IEnumerable<Customer> GetPremiumCustomers()
        => _customers.FilterPremium(PremiumThreshold);

    public IEnumerable<Customer> GetActiveAndPremiumCustomers()
        => _customers.FilterActive().FilterPremium(PremiumThreshold);

    public IEnumerable<Customer> GetActiveOrPremiumCustomers()
        => _customers.FilterActiveOrPremium(PremiumThreshold);

    public IEnumerable<Customer> GetInactiveCustomers()
        => _customers.FilterInactive();

    public IEnumerable<Customer> GetInactiveAndPremiumCustomers()
        => _customers.FilterInactive().FilterPremium(PremiumThreshold);

    public IEnumerable<Customer> GetInactiveOrPremiumCustomers()
        => _customers.FilterInactiveOrPremium(PremiumThreshold);

    public bool CheckIsActivePremiumCustomerByName(string name)
        => _customers.CheckActivePremiumCustomer(name, PremiumThreshold);
}

This approach is not only more efficient than the previous one but also requires less code to implement.

To test it, add the following method:

    public static void RunExpressionWay()
    {
        var expression = new ExpressionWayCustomerService();

        Print(expression.GetActiveCustomers());
        Print(expression.GetPremiumCustomers());
        Print(expression.GetActiveAndPremiumCustomers());
        Print(expression.GetActiveOrPremiumCustomers());
        // Print(expression.GetActiveAndPremiumCustomersWithActivePayments());
        Print(expression.GetInactiveCustomers());
        Print(expression.GetInactiveAndPremiumCustomers());
        Print(expression.GetInactiveOrPremiumCustomers());
        // Print(expression.GetInactiveAndPremiumCustomersWithInactivePayments());
        // Print(expression.GetCustomersWithoutPayments());
        Print(CustomerName, expression.CheckIsActivePremiumCustomerByName(CustomerName));
    }

The result should match the output of the previous approach.

This method allows you to extract and organize query logic into separate methods, which improves readability. However, it may come with a performance cost.

If you're working with complex filtering logic, I recommend using the Specification pattern for a more scalable and maintainable solution.

Specification Implementation

This approach builds on the same principle as the previous ones, breaking down queries into smaller, reusable blocks. However, it leverages expressions and delegates to create a more flexible solution. While this approach results in a larger codebase compared to the previous two, it offers greater maintainability and scalability. In this case, each query is represented as a distinct class that inherits from a Specification base class. Let’s dive into the details.

public interface ISpecification<T>
{
    bool IsSatisfiedBy(T entity);
    Expression<Func<T, bool>> ToExpression();
}

public abstract class Specification<T> : ISpecification<T>
{
    private Func<T, bool>? _compiled;

    public abstract Expression<Func<T, bool>> ToExpression();

    public Func<T, bool> GetCompiledExpression()
        => _compiled ??= ToExpression().Compile();

    public virtual bool IsSatisfiedBy(T entity)
        => GetCompiledExpression()(entity);

    public static Specification<T> operator &(Specification<T> left, ISpecification<T> right)
        => new AndSpecification<T>(left, right);

    public static Specification<T> operator |(Specification<T> left, ISpecification<T> right)
        => new OrSpecification<T>(left, right);

    public static Specification<T> operator !(Specification<T> spec)
        => new NotSpecification<T>(spec);

    public static implicit operator Expression<Func<T, bool>>(Specification<T> spec)
        => spec.ToExpression();
}

The base class compiles expressions and overrides operators. While it’s possible to use methods instead of operators, I recommend using this approach for better performance.

As you can see, the three primary conditional operators are implemented here. Each operator creates a new instance of the class, enabling more efficient and flexible query composition.

public class AndSpecification<T>(ISpecification<T> left, ISpecification<T> right) : Specification<T>
{
    private readonly ISpecification<T> _left = left ?? throw new ArgumentNullException(nameof(left));
    private readonly ISpecification<T> _right = right ?? throw new ArgumentNullException(nameof(right));

    public override Expression<Func<T, bool>> ToExpression() =>
        ExpressionCombiner.CombineAnd(_left.ToExpression(), _right.ToExpression());

    public override bool IsSatisfiedBy(T entity) => _left.IsSatisfiedBy(entity) && _right.IsSatisfiedBy(entity);
}

public class OrSpecification<T>(ISpecification<T> left, ISpecification<T> right) : Specification<T>
{
    private readonly ISpecification<T> _left = left ?? throw new ArgumentNullException(nameof(left));
    private readonly ISpecification<T> _right = right ?? throw new ArgumentNullException(nameof(right));

    public override Expression<Func<T, bool>> ToExpression() =>
        ExpressionCombiner.CombineOr(_left.ToExpression(), _right.ToExpression());

    public override bool IsSatisfiedBy(T entity) => _left.IsSatisfiedBy(entity) || _right.IsSatisfiedBy(entity);
}

public class NotSpecification<T>(ISpecification<T> inner) : Specification<T>
{
    private readonly ISpecification<T> _inner = inner ?? throw new ArgumentNullException(nameof(inner));
    public override Expression<Func<T, bool>> ToExpression() => ExpressionCombiner.CombineNot(_inner.ToExpression());
    public override bool IsSatisfiedBy(T entity) => !_inner.IsSatisfiedBy(entity);
}

These classes are designed to be combined with other, more specific queries. They are generic, allowing them to work with different entities and making the approach highly reusable.

Additionally, you’ll need to include these helper methods for setting up, combining expressions, and handling parameters:

internal static class ExpressionCombiner
{
    public static Expression<Func<T, bool>> CombineAnd<T>(Expression<Func<T, bool>> left,
        Expression<Func<T, bool>> right)
    {
        var param = Expression.Parameter(typeof(T));
        var body = Expression.AndAlso(
            ParameterReplacer.Replace(left.Body, left.Parameters[0], param),
            ParameterReplacer.Replace(right.Body, right.Parameters[0], param));
        return Expression.Lambda<Func<T, bool>>(body, param);
    }

    public static Expression<Func<T, bool>> CombineOr<T>(Expression<Func<T, bool>> left,
        Expression<Func<T, bool>> right)
    {
        var param = Expression.Parameter(typeof(T));
        var body = Expression.OrElse(
            ParameterReplacer.Replace(left.Body, left.Parameters[0], param),
            ParameterReplacer.Replace(right.Body, right.Parameters[0], param));
        return Expression.Lambda<Func<T, bool>>(body, param);
    }

    public static Expression<Func<T, bool>> CombineNot<T>(Expression<Func<T, bool>> expression)
    {
        var param = expression.Parameters[0];
        var body = Expression.Not(expression.Body);
        return Expression.Lambda<Func<T, bool>>(body, param);
    }
}

internal class ParameterReplacer : ExpressionVisitor
{
    private readonly ParameterExpression _source;
    private readonly ParameterExpression _target;

    private ParameterReplacer(ParameterExpression source, ParameterExpression target)
    {
        _source = source;
        _target = target;
    }

    public static Expression Replace(Expression expression, ParameterExpression source, ParameterExpression target)
        => new ParameterReplacer(source, target).Visit(expression);

    protected override Expression VisitParameter(ParameterExpression node)
        => node == _source ? _target : base.VisitParameter(node);
}

When filtering a specific entity, you should create a new class for the query and explicitly define the entity type within it.

public class ActiveCustomerSpecification : Specification<Customer>
{
    public override Expression<Func<Customer, bool>> ToExpression() => customer => customer.IsActive;
}

public class PremiumCustomerSpecification(decimal threshold = 1000m) : Specification<Customer>
{
    public override Expression<Func<Customer, bool>> ToExpression() => customer => customer.TotalPurchases >= threshold;
}

public class CustomerNameSpecification : Specification<Customer>
{
    public string Name { get; set; } = string.Empty;
    public override Expression<Func<Customer, bool>> ToExpression() => customer => customer.Name == Name;
}

In the service, we use straightforward LINQ queries combined with specifications and delegates. There’s one important detail: you should always use static fields to ensure optimal performance. When declaring an expression, it needs to be compiled, and this compilation should only occur once to avoid unnecessary overhead.

public class SpecificationWayCustomerService
{
    private readonly IEnumerable<Customer> _customers =
    [
        new(1, "Alice", true, 1500m),
        new(2, "Bob", false, 800m),
        new(3, "Charlie", true, 200m),
        new(4, "David", true, 1200m),
        new(5, "Eve", false, 2500m)
    ];

    private static readonly ActiveCustomerSpecification ActiveSpec = new();
    private static readonly PremiumCustomerSpecification PremiumSpec = new();

    private static readonly CustomerNameSpecification NameSpec = new();

    private static readonly Func<Customer, bool> ActiveFunc = ActiveSpec.GetCompiledExpression();
    private static readonly Func<Customer, bool> PremiumFunc = PremiumSpec.GetCompiledExpression();

    private static readonly Func<Customer, bool> ActiveAndPremiumFunc =
        (ActiveSpec & PremiumSpec).GetCompiledExpression();

    private static readonly Func<Customer, bool> ActiveOrPremiumFunc =
        (ActiveSpec | PremiumSpec).GetCompiledExpression();

    private static readonly Func<Customer, bool> InactiveFunc = (!ActiveSpec).GetCompiledExpression();

    private static readonly Func<Customer, bool> InactiveAndPremiumFunc =
        (!ActiveSpec & PremiumSpec).GetCompiledExpression();

    private static readonly Func<Customer, bool> InactiveOrPremiumFunc =
        (!ActiveSpec | PremiumSpec).GetCompiledExpression();

    public IEnumerable<Customer> GetActiveCustomers() => _customers.Where(ActiveFunc);
    public IEnumerable<Customer> GetPremiumCustomers() => _customers.Where(PremiumFunc);
    public IEnumerable<Customer> GetActiveAndPremiumCustomers() => _customers.Where(ActiveAndPremiumFunc);
    public IEnumerable<Customer> GetActiveOrPremiumCustomers() => _customers.Where(ActiveOrPremiumFunc);
    public IEnumerable<Customer> GetInactiveCustomers() => _customers.Where(InactiveFunc);
    public IEnumerable<Customer> GetInactiveAndPremiumCustomers() => _customers.Where(InactiveAndPremiumFunc);
    public IEnumerable<Customer> GetInactiveOrPremiumCustomers() => _customers.Where(InactiveOrPremiumFunc);

    public bool CheckIsActivePremiumCustomerByName(string name)
    {
        NameSpec.Name = name;
        var combinedSpec = NameSpec & ActiveSpec & PremiumSpec;
        return _customers.Any(combinedSpec.IsSatisfiedBy);
    }
}

Now, let’s take a look at this and add the necessary code to run the service:

    public static void RunSpecificationWay()
    {
        var specification = new SpecificationWayCustomerService();

        Print(specification.GetActiveCustomers());
        Print(specification.GetPremiumCustomers());
        Print(specification.GetActiveAndPremiumCustomers());
        Print(specification.GetActiveOrPremiumCustomers());
        Print(specification.GetInactiveCustomers());
        Print(specification.GetInactiveAndPremiumCustomers());
        Print(specification.GetInactiveOrPremiumCustomers());
        Print(CustomerName, specification.CheckIsActivePremiumCustomerByName(CustomerName));
    }

You should get the same result.
As you can see, this approach has a larger codebase and is more complex. It also comes with a performance cost. So, why use it when you can implement the same logic with less code and complexity?

Before answering that, let’s first compare the performance of each approach.

Performance Comparison

I measured the performance using the DotNetBenchmark library to provide accurate and consistent results.

As you can see, the Specification approach performs similarly to the expression-based approach, which has a smaller codebase. However, the straightforward LINQ approach is faster and simpler. Below, I’ll explain how the Specification pattern can still be beneficial in certain scenarios.

More Complex Scenario

In real-world applications, you often work with multiple entities that are part of a more complex structure. To demonstrate this, I’ll extend our data repository to include a related entity.

public record Customer(int Id, string Name, bool IsActive, decimal TotalPurchases, IEnumerable<Payment>? Payments)
{
    public string Name { get; init; } = Name ?? throw new ArgumentNullException(nameof(Name));
    public bool IsActive { get; set; } = IsActive;

    public override string ToString() =>
        $"ID: {Id}, Name: {Name}, Active: {IsActive}, Purchases: {TotalPurchases:C}, Payments: {(Payments != null ? string.Join(", ", Payments.Select(p => $"{p.Method}({(p.IsActive ? "Active" : "Inactive")})")) : "None")}";
}

public record Payment(string Method, bool IsActive);

This entity contains a collection of related entities. Now, I need to filter the data based on this related information. Please update the service accordingly:

public class LinqWayCustomerService
{
    private readonly IEnumerable<Customer> _customers =
    [
        new(1, "Alice", true, 1500m, [new("Card", true), new("PayPal", false), new("Crypto", true)]),
        new(2, "Bob", false, 800m, null),
        new(3, "Charlie", true, 200m, [new("Card", false), new("PayPal", false), new("Crypto", true)]),
        new(4, "David", true, 1200m, null),
        new(5, "Eve", false, 2500m, [new("Card", false), new("PayPal", false), new("Crypto", false)])
    ];

    const decimal PremiumThreshold = 1000m;

    public IEnumerable<Customer> GetActiveCustomers()
        => _customers.Where(x => x.IsActive);

    public IEnumerable<Customer> GetPremiumCustomers()
        => _customers.Where(x => x.TotalPurchases >= PremiumThreshold);

    public IEnumerable<Customer> GetActiveAndPremiumCustomers()
        => _customers.Where(x => x is { IsActive: true, TotalPurchases: >= PremiumThreshold });

    public IEnumerable<Customer> GetActiveOrPremiumCustomers()
        => _customers.Where(x => x.IsActive || x.TotalPurchases >= PremiumThreshold);

    public IEnumerable<Customer> GetInactiveCustomers()
        => _customers.Where(x => !x.IsActive);

    public IEnumerable<Customer> GetInactiveAndPremiumCustomers()
        => _customers.Where(x => x is { IsActive: false, TotalPurchases: >= PremiumThreshold });

    public IEnumerable<Customer> GetInactiveOrPremiumCustomers()
        => _customers.Where(x => !x.IsActive || x.TotalPurchases >= PremiumThreshold);

    public IEnumerable<Customer> GetActiveAndPremiumCustomersWithActivePayments()
        => _customers.Where(x =>
            x is { IsActive: true, TotalPurchases: >= PremiumThreshold, Payments: not null } &&
            x.Payments.Any(y => y is { IsActive: true, Method: "Card" } || y.Method == "Crypto"));

    public IEnumerable<Customer> GetInactiveAndPremiumCustomersWithInactivePayments()
        => _customers.Where(x =>
            x is { IsActive: false, TotalPurchases: >= PremiumThreshold, Payments: not null } &&
            x.Payments.Any(y => y is { IsActive: false }));

    public IEnumerable<Customer> GetCustomersWithoutPayments()
        => _customers.Where(x => x is { Payments: null });

    public bool CheckIsActivePremiumCustomerByName(string name)
    {
        Customer? customer = _customers.FirstOrDefault(x => x.Name == name);

        return customer is { IsActive: true, TotalPurchases: >= PremiumThreshold };
    }
}

As you can see, the queries have become more complex with just one additional related entity. In real-world scenarios, you often deal with multiple related entities, which can result in highly intricate filtering logic.

For testing, I’ve updated the method as follows:

public static void RunLinqWay()
    {
        var linq = new LinqWayCustomerService();

        Print(linq.GetActiveCustomers());
        Print(linq.GetPremiumCustomers());
        Print(linq.GetActiveAndPremiumCustomers());
        Print(linq.GetActiveOrPremiumCustomers());
        Print(linq.GetActiveAndPremiumCustomersWithActivePayments());
        Print(linq.GetInactiveCustomers());
        Print(linq.GetInactiveAndPremiumCustomers());
        Print(linq.GetInactiveOrPremiumCustomers());
        Print(linq.GetInactiveAndPremiumCustomersWithInactivePayments());
        Print(linq.GetCustomersWithoutPayments());
        Print(CustomerName, linq.CheckIsActivePremiumCustomerByName(CustomerName));
    }

The expected result should look like this:

ID: 1, Name: Alice, Active: True, Purchases: 1 500,00 UAH, Payments: Card(Active), PayPal(Inactive), Crypto(Active)
ID: 3, Name: Charlie, Active: True, Purchases: 200,00 UAH, Payments: Card(Inactive), PayPal(Inactive), Crypto(Active)
ID: 4, Name: David, Active: True, Purchases: 1 200,00 UAH, Payments: None


ID: 1, Name: Alice, Active: True, Purchases: 1 500,00 UAH, Payments: Card(Active), PayPal(Inactive), Crypto(Active)
ID: 4, Name: David, Active: True, Purchases: 1 200,00 UAH, Payments: None
ID: 5, Name: Eve, Active: False, Purchases: 2 500,00 UAH, Payments: Card(Inactive), PayPal(Inactive), Crypto(Inactive)


ID: 1, Name: Alice, Active: True, Purchases: 1 500,00 UAH, Payments: Card(Active), PayPal(Inactive), Crypto(Active)
ID: 4, Name: David, Active: True, Purchases: 1 200,00 UAH, Payments: None


ID: 1, Name: Alice, Active: True, Purchases: 1 500,00 UAH, Payments: Card(Active), PayPal(Inactive), Crypto(Active)
ID: 3, Name: Charlie, Active: True, Purchases: 200,00 UAH, Payments: Card(Inactive), PayPal(Inactive), Crypto(Active)
ID: 4, Name: David, Active: True, Purchases: 1 200,00 UAH, Payments: None
ID: 5, Name: Eve, Active: False, Purchases: 2 500,00 UAH, Payments: Card(Inactive), PayPal(Inactive), Crypto(Inactive)


ID: 1, Name: Alice, Active: True, Purchases: 1 500,00 UAH, Payments: Card(Active), PayPal(Inactive), Crypto(Active)


ID: 2, Name: Bob, Active: False, Purchases: 800,00 UAH, Payments: None
ID: 5, Name: Eve, Active: False, Purchases: 2 500,00 UAH, Payments: Card(Inactive), PayPal(Inactive), Crypto(Inactive)


ID: 5, Name: Eve, Active: False, Purchases: 2 500,00 UAH, Payments: Card(Inactive), PayPal(Inactive), Crypto(Inactive)


ID: 1, Name: Alice, Active: True, Purchases: 1 500,00 UAH, Payments: Card(Active), PayPal(Inactive), Crypto(Active)
ID: 2, Name: Bob, Active: False, Purchases: 800,00 UAH, Payments: None
ID: 4, Name: David, Active: True, Purchases: 1 200,00 UAH, Payments: None
ID: 5, Name: Eve, Active: False, Purchases: 2 500,00 UAH, Payments: Card(Inactive), PayPal(Inactive), Crypto(Inactive)


ID: 5, Name: Eve, Active: False, Purchases: 2 500,00 UAH, Payments: Card(Inactive), PayPal(Inactive), Crypto(Inactive)


ID: 2, Name: Bob, Active: False, Purchases: 800,00 UAH, Payments: None
ID: 4, Name: David, Active: True, Purchases: 1 200,00 UAH, Payments: None


Bob is active premium customer: False

Process finished with exit code 0.

With the Expression approach, you'll need to update the filters as follows:

public static class CustomerFilteringExtensions
{
    public static IEnumerable<Customer> FilterActive(this IEnumerable<Customer> customers)
        => customers.Where(c => c.IsActive);

    public static IEnumerable<Customer> FilterInactive(this IEnumerable<Customer> customers)
        => customers.Where(c => !c.IsActive);

    public static IEnumerable<Customer> FilterPremium(this IEnumerable<Customer> customers,
        decimal minimumPurchaseAmount)
        => customers.Where(c => c.TotalPurchases >= minimumPurchaseAmount);

    public static IEnumerable<Customer> FilterActiveOrPremium(this IEnumerable<Customer> customers, decimal minAmount)
        => customers.Where(c => c.IsActive || c.TotalPurchases >= minAmount);

    public static IEnumerable<Customer> FilterInactiveOrPremium(this IEnumerable<Customer> customers, decimal minAmount)
        => customers.Where(c => !c.IsActive || c.TotalPurchases >= minAmount);

    public static bool CheckActivePremiumCustomer(this IEnumerable<Customer> customers, string name, decimal minAmount)
    {
        Customer? customer = customers.FirstOrDefault(x => x.Name == name);

        return customer is { IsActive: true } && customer.TotalPurchases >= minAmount;
    }

    public static IEnumerable<Customer> CheckActiveAndPremiumCustomersWithActivePayments(
        this IEnumerable<Customer> customers, decimal minAmount)
        => customers.Where(x =>
            x is { IsActive: true, Payments: not null } && x.TotalPurchases >= minAmount &&
            x.Payments.Any(y => y is { IsActive: true, Method: "Card" } || y.Method == "Crypto"));

    public static IEnumerable<Customer> CheckInactiveAndPremiumCustomersWithInactivePayments(
        this IEnumerable<Customer> customers, decimal minAmount)
        => customers.Where(x =>
            x is { IsActive: false, Payments: not null } && x.TotalPurchases >= minAmount &&
            x.Payments.Any(y => y is { IsActive: false }));

    public static IEnumerable<Customer> CheckCustomersWithoutPayments(this IEnumerable<Customer> customers)
        => customers.Where(x => x is { Payments: null });
}

Additionally, you'll need to add new requests to the service as follows:

public class ExpressionWayCustomerService
{
    private readonly IEnumerable<Customer> _customers =
    [
        new(1, "Alice", true, 1500m, [new("Card", true), new("PayPal", false), new("Crypto", true)]),
        new(2, "Bob", false, 800m, null),
        new(3, "Charlie", true, 200m, [new("Card", false), new("PayPal", false), new("Crypto", true)]),
        new(4, "David", true, 1200m, null),
        new(5, "Eve", false, 2500m, [new("Card", false), new("PayPal", false), new("Crypto", false)])
    ];

    const decimal PremiumThreshold = 1000m;

    public IEnumerable<Customer> GetActiveCustomers()
        => _customers.FilterActive();

    public IEnumerable<Customer> GetPremiumCustomers()
        => _customers.FilterPremium(PremiumThreshold);

    public IEnumerable<Customer> GetActiveAndPremiumCustomers()
        => _customers.FilterActive().FilterPremium(PremiumThreshold);

    public IEnumerable<Customer> GetActiveOrPremiumCustomers()
        => _customers.FilterActiveOrPremium(PremiumThreshold);

    public IEnumerable<Customer> GetInactiveCustomers()
        => _customers.FilterInactive();

    public IEnumerable<Customer> GetInactiveAndPremiumCustomers()
        => _customers.FilterInactive().FilterPremium(PremiumThreshold);

    public IEnumerable<Customer> GetInactiveOrPremiumCustomers()
        => _customers.FilterInactiveOrPremium(PremiumThreshold);

    public IEnumerable<Customer> GetActiveAndPremiumCustomersWithActivePayments()
        => _customers.CheckActiveAndPremiumCustomersWithActivePayments(PremiumThreshold);

    public IEnumerable<Customer> GetInactiveAndPremiumCustomersWithInactivePayments()
        => _customers.CheckInactiveAndPremiumCustomersWithInactivePayments(PremiumThreshold);

    public IEnumerable<Customer> GetCustomersWithoutPayments()
        => _customers.CheckCustomersWithoutPayments();

    public bool CheckIsActivePremiumCustomerByName(string name)
        => _customers.CheckActivePremiumCustomer(name, PremiumThreshold);
}

In general, to extend this functionality, you’ll need to make updates in two key places.

For testing, update this method:

public static void RunExpressionWay()
    {
        var expression = new ExpressionWayCustomerService();

        Print(expression.GetActiveCustomers());
        Print(expression.GetPremiumCustomers());
        Print(expression.GetActiveAndPremiumCustomers());
        Print(expression.GetActiveOrPremiumCustomers());
        Print(expression.GetActiveAndPremiumCustomersWithActivePayments());
        Print(expression.GetInactiveCustomers());
        Print(expression.GetInactiveAndPremiumCustomers());
        Print(expression.GetInactiveOrPremiumCustomers());
        Print(expression.GetInactiveAndPremiumCustomersWithInactivePayments());
        Print(expression.GetCustomersWithoutPayments());
        Print(CustomerName, expression.CheckIsActivePremiumCustomerByName(CustomerName));
    }

To extend the Specification pattern, additional updates are required. First, you'll need to create new specifications that define the new filtering logic.

public class ActiveCardOrCryptoPaymentSpecification : Specification<Customer>
{
    public override Expression<Func<Customer, bool>> ToExpression()
    {
        return customer => customer.Payments != null &&
                           customer.Payments.Any(p => p.IsActive && (p.Method == "Card" || p.Method == "Crypto"));
    }
}

public class HasActivePaymentSpecification : Specification<Customer>
{
    public override Expression<Func<Customer, bool>> ToExpression()
    {
        return customer => customer.Payments != null &&
                           customer.Payments.Any(p => p.IsActive);
    }
}

public class HasInactivePaymentSpecification : Specification<Customer>
{
    public override Expression<Func<Customer, bool>> ToExpression()
    {
        return customer => customer.Payments != null &&
                           customer.Payments.Any(p => !p.IsActive);
    }
}

public class HasPaymentsSpecification : Specification<Customer>
{
    public override Expression<Func<Customer, bool>> ToExpression()
    {
        return customer => customer.Payments != null;
    }
}

public class NoPaymentsSpecification : Specification<Customer>
{
    public override Expression<Func<Customer, bool>> ToExpression()
    {
        return customer => customer.Payments == null;
    }
}

Additionally, you’ll need to make substantial changes to the service:

public class SpecificationWayCustomerService
{
    private readonly IEnumerable<Customer> _customers =
    [
        new(1, "Alice", true, 1500m, [new("Card", true), new("PayPal", false), new("Crypto", true)]),
        new(2, "Bob", false, 800m, null),
        new(3, "Charlie", true, 200m, [new("Card", false), new("PayPal", false), new("Crypto", true)]),
        new(4, "David", true, 1200m, null),
        new(5, "Eve", false, 2500m, [new("Card", false), new("PayPal", false), new("Crypto", false)])
    ];

    private static readonly ActiveCustomerSpecification ActiveSpec = new();
    private static readonly PremiumCustomerSpecification PremiumSpec = new();
    private static readonly CustomerNameSpecification NameSpec = new();
    private static readonly HasPaymentsSpecification HasPaymentsSpec = new();
    private static readonly NoPaymentsSpecification NoPaymentsSpec = new();
    private static readonly ActiveCardOrCryptoPaymentSpecification ActiveCardOrCryptoSpec = new();
    private static readonly HasActivePaymentSpecification HasActivePaymentSpec = new();
    private static readonly HasInactivePaymentSpecification HasInactivePaymentSpec = new();

    private static readonly Func<Customer, bool> ActiveFunc = ActiveSpec.GetCompiledExpression();
    private static readonly Func<Customer, bool> PremiumFunc = PremiumSpec.GetCompiledExpression();

    private static readonly Func<Customer, bool> ActiveAndPremiumFunc =
        (ActiveSpec & PremiumSpec).GetCompiledExpression();

    private static readonly Func<Customer, bool> ActiveOrPremiumFunc =
        (ActiveSpec | PremiumSpec).GetCompiledExpression();

    private static readonly Func<Customer, bool> InactiveFunc = (!ActiveSpec).GetCompiledExpression();

    private static readonly Func<Customer, bool> InactiveAndPremiumFunc =
        (!ActiveSpec & PremiumSpec).GetCompiledExpression();

    private static readonly Func<Customer, bool> InactiveOrPremiumFunc =
        (!ActiveSpec | PremiumSpec).GetCompiledExpression();

    private static readonly Func<Customer, bool> NoPaymentsFunc = NoPaymentsSpec.GetCompiledExpression();

    private static readonly Func<Customer, bool> ActivePremiumWithActivePaymentsFunc =
        (ActiveSpec & PremiumSpec & HasPaymentsSpec & ActiveCardOrCryptoSpec).GetCompiledExpression();

    private static readonly Func<Customer, bool> InactivePremiumWithInactivePaymentsFunc =
        (!ActiveSpec & PremiumSpec & HasPaymentsSpec & HasInactivePaymentSpec).GetCompiledExpression();

    public IEnumerable<Customer> GetActiveCustomers() => _customers.Where(ActiveFunc);
    public IEnumerable<Customer> GetPremiumCustomers() => _customers.Where(PremiumFunc);
    public IEnumerable<Customer> GetActiveAndPremiumCustomers() => _customers.Where(ActiveAndPremiumFunc);
    public IEnumerable<Customer> GetActiveOrPremiumCustomers() => _customers.Where(ActiveOrPremiumFunc);
    public IEnumerable<Customer> GetInactiveCustomers() => _customers.Where(InactiveFunc);
    public IEnumerable<Customer> GetInactiveAndPremiumCustomers() => _customers.Where(InactiveAndPremiumFunc);
    public IEnumerable<Customer> GetInactiveOrPremiumCustomers() => _customers.Where(InactiveOrPremiumFunc);

    public IEnumerable<Customer> GetActiveAndPremiumCustomersWithActivePayments()
        => _customers.Where(ActivePremiumWithActivePaymentsFunc);

    public IEnumerable<Customer> GetInactiveAndPremiumCustomersWithInactivePayments()
        => _customers.Where(InactivePremiumWithInactivePaymentsFunc);

    public IEnumerable<Customer> GetCustomersWithoutPayments()
        => _customers.Where(NoPaymentsFunc);

    public bool CheckIsActivePremiumCustomerByName(string name)
    {
        NameSpec.Name = name;
        var combinedSpec = NameSpec & ActiveSpec & PremiumSpec;
        return _customers.Any(combinedSpec.IsSatisfiedBy);
    }
}

In this case, I’ve added new specifications and combined the queries.
For testing, update the method as follows:

public static void RunSpecificationWay()
    {
        var specification = new SpecificationWayCustomerService();

        Print(specification.GetActiveCustomers());
        Print(specification.GetPremiumCustomers());
        Print(specification.GetActiveAndPremiumCustomers());
        Print(specification.GetActiveOrPremiumCustomers());
        Print(specification.GetActiveAndPremiumCustomersWithActivePayments());
        Print(specification.GetInactiveCustomers());
        Print(specification.GetInactiveAndPremiumCustomers());
        Print(specification.GetInactiveOrPremiumCustomers());
        Print(specification.GetInactiveAndPremiumCustomersWithInactivePayments());
        Print(specification.GetCustomersWithoutPayments());
        Print(CustomerName, specification.CheckIsActivePremiumCustomerByName(CustomerName));
    }

Final Comparison

I conducted a new benchmark using more complex queries:

As you can see, the performance gap between this approach and the first one has narrowed, despite adding just one entity and three new filters. In more complex scenarios, however, the performance will likely degrade further.

Conclusion

Let’s review the pros and cons of the Specification pattern.

Pros

Enables reuse of filters
Facilitates building simple queries and combining them into more complex ones
Treats each query as a separate class, improving readability
Provides good performance in more complex scenarios

Cons

More complex to implement and maintain
Requires familiarity with Expressions
Involves writing more code
Incorrect implementation can negatively impact performance

When to Use:

Use the Specification pattern in large projects with complex data structures.

When to Avoid:

Avoid it in small projects, with straightforward data models, or simple filtering needs.

Thanks for reading! I hope this article was helpful. See you next time, and happy coding!

You can find the source code for this example here.

Design Patterns #5: Null Object Pattern – Writing Safer, Cleaner Code.

Serhii Korol — Mon, 21 Apr 2025 14:41:08 +0000

Hey everyone, I’m back! Today, let’s talk about a common headache in programming: dealing with null objects.

When you’re working with simple value types — like integers or booleans - you can rely on default values. An int defaults to 0, a bool to false, and so on. But what happens when you need to return an object?

Many developers fall into the habit of returning null and then scattering null checks throughout their code. Sure, you could return a new instance instead of null, but that’s often just as problematic.

So, what’s the better solution? Let’s dive in.

Default Practice: Returning null for Missing Objects

To illustrate the problem, let’s start with a basic example. Imagine we have a simple User class:

public sealed class User(Guid id, string name, bool hasAccess)
{
    public Guid Id { get; set; } = id;
    public string Name { get; set; } = name;
    public bool HasAccess { get; set; } = hasAccess;
}

Let's create a simple in-memory data store and implement a user lookup method. First, we'll seed some sample data:

public sealed class NonNullObjectUserRepository
{
    private readonly IList<User> _users = new List<User>();

    public NonNullObjectUserRepository()
    {
        _users.Add(new User(Guid.Parse("8363c613-f614-4f7c-971f-396cba910f32"), "John", true));
        _users.Add(new User(Guid.Parse("7c62b792-4903-4fe7-b264-870cdef66ea8"), "Jane", true));
        _users.Add(new User(Guid.Parse("2e32e097-d729-4d12-838d-bcc4e6cd821a"), "Bob", true));
    }

    public User? GetUserById(Guid id)
    {
        return _users.FirstOrDefault(u => u.Id == id);
    }
}

This is where we encounter our critical design decision - how should GetUserById behave when the requested user doesn't exist? The conventional approach would look something like this:

    public User? GetUserById(Guid id)
    {
        return _users.FirstOrDefault(u => u.Id == id);
    }

Notice the return type User? - that question mark isn't just syntax. It's a warning sign that says:

"This might be null"
"You must handle this case"
"I'm a potential runtime exception waiting to happen"

Now let's create a service that acts as an intermediary between our application and the repository. This service will handle the business logic while delegating data access to the repository:

public sealed class NonNullObjectUserService
{
    private readonly NonNullObjectUserRepository _userRepository = new();

    public User? GetCurrentUser(Guid userId)
    {
        return _userRepository.GetUserById(userId);
    }
}

Our GetCurrentUser method shares the same challenge - it returns a nullable User?, forcing callers to handle the null case.

Next, let's create a method to make a call. For demonstration purposes, we'll attempt to retrieve a non-existent user using a random ID. Since the user may not exist, it's essential to perform a null check before using the object. While these checks can add to the codebase and increase complexity, they are necessary for safe access. Despite this, the code remains valid and functions as expected.

    public void RunGetNonNullObjectUser()
    {
        var userService = new NonNullObjectUserService();
        var user = userService.GetCurrentUser(Guid.Parse("3d73ae77-229a-4f7b-a3c6-49a3e283b5ac"));
        if (user is null)
        {
            Console.WriteLine("User not found");
        }
    }

So, how can we make this better? This is where the Null Object Pattern comes in — it was specifically created to handle cases like this, where dealing with null checks can become repetitive and error-prone.

A Practical Implementation of the Null Object Pattern

Earlier, we created the User class. Now, we need to define an abstract type by introducing an IUser interface, which both User and other related classes will implement. The IUser interface should contain the same properties as the User class to ensure consistency and enable polymorphism.

public interface IUser
{
    public Guid Id { get; set; }
    public string Name { get; set; }
    public bool HasAccess { get; set; }
}

public sealed class User(Guid id, string name, bool hasAccess) : IUser
{
    public Guid Id { get; set; } = id;
    public string Name { get; set; } = name;
    public bool HasAccess { get; set; } = hasAccess;
}

Next, let's implement a default class that provides properties with predefined values. We'll use the Singleton pattern here, as there's no need to create a new instance every time—the same instance can be reused throughout the application.

public sealed class NullUser : IUser
{
    public static readonly NullUser Instance = new ();

    private NullUser() { }
    public Guid Id { get; set; } = Guid.Empty;
    public string Name { get; set; } = string.Empty;
    public bool HasAccess { get; set; } = false;
}

The repository is similar to the previous one but now works with the general IUser type. Notice the GetNullObjectUserById method—here, we check if the retrieved object is null, and if so, we return the default instance instead.

public sealed class NullObjectUserRepository
{
    private readonly IList<IUser> _users = new List<IUser>();

    public NullObjectUserRepository()
    {
        _users.Add(new User(Guid.Parse("8363c613-f614-4f7c-971f-396cba910f32"), "John", true));
        _users.Add(new User(Guid.Parse("7c62b792-4903-4fe7-b264-870cdef66ea8"), "Jane", true));
        _users.Add(new User(Guid.Parse("2e32e097-d729-4d12-838d-bcc4e6cd821a"), "Bob", true));
    }

    public IUser GetNullObjectUserById(Guid id)
    {
        var user = _users.FirstOrDefault(u => u.Id == id);
        return user ?? NullUser.Instance;
    }
}

The service remains the same as before, with the only difference being the return type, which is now IUser.

public sealed class NullObjectUserService
{
    private readonly NullObjectUserRepository _userRepository = new();

    public IUser GetCurrentNullObjectUser(Guid userId)
    {
        return _userRepository.GetNullObjectUserById(userId);
    }
}

Next, let's implement the call method. Unlike the previous version, this one includes a check for the default object.

    public void RunGetNullObjectUser()
    {
        var userService = new NullObjectUserService();
        var user = userService.GetCurrentNullObjectUser(Guid.Parse("3d73ae77-229a-4f7b-a3c6-49a3e283b5ac"));
        if (user.Id == Guid.Empty)
        {
            Console.WriteLine("User not found");
        }
    }

Comparison and Testing

As the codebase grows in complexity, we might question the need for the second approach—especially since it still involves checking the object. However, the key advantage lies in performance and code quality.

When checking for null, we're performing a reference check, which may be simple but often triggers compiler warnings or requires repetitive safeguards throughout the code. More null checks also increase branching, which can negatively impact performance and readability.

In contrast, the Null Object Pattern eliminates null references entirely. The object is never null, so we compare by value instead of by reference. This makes the code more predictable and improves branch prediction at runtime. It also results in cleaner Intermediate Language (IL) code with fewer instructions.

Although a direct null check is technically faster due to its simplicity, it often leads to more verbose and scattered null-handling logic. On the other hand, nullable objects typically produce more IL instructions. So, while the Null Object Pattern introduces a value-based check, it offers better maintainability, predictability, and, in some cases, performance benefits at scale.

Certainly, we can modify our method to return a new instance instead of null. In this case, there's no need to check the object for null anymore.

    public User? GetUserById(Guid id)
    {
        var user = _users.FirstOrDefault(u => u.Id == id);
        return user ?? new User(Guid.Empty, string.Empty, false);
    }

    public void RunGetNonNullObjectUser()
    {
        var userService = new NonNullObjectUserService();
        var user = userService.GetCurrentUser(Guid.Parse("3d73ae77-229a-4f7b-a3c6-49a3e283b5ac"));
        if (user.Id == Guid.Empty)
        {
            Console.WriteLine("User not found");
        }
    }

However, this approach will be slower, as we create a new instance each time, which consumes more memory.

Conclusions

In this article, I’ve aimed to clearly demonstrate the consequences of using null instead of the Null Object Pattern. While it's not critical for simple projects, in applications with complex logic and frequent reuse of services, performance may suffer.

I hope you found something valuable in this article. Happy coding, and see you next time!

You can find the source code for this example here.

Customizing the Tab Bar in .NET MAUI: A Step-by-Step Guide to Painting and Styling

Serhii Korol — Thu, 13 Mar 2025 12:00:40 +0000

Hi there! Today, I’d like to dive into the Tab Bar in .NET MAUI. The tab bar is a key navigation element that allows users to switch between different sections of an app seamlessly. To start, I’ll walk you through how to implement a default tab bar out of the box, along with some of its limitations. Then, I’ll show you how to enhance and customize it to create a more polished and user-friendly experience. Let’s get started!

Default approach

This approach works out of the box with minimal setup. All you need to do is add a bit of code to the Shell configuration.

To get started, create a base project using the .NET MAUI template. This will set up the foundation for implementing the tab bar.

dotnet new maui -n YourProject

Once you run the project, you should see the following screen:

Now, let’s set up the navigation. Open the AppShell.xaml file, where you’ll find the following structure:

<?xml version="1.0" encoding="UTF-8" ?>
<Shell
    x:Class="CustomTabBar.AppShell"
    xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
    xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
    xmlns:local="clr-namespace:CustomTabBar"
    Title="CustomTabBar">

    <ShellContent ContentTemplate="{DataTemplate local:MainPage}" />

</Shell>

Before we dive into implementing the navigation, let’s enhance the tab bar by adding some icons. I’ve come across a set of stunning icons that I think many of you will love. However, there’s a catch: while we all want beautiful icons, sometimes we’re limited by the options available. You’ll see what I mean as we proceed. The icons I’ll be using are available in the repository linked to this article, so feel free to grab them from there.

As you can see, these icons are vibrant and visually appealing. However, despite their charm, they aren’t quite suitable for this specific use case. Let me walk you through why that is and what makes them a less-than-ideal fit.

To proceed, you’ll need to replace the existing code with the following:

<ShellContent ContentTemplate="{DataTemplate local:MainPage}" />

To this:

    <FlyoutItem FlyoutDisplayOptions="AsMultipleItems">
        <Tab Title="Profile" Icon="icon_profile.png">
            <ShellContent ContentTemplate="{DataTemplate local:MainPage}" />
        </Tab>
        <Tab Title="Notifications" Icon="icon_notifications.png">
            <ShellContent ContentTemplate="{DataTemplate local:MainPage}" />
        </Tab>
        <Tab Title="Favorites" Icon="icon_favorites.png">
            <ShellContent ContentTemplate="{DataTemplate local:MainPage}" />
        </Tab>
        <Tab Title="Settings" Icon="icon_settings.png">
            <ShellContent ContentTemplate="{DataTemplate local:MainPage}" />
        </Tab>
    </FlyoutItem>

If you run the app now, you’ll notice the icons displayed at the bottom. Unfortunately, the once vibrant and detailed icons have been rendered as monochrome shapes, losing their color and intricate details. Instead of the charming visuals we started with, they now appear as smudged, indistinct marks—far from appealing. This happens because the Shell in .NET MAUI doesn’t support colorful icons in the bottom tab bar, limiting their visual impact and aesthetic appeal.

However, if you open the sandwich menu (the flyout menu), you’ll notice that the icons there retain their vibrant and detailed appearance. It’s a bit puzzling why this inconsistency exists—why the icons look stunning in the flyout menu but lose their charm in the bottom tab bar. I’m not entirely sure why this design choice was made, but it certainly highlights a limitation worth addressing.

Of course, you could always search for more suitable icons or even explore iconic fonts to create visually appealing styles, and the result could look quite impressive. However, let’s say you’re set on using these specific icons—maybe you’re fond of their design, or they align perfectly with your project’s theme. The question is, how can you make them work in this context? Let’s dive into a solution that allows you to use these icons effectively.

Custom control

This issue can be resolved by implementing a custom control. To get started, let’s create a ContentView element. Simply paste the following code into TabBarView.xaml. For now, you can leave TabBarView.xaml.cs unchanged—no additional modifications are needed there.

<?xml version="1.0" encoding="utf-8"?>

<ContentView xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
             x:Class="CustomTabBar.Controls.TabBarView">
    <Grid RowDefinitions="*,Auto">
        <Border Grid.Row="1"
                BackgroundColor="{StaticResource Secondary}"
                HeightRequest="100"
                Opacity="0.5"
                Padding="15,0"
                StrokeThickness="0">
            <Border.StrokeShape>
                <RoundRectangle CornerRadius="5" />
            </Border.StrokeShape>
        </Border>
        <FlexLayout Direction="Row"
                    Grid.Row="1"
            JustifyContent="SpaceAround"
            AlignItems="Center">
            <VerticalStackLayout Spacing="4" Padding="10">
                <VerticalStackLayout.GestureRecognizers>
                    <TapGestureRecognizer Command="{Binding GoToHomeCommand}" />
                </VerticalStackLayout.GestureRecognizers>
                <Image Source="icon_profile.png" HeightRequest="24" WidthRequest="24" />
                <Label Text="Home" HorizontalOptions="Center" FontSize="12" TextColor="Black" />
            </VerticalStackLayout>
                    <VerticalStackLayout Spacing="4" Padding="10">
                        <VerticalStackLayout.GestureRecognizers>
                            <TapGestureRecognizer Command="{Binding GoToCalendarCommand}" />
                        </VerticalStackLayout.GestureRecognizers>
                        <Image Source="icon_notifications.png" HeightRequest="24" WidthRequest="24" />
                        <Label Text="Calendar" HorizontalOptions="Center" FontSize="12" TextColor="Black" />
                    </VerticalStackLayout>

                    <VerticalStackLayout Spacing="4" Padding="10">
                        <VerticalStackLayout.GestureRecognizers>
                            <TapGestureRecognizer Command="{Binding GoToFiltersCommand}" />
                        </VerticalStackLayout.GestureRecognizers>
                        <Image Source="icon_favorites.png" HeightRequest="24" WidthRequest="24" />
                        <Label Text="Filters" HorizontalOptions="Center" FontSize="12" TextColor="Black" />
                    </VerticalStackLayout>

                    <VerticalStackLayout Spacing="4" Padding="10">
                        <VerticalStackLayout.GestureRecognizers>
                            <TapGestureRecognizer Command="{Binding GoToSettingsCommand}" />
                        </VerticalStackLayout.GestureRecognizers>
                        <Image Source="icon_settings.png" HeightRequest="24" WidthRequest="24" />
                        <Label Text="Settings" HorizontalOptions="Center" FontSize="12" TextColor="Black" />
                    </VerticalStackLayout>
        </FlexLayout>
    </Grid>
</ContentView>

Next, let’s return to AppShell.xaml and revert to our previous code. This will help us restore the original setup while integrating our new custom control.

<?xml version="1.0" encoding="UTF-8" ?>
<Shell
    x:Class="CustomTabBar.AppShell"
    xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
    xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
    xmlns:local="clr-namespace:CustomTabBar"
    Title="CustomTabBar">

    <ShellContent ContentTemplate="{DataTemplate local:MainPage}" />
</Shell>

Now, let’s move to the MainPage.xaml file and make a few adjustments. First, wrap the existing ScrollView block inside a Grid block. Then, just below the ScrollView, insert our custom TabBarView. Here’s what the final implementation should look like:

<?xml version="1.0" encoding="utf-8" ?>
<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
             xmlns:controls="clr-namespace:CustomTabBar.Controls"
             x:Class="CustomTabBar.MainPage">

    <Grid RowDefinitions="*,Auto">
        <ScrollView>
        <VerticalStackLayout
            Padding="30,0"
            Spacing="25">

            <Image
                Source="dotnet_bot.png"
                HeightRequest="185"
                Aspect="AspectFit"
                SemanticProperties.Description="dot net bot in a hovercraft number nine" />

            <Label
                Text="Hello, World!"
                Style="{StaticResource Headline}"
                SemanticProperties.HeadingLevel="Level1" />

            <Label
                Text="Welcome to &#10;.NET Multi-platform App UI"
                Style="{StaticResource SubHeadline}"
                SemanticProperties.HeadingLevel="Level2"
                SemanticProperties.Description="Welcome to dot net Multi platform App U I" />

            <Button
                x:Name="CounterBtn"
                Text="Click me" 
                SemanticProperties.Hint="Counts the number of times you click"
                Clicked="OnCounterClicked"
                HorizontalOptions="Fill" />

        </VerticalStackLayout>
    </ScrollView>
        <controls:TabBarView />
    </Grid>
</ContentPage>

The TabBarView.xaml.cs file can remain unchanged—no modifications are needed there.

Once you’ve made all the adjustments, go ahead and run the app. If everything was done correctly, you should see the updated tab bar in action!

It works! While I didn’t use any commands or tap gestures to handle page navigation, my primary goal was to demonstrate how to style the tab bar and address the challenge of using custom icons. Although this solution achieves the desired visual effect, I wouldn’t recommend using it in its current state. Below, I’ll explain the reasons why and discuss potential improvements.

Correct implementation

If you inject the ContentView element directly, you’ll end up with redundant code that lacks flexibility and maintainability. This approach can quickly become cumbersome as your project grows. Fortunately, there’s a better way to address these issues. Let me show you an alternative approach that solves these problems while keeping your code clean and adaptable.

Let’s create another element, similar to a ContentPage, to streamline our solution. Simply paste the following code into the new file:

<?xml version="1.0" encoding="utf-8"?>

<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
             xmlns:controls="clr-namespace:CustomTabBar.Controls"
             x:Class="CustomTabBar.Controls.TabBarPage"
             x:DataType="controls:TabBarPage">
        <ContentPage.Resources>
    <ControlTemplate x:Key="TabBarTemplate">
    <Grid RowDefinitions="*,Auto">
        <Border Grid.Row="1"
                BackgroundColor="{StaticResource Secondary}"
                HeightRequest="100"
                Opacity="0.5"
                Padding="15,0" 
                StrokeThickness="0">
            <Border.StrokeShape>
                <RoundRectangle CornerRadius="5" />
            </Border.StrokeShape>
        </Border>
        <FlexLayout Direction="Row"
                    Grid.Row="1"
            JustifyContent="SpaceAround"
            AlignItems="Center">
            <VerticalStackLayout Spacing="4" Padding="10">
                <Image Source="icon_profile.png" HeightRequest="24" WidthRequest="24" />
                <Label Text="Profile" HorizontalOptions="Center" FontSize="12" TextColor="Black" />
            </VerticalStackLayout>
                    <VerticalStackLayout Spacing="4" Padding="10">
                        <Image Source="icon_notifications.png" HeightRequest="24" WidthRequest="24" />
                        <Label Text="Notifications" HorizontalOptions="Center" FontSize="12" TextColor="Black" />
                    </VerticalStackLayout>

                    <VerticalStackLayout Spacing="4" Padding="10">
                        <Image Source="icon_favorites.png" HeightRequest="24" WidthRequest="24" />
                        <Label Text="Favorites" HorizontalOptions="Center" FontSize="12" TextColor="Black" />
                    </VerticalStackLayout>

                    <VerticalStackLayout Spacing="4" Padding="10">
                        <Image Source="icon_settings.png" HeightRequest="24" WidthRequest="24" />
                        <Label Text="Settings" HorizontalOptions="Center" FontSize="12" TextColor="Black" />
                    </VerticalStackLayout>
        </FlexLayout>
    </Grid>
    </ControlTemplate>
</ContentPage.Resources>
</ContentPage>

The code must be placed within a ControlTemplate, which is mandatory to include in the Resources block.

For a visual demonstration, I created a clone of MainPage named ExtendedMainPage. While the logic and layout remain the same, a few modifications are necessary. As you may know, a ContentPage inherits from the ContentPage class. In this case, however, you’ll need to inherit from TabBarPage, which itself is already derived from the ContentPage class.

public partial class ExtendedMainPage : TabBarPage
{
    int count = 0;

    public ExtendedMainPage()
    {
        InitializeComponent();
    }

    private void OnCounterClicked(object sender, EventArgs e)
    {
        count++;

        if (count == 1)
            CounterBtn.Text = $"Clicked {count} time";
        else
            CounterBtn.Text = $"Clicked {count} times";

        SemanticScreenReader.Announce(CounterBtn.Text);
    }
}

Previously, our ScrollView was placed directly inside the ContentPage and wrapped in a Grid. Now, we’ll take a different approach: instead of using ContentPage directly, we’ll utilize the Content block from the base class and wrap the ScrollView there.

Once this is done, the final step is to navigate to AppShell.xaml and replace MainPage with ExtendedMainPage. This ensures our updated implementation is properly integrated into the app’s navigation structure.

<ShellContent ContentTemplate="{DataTemplate local:ExtendedMainPage}" />

If you test this now, you’ll notice that the bottom tab bar is missing. Why? It’s because we haven’t invoked our ControlTemplate yet. To fix this, simply add the following code to ensure the template is properly applied:

<controls:TabBarPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
             xmlns:controls="clr-namespace:CustomTabBar.Controls"
             x:Class="CustomTabBar.ExtendedMainPage"
             ControlTemplate="{StaticResource TabBarTemplate}">

Run the app again. This time, you’ll notice that only the menu is displayed, while the rest of the content is missing. What’s going on? Let’s break it down.

Oh no! It looks like we forgot to instruct our control to display the content from the child element. Let’s fix that.

    <Grid RowDefinitions="*,Auto">
        <ContentPresenter Grid.Row="0" />

Run the app again—this time, everything should work as expected. The tab bar and content are now displaying correctly!

But you might be wondering, what’s the advantage of this approach compared to the previous one? As I mentioned earlier, this method allows us to use only a single ContentPage while maintaining flexibility. Now, I’d like to show you how to manage the custom control effectively.

Head over to TabBarPage.xaml.cs and add the following code:

public partial class TabBarPage : ContentPage
{
    private static readonly BindableProperty ProfileTextProperty = BindableProperty.Create(nameof(ProfileText), typeof(string), typeof(TabBarPage));
    private static readonly BindableProperty NotificationsTextProperty = BindableProperty.Create(nameof(NotificationsText), typeof(string), typeof(TabBarPage));
    private static readonly BindableProperty FavoritesTextProperty = BindableProperty.Create(nameof(FavoritesText), typeof(string), typeof(TabBarPage));
    private static readonly BindableProperty SettingsTextProperty = BindableProperty.Create(nameof(SettingsText), typeof(string), typeof(TabBarPage));

    public string ProfileText
    {
        get => (string)GetValue(ProfileTextProperty);
        init => SetValue(ProfileTextProperty, value);
    }

    public string NotificationsText
    {
        get => (string)GetValue(NotificationsTextProperty);
        init => SetValue(NotificationsTextProperty, value);
    }

    public string FavoritesText
    {
        get => (string)GetValue(FavoritesTextProperty);
        init => SetValue(FavoritesTextProperty, value);
    }

    public string SettingsText
    {
        get => (string)GetValue(SettingsTextProperty);
        init => SetValue(SettingsTextProperty, value);
    }

    public TabBarPage()
    {
        InitializeComponent();
    }
}

These properties are essential for setting dynamic values that we’ll integrate into the layout. They provide the flexibility needed to customize the control at runtime.

<?xml version="1.0" encoding="utf-8"?>

<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
             xmlns:controls="clr-namespace:CustomTabBar.Controls"
             x:Class="CustomTabBar.Controls.TabBarPage"
             x:DataType="controls:TabBarPage">
        <ContentPage.Resources>
    <ControlTemplate x:Key="TabBarTemplate">
    <Grid RowDefinitions="*,Auto">
        <ContentPresenter Grid.Row="0" />
        <Border Grid.Row="1"
                BackgroundColor="{StaticResource Secondary}"
                HeightRequest="100"
                Opacity="0.5"
                Padding="15,0" 
                StrokeThickness="0">
            <Border.StrokeShape>
                <RoundRectangle CornerRadius="5" />
            </Border.StrokeShape>
        </Border>
        <FlexLayout Direction="Row"
                    Grid.Row="1"
            JustifyContent="SpaceAround"
            AlignItems="Center">
            <VerticalStackLayout Spacing="4" Padding="10">
                <Image Source="icon_profile.png" HeightRequest="24" WidthRequest="24" />
                <Label Text="{TemplateBinding ProfileText}" HorizontalOptions="Center" FontSize="12" TextColor="Black" />
            </VerticalStackLayout>
                    <VerticalStackLayout Spacing="4" Padding="10">
                        <Image Source="icon_notifications.png" HeightRequest="24" WidthRequest="24" />
                        <Label Text="{TemplateBinding NotificationsText}" HorizontalOptions="Center" FontSize="12" TextColor="Black" />
                    </VerticalStackLayout>

                    <VerticalStackLayout Spacing="4" Padding="10">
                        <Image Source="icon_favorites.png" HeightRequest="24" WidthRequest="24" />
                        <Label Text="{TemplateBinding FavoritesText}" HorizontalOptions="Center" FontSize="12" TextColor="Black" />
                    </VerticalStackLayout>

                    <VerticalStackLayout Spacing="4" Padding="10">
                        <Image Source="icon_settings.png" HeightRequest="24" WidthRequest="24" />
                        <Label Text="{TemplateBinding SettingsText}" HorizontalOptions="Center" FontSize="12" TextColor="Black" />
                    </VerticalStackLayout>
        </FlexLayout>
    </Grid>
    </ControlTemplate>
</ContentPage.Resources>
</ContentPage>

Finally, you’ll need to assign the appropriate values in ExtendedMainPage to complete the setup.

<controls:TabBarPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
             xmlns:controls="clr-namespace:CustomTabBar.Controls"
             x:Class="CustomTabBar.ExtendedMainPage"
             ProfileText="Person"
             NotificationsText="Notifications"
             FavoritesText="Favorites"
             SettingsText="Settings"
             ControlTemplate="{StaticResource TabBarTemplate}">

Go ahead and test it out—the result will be exactly the same as before, but now with a more flexible and maintainable implementation.

Now, I can effortlessly update and customize the text labels, making the control more dynamic and adaptable to changes.

<controls:TabBarPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
             xmlns:controls="clr-namespace:CustomTabBar.Controls"
             x:Class="CustomTabBar.ExtendedMainPage"
             ProfileText="Account"
             NotificationsText="Messages"
             FavoritesText="Bookmarks"
             SettingsText="Tools"
             ControlTemplate="{StaticResource TabBarTemplate}">

Take a look now—the labels have been successfully updated! This demonstrates how easily you can modify and customize the content.

Conclusion

In this article, I’ve demonstrated different approaches to creating a more styled and flexible tab bar menu, as the standard implementation comes with certain limitations. That said, my approach isn’t without its drawbacks—it’s more complex and requires adding this custom control to each page individually.

Despite these trade-offs, I hope you found this guide helpful and that it inspires you to implement similar solutions in your own projects.

You can find the complete source code on my GitHub repository for reference and further exploration.

SergKorol / CustomTabBar

Say Goodbye to WebDriver: Modern Alternatives for Browser Automation – Part 3

Serhii Korol — Tue, 25 Feb 2025 14:22:28 +0000

Good day! In my previous articles, I explained how to scrape data and interact with the DOM and shadow roots. You can find the first and second parts by following the links.

Today, I’ll show you how to interact with closed shadow roots. As you may know, shadow roots can be either open or closed. Open shadow roots allow direct access via queries, but closed shadow roots do not. However, you can still interact with them—let me show you how.

Base implementation

I won’t waste your time explaining the basic functionality—that's covered in the first part. Let’s jump straight into the base code:

        static async Task InteractionWithClosedShadowRoot()
        {
            const int port = 9222;
            var chromePath = "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome";
            var userDataDir = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName());

            //🚀Step 1: Start Chrome
            Console.WriteLine("🚀Starting a new Chrome instance...");
            Directory.CreateDirectory(userDataDir);

            var psi = new ProcessStartInfo
            {
                FileName = chromePath,
                Arguments = string.Join(" ",
                    $"--remote-debugging-port={port}",
                    "--no-first-run",
                    $"--user-data-dir={userDataDir}",
                    "https://selectorshub.com/xpath-practice-page/")
            };

            var chromeProcess = Process.Start(psi);
            if (chromeProcess == null)
            {
                Console.WriteLine("❌Failed to start Chrome.");
                return;
            }

            Console.WriteLine("🚀Chrome started. Waiting for initialization...");
            await Task.Delay(5000);
            try
            {
                //✅Step 2: Get WebSocket Debugger URL
                string? debuggerUrl = await GetPageWebSocketUrl();
                Console.WriteLine(debuggerUrl);
                if (string.IsNullOrEmpty(debuggerUrl))
                {
                    Console.WriteLine("❌Failed to retrieve WebSocket Debugger URL.");
                    return;
                }

                // ⚙️Step 3: Connect to WebSocket

                using var ws = new ClientWebSocket();
                await ws.ConnectAsync(new Uri(debuggerUrl), CancellationToken.None);

                //🚪Step 7: Close
                Console.WriteLine("🚪Press Enter to close...");
                Console.ReadLine();
                await ws.CloseAsync(WebSocketCloseStatus.NormalClosure, "Close", CancellationToken.None);
            }
            catch (Exception ex)
            {
                Console.WriteLine($"❌ Error: {ex.Message}");
            }
            finally
            {
                if (!chromeProcess.HasExited)
                {
                    chromeProcess.Kill();
                }
            }
        }

Tasks

We need to enter text into an input element located inside a closed shadow root.

Visit this page, where I’ve identified an element within a closed shadow root.

Implementation

Since we can’t directly access the input element, we need to target its parent element using the #userPass selector. In my previous article, I demonstrated how to retrieve an element's object ID—we’ll follow the same approach here.

 // ✅Step 4: Get element

var hostId = await QuerySelector(ws, "#userPass", 1);
if (string.IsNullOrEmpty(hostId)) return;

Once we retrieve the ID, we need to scroll down to the element. Without this step, we can't focus on it, as it renders dynamically. Scrolling ensures the element is loaded into the viewport, making it accessible for interaction.

        static async Task ScrollToElement(ClientWebSocket ws, string objectId, int id)
        {
            var command = new
            {
                id,
                method = "Runtime.callFunctionOn",
                @params = new
                {
                    objectId,
                    functionDeclaration = "function() { this.scrollIntoView(true); }",
                    returnByValue = false
                }
            };

            var response = await SendAndReceive(ws, command);
            Console.WriteLine($"Click Response: {response}");
        }


// ✅Step 5: Scroll
await ScrollToElement(ws, hostId, 2);

Next, to type text, we need to focus on the element. JavaScript provides a method for focusing elements, and CDP offers a specialized method called DOM.focus. However, there’s a challenge—the target element is a <div>, which isn’t inherently focusable. Since it has no visible representation, the browser won’t allow focus on it.

To work around this, use the following code:

// ✅Step 6: Focus and type text
await PressArrowUp(ws, 3);
await PressTab(ws, 3);
await TypeText(ws, "helloworld", 4);

This approach comes with a few pitfalls. You might be wondering why I included the PressArrowUp method. It’s a unique case—this component only loads when the user physically scrolls down. By simulating user interaction, this method helps trigger the loading process.

You can use different keys or methods to achieve the same effect, but I chose the Arrow Up key for this scenario.

        static async Task PressArrowUp(ClientWebSocket ws, int id)
        {
            var keyDownCommand = new
            {
                id,
                method = "Input.dispatchKeyEvent",
                @params = new
                {
                    type = "keyDown",
                    key = "ArrowUp",
                    code = "ArrowUp",
                    keyCode = 38
                }
            };
            await SendAndReceive(ws, keyDownCommand);

            var keyUpCommand = new
            {
                id = id + 1,
                method = "Input.dispatchKeyEvent",
                @params = new
                {
                    type = "keyUp",
                    key = "ArrowUp",
                    code = "ArrowUp",
                    keyCode = 38
                }
            };
            await SendAndReceive(ws, keyUpCommand);
        }

After this step, you can press the TAB key to move the focus to the input element.

        static async Task PressTab(ClientWebSocket ws, int id)
        {
            var command = new
            {
                id,
                method = "Input.dispatchKeyEvent",
                @params = new
                {
                    type = "keyDown",
                    key = "Tab",
                    code = "Tab",
                    windowsVirtualKeyCode = 9,
                    nativeVirtualKeyCode = 9
                }
            };
            await SendAndReceive(ws, command);

            command = new
            {
                id = id + 1,
                method = "Input.dispatchKeyEvent",
                @params = new
                {
                    type = "keyUp",
                    key = "Tab",
                    code = "Tab",
                    windowsVirtualKeyCode = 9,
                    nativeVirtualKeyCode = 9
                }
            };
            await SendAndReceive(ws, command);
        }

Finally, type the text into the input field.

        static async Task TypeText(ClientWebSocket ws, string text, int startId)
        {
            int id = startId;
            foreach (char c in text)
            {
                var command = new
                {
                    id = id++,
                    method = "Input.dispatchKeyEvent",
                    @params = new
                    {
                        type = "keyDown",
                        text = c.ToString(),
                        unmodifiedText = c.ToString(),
                        key = c.ToString(),
                        code = c.ToString(),
                        keyCode = (int)c
                    }
                };
                await SendAndReceive(ws, command);

                command = new
                {
                    id = id++,
                    method = "Input.dispatchKeyEvent",
                    @params = new
                    {
                        type = "keyUp",
                        text = c.ToString(),
                        unmodifiedText = c.ToString(),
                        key = c.ToString(),
                        code = c.ToString(),
                        keyCode = (int)c
                    }
                };
                await SendAndReceive(ws, command);
            }
        }

Let's test it out. As you can see, the password input field has been successfully filled.

Bonus

When scraping or automating actions, using proxy servers is often essential. Typically, you might install a system-wide proxy application that affects your entire PC. However, I’ll show you how to configure a proxy locally, specifically for your project.

One way to achieve this is by creating a custom Chrome extension. This requires just a few lines of code along with a manifest file.

The manifest is a JSON file that defines settings and permissions for the extension.

{
  "manifest_version": 3,
  "name": "Proxy Auth Extension",
  "version": "1.0",
  "permissions": [
    "proxy",
    "storage",
    "webRequest",
    "webRequestAuthProvider",
    "declarativeNetRequestWithHostAccess"
  ],
  "host_permissions": [
    "*://*/*"
  ],
  "background": {
    "service_worker": "background.js"
  }
}

The second file allows you to fill in the credentials automatically.

chrome.runtime.onInstalled.addEventListener(() => {
    console.log("Proxy Auth Extension installed.");
});

chrome.webRequest.onAuthRequired.addEventListener(
    (details) => {
        console.log("Auth request detected for:", details.url);
        return {
            authCredentials: {
                username: "your_proxy_username",
                password: "your_proxy_password",
            }
        };
    },
    { urls: ["<all_urls>"] },
    ["blocking"]
);

The final step is to add the launch parameters.

            var psi = new ProcessStartInfo
            {
                FileName = chromePath,
                Arguments = string.Join(" ",
                    $"--remote-debugging-port={port}",
                    "--ignore-certificate-errors",
                    "--load-extension=/Users/serhiikorol/RiderProjects/Scarping/Scarping/Extensions/proxy-auth-extension",
                    "--proxy-server=http://brd.superproxy.io:33335",
                    "--no-first-run",
                    $"--user-data-dir={userDataDir}",
                    "https://selectorshub.com/xpath-practice-page/")
            };

If you’ve entered the correct credentials, the target page will load successfully.

Final words

I’ve shown you an alternative approach to managing your browser. While it may seem more complex compared to Selenium or Puppeteer-Sharp, using the Chrome DevTools Protocol (CDP) directly provides greater control and flexibility.

NuGet packages can sometimes contain errors or compatibility issues with your current Chrome version. By using CDP directly, you can avoid these problems and ensure a more stable automation process.

I hope you found this article helpful. See you next time!

Source code here.