Forem: Olabamiji Oyetubo

How I Use Claude Code and Codex Together to Build .NET Features Faster

Olabamiji Oyetubo — Sun, 19 Apr 2026 10:50:30 +0000

When most developers discover AI coding tools, they pick one and use it for everything. Chat with it, paste code in, copy code out. One tool, one workflow, every problem.

That works until you notice the cracks. The AI forgets what you told it ten messages ago. It generates code that doesn't match your project's patterns. You spend more time correcting it than you saved using it. And your token costs keep climbing.

I use Claude Code and Codex together on every .NET feature I build now. Claude plans. Codex builds. A single markdown file connects them.

This article will show exactly how it works.

The Problem With Using One Tool for Everything

If you've used Claude or Copilot for anything beyond a quick snippet, you've felt this:

The context problem. AI tools work best when they have rich context about your project.
But feeding that context costs tokens, takes time, and has to be repeated every session. The more complex your project, the worse this gets.

The consistency problem. Ask an AI to implement something without enough context and it generates code that doesn't match your conventions. Wrong patterns, wrong folder structure, wrong naming. You spend the time you saved fixing what was generated.

The cost problem. Using a powerful, context-aware model for every line of code is like hiring an architect to lay bricks. It's valuable, but not the most efficient use of the skillset.

The insight that changed my workflow: planning and implementation are different jobs. They need different things from an AI tool. Once I split them, everything got faster, cheaper, and more consistent.

The Two Roles — and Why Each Tool Fits

Claude Code — the planner

Claude Code runs in your terminal with full access to your codebase. Combined with a well-written CLAUDE.md file, it knows your project's architecture, naming conventions, existing services, and the rules Claude should follow.
You can learn more about setting up Claude and CLAUDE.md files here.

This makes Claude exceptional at reasoning. It can look at your actual code, understand what already exists, and produce a plan that fits your use case.

What Claude is doing in this workflow: thinking, planning, and writing the spec.It burns tokens once to understand the codebase deeply, then produces a clear, self-contained task document. That upfront investment pays off every time Codex uses the output.

Codex — the implementer

Codex is fast and focused. It excels at taking a clear, well-scoped specification and turning it into working code. It does not need to explore your entire codebase, just a good brief.

That's exactly what Claude provides.

What Codex is doing in this workflow: reading the task file Claude produced and implementing it. No context exploration, no pattern guessing, no wasted tokens on things it doesn't need to know.

Why this split works

	Claude Code	Codex
Strength	Reasoning, planning, context	Implementation, speed
Needs	Full project context	A clear, focused spec
Cost	Higher per token — used once for planning	Lower per token — used for execution
Role in workflow	Architect	Builder

The Workflow — Step by Step

Here is the exact workflow I follow, demonstrated by adding a real feature to SensorIngestApi — a device registration endpoint that did not exist before. This is not a staged demo. This is the actual feature being built.

Step 1 — Open Claude Code in the project repo

cd C:\Users\source\repos\SensorIngestApi
claude

Claude reads CLAUDE.md automatically. It already knows SensorIngestApi's
structure — the Controllers, Services, Interfaces, Data folders, the TimescaleDB setup, the SignalR hub, the channel pipeline, and the conventions the project follows. No manual context-pasting required.

Step 2 — Tell Claude what you want to build

Give Claude a plain description of the feature. You do not need to be precise. Claude's job in this step is to turn your rough idea into a precise spec.

I want to add a device registration endpoint to SensorIngestApi.
Devices should be stored in the database and we need to prevent duplicates.
Keep it consistent with how ReadingsController, StatsController,
and AlertsController work.

Claude reads the existing controllers, checks TelemetryDbContext, looks at the existing models, and asks any clarifying questions it needs before writing the spec. Because CLAUDE.md is loaded, it already knows the conventions,
IActionResult, ILogger<T>, CancellationToken, file-scoped namespaces without you having to repeat them.

Step 3 — Have Claude write task.md

Once Claude understands the feature, ask it to write the implementation brief:

Write a task.md file in the repo root that Codex can read to implement this.
Include all the context Codex will need — what to build, which files to touch,
and the conventions to follow.

Claude produces a structured markdown file and writes it directly to disk. It includes everything Codex needs and nothing it doesn't.

Step 4 — Open Codex in the same directory

Switch to Codex. Because it is running in the same directory, it can read the task.md file Claude just wrote.

Read task.md and implement everything described in it.

Codex reads the spec and implements. It follows the conventions Claude documented because they are written explicitly in the task file — not assumed from context it does not have.

Step 5 — Review with Claude

Once Codex has implemented, switch back to Claude Code for a quick review:

@code-reviewer review the files Codex just created against our CLAUDE.md conventions

Claude checks the output against your project standards and flags anything that slipped through.

After the review Claude gives a summary of what was good and what needs to be fixed,

You can then go through the process again: Claude Code drafts a fix plan -> Writes to task.md -> Codex implements fix.

What Goes in task.md — A Real Example

The quality of task.md determines the quality of Codex's output.
Claude writes it based on what it read from the codebase and CLAUDE.md, you do not write it manually.

# Task: Add Device Registration Endpoint

## Goal
Add a POST /devices endpoint that registers a device by DeviceId.
Registering the same device twice returns 409 Conflict.
Add a GET /devices endpoint to list all registered devices.

## Files to create
- SensorIngestApi/Models/Device.cs
- SensorIngestApi/Controllers/DevicesController.cs

## Files to modify
- SensorIngestApi/Data/TelemetryDbContext.cs (add DbSet<Device>)

## Conventions to follow
- IActionResult returns (not TypedResults — controller-based project)
- All DB calls async with CancellationToken forwarded
- ILogger<T> only — never Console.WriteLine
- null! on required EF Core string properties with a comment explaining why
- No new NuGet packages needed

The full task.md includes complete file contents, exact EF Core configuration, migration commands, and a "What NOT to do" section. I've linked it in the GitHub repo.

The Token Economics

This workflow is not just faster, it is meaningfully cheaper than using one tool for everything.

Without the split: You feed Claude (or any powerful model) the full codebase context on every implementation request. Every feature, every bug fix, every refactor, full context, full cost, every time.

With the split: Claude reads the full context once per planning session and produces or edits task.md. Codex receives a focused, self-contained spec with no wasted tokens on context it does not need. The expensive reasoning happens once. The cheap implementation happens as many times as needed.

What This Looks Like End to End

1. cd SensorIngestApi → claude
   CLAUDE.md loads — project context ready

2. "I want to add a device registration endpoint.
    Keep it consistent with ReadingsController."

3. "Write a task.md Codex can use to implement this."
    Claude reads the codebase, writes task.md to disk

4. Switch to Codex — same directory
   "Read task.md and implement everything in it."
   Codex creates DevicesController, Device model,
   updates TelemetryDbContext, flags migration needed

5. Back to Claude:
   "@code-reviewer review the files Codex just created"
   Claude checks against CLAUDE.md, returns verdict

6. Run migration, commit, done

Total prompts: 3 in Claude, 1 in Codex.
Total context feeding: once, at the start.
Result: a working DevicesController that looks like it was written by someone who knows the codebase.

Closing

The Claude + Codex split is not about which tool is better.
It is about using each tool for what it is actually good at.

Claude thinks. Codex builds. task.md is the contract between them.

Once you try this on a real feature it is hard to go back. The planning step forces clarity you would have skipped. The implementation step is faster because the spec is precise. The review step catches what slipped through. One habit that makes the whole thing safer is to commit after every step. When task.md is written, commit. When Codex finishes, commit. When the review is clean, commit. AI tools make mistakes and small frequent commits are your save points. Think of it like a video game, you would not play an hour without saving and then hand the controller to someone else!

Happy Coding!!!

How to Set Up Claude Code on an Existing .NET Project

Olabamiji Oyetubo — Tue, 07 Apr 2026 14:27:09 +0000

You've probably used Claude or ChatGPT to help you write C# code. You paste in a class, ask it to add a method, copy the result back. That approach works but its not the most optimal.

There's times where it can suggest something that does not match the rest of the codebase, simply because it does not have the full context of the code.

The problem isn't the AI/LLM. The problem is that every conversation starts from zero. Claude/ChatGPT have no idea what your project looks like, what patterns you follow, or what you've already decided. You're giving it a piece of the puzzle and hoping it guesses the rest.

Claude Code fixes this, and in this article, I'll show you how to set it up on an existing .NET project.

What is Claude Code ?

Claude Code is Anthropic's CLI tool for using Claude directly in your terminal, inside your actual codebase. Instead of copying code back and forth in a chat window, Claude reads your files, makes changes, runs commands, and works alongside you in the repo.

The difference from chat isn't the interface, it's the context. Claude Code can see your entire codebase. It can read your files, check your dependencies, understand your folder structure, and make changes directly.

But that only matters if you tell it what to do with all that context.

That's where a CLAUDE.md file comes in.

Claude Code setup/
├── CLAUDE.md                    # Project context — read every session
├── .claude/
│   ├── commands/                # Slash commands — reusable .NET workflows
│   │   ├── scaffold-endpoint
│   │   ├── add-command
│   │   ├── add-query
│   │   ├── add-migration
│   │   ├── write-tests
│   │   └── add-service
│   └── agents/                  # Personas — specialist modes on demand
│       ├── @code-reviewer
│       ├── @architect
│       ├── @test-writer
│       └── @doc-writer
└── integrations/                # MCP configs — external tool connections
    ├── github/
    ├── azure-devops/
    ├── jira/
    └── slack/

The CLAUDE.md File

CLAUDE.md is a markdown file you place at the root of your repo. Claude Code reads it automatically at the start of every session. It's the document that tells Claude everything it needs to know to work effectively without you having to repeat yourself.

Think of it like onboarding a new developer. You wouldn't hand them a ticket and walk away. You'd tell them: here's the architecture, here's how we name things, here are the patterns we use, here's what we never do. CLAUDE.md is that conversation, written down once and reused forever.

Contents of a CLAUDE.md

A good CLAUDE.md for a .NET project covers:

Project identity — what the solution is called, where the .sln file lives,
what .NET version you're targeting, and one sentence describing what the system does.

Repository structure — the actual folder tree. Claude should not have to guess where your controllers live or whether you have separate Application and Infrastructure projects.

Architecture — the patterns in use and the rules that come with them. If you're using Clean Architecture, Claude needs to know the layer boundaries. If you're using CQRS with MediatR, it needs to know where Commands and Queries live. If you have a
simpler folder-based structure, it needs to know that too, and what each folder is responsible for.

Coding standards — your actual conventions. Nullable reference types on or off. Whether you use var freely or sparingly. Async method naming. Error handling approach.
The things that make a PR reviewer say "this doesn't look like our code."

Testing — which framework, which mock library, and what the naming convention is. Claude generates a lot of tests. They should look like your tests, not generic ones.

Behaviour rules — explicit "always do" and "never do" instructions. This is where you eliminate the most common AI frustrations. Things like:

Never put business logic in a controller
Always use ILogger, never Console.WriteLine
Never add a NuGet package without flagging it first
Always generate an EF Core migration when changing the schema

A real example

## Project Overview
**Project name:** SensorIngestApi
**Solution file:** SensorIngestApi.sln
**Target framework:** net8.0
**Description:** High-throughput sensor telemetry API — accepts readings via HTTP,
routes through a channels pipeline, detects anomalies, persists to TimescaleDB,
and streams real-time stats via SignalR.

## Repository Structure
SensorIngestApi/
  Controllers/    # API controllers
  Services/       # Background workers and core services
  Interfaces/     # Service contracts
  Models/         # Domain models
  Data/           # EF Core DbContext

## Claude Behaviour for This Project

### Always do
- Use ILogger<T> with structured message templates — never Console.WriteLine
- Consider back-pressure on every change to the channel pipeline
- Use existing IThroughputStats, IAggregator, IAlertBus abstractions

### Never do
- Add NuGet packages without explaining why
- Change the database schema without generating an EF Core migration
- Use .Result or .Wait() on async operations
- Use Thread.Sleep — use Task.Delay with CancellationToken

MCP Integrations and Connecting Claude to Your Tools

MCP (Model Context Protocol) is how Claude Code connects to external tools. With the right MCP server configured, Claude can read your GitHub issues, check open PRs, look up Jira tickets, and search Slack threads, all without you leaving the terminal.

For most .NET projects, GitHub is the one to set up first. The config is straightforward:

{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "${GITHUB_PERSONAL_ACCESS_TOKEN}"
      }
    }
  }
}

Drop this in your Claude Code settings and Claude can do things like:

Can you check if there's already a GitHub issue for the sensor timeout bug?

Commit and push this this implementation to the target branch

Other useful integrations for .NET teams: Azure DevOps (work items and pipelines), Jira (issues and sprints), and Slack (thread summaries).

Slash Commands — Reusable Workflows for .NET

Slash commands are reusable prompt templates stored as markdown files in .claude/commands/.
You invoke them with /command-name and Claude executes the instructions inside.

For .NET projects, the commands that save the most time are the ones you'd otherwise type from scratch every session. Here are a few that have become part of my workflow:

/scaffold-endpoint — scaffolds a Controller action with the right attributes, IMediator injection, CancellationToken, and ProducesResponseType declarations. One command instead of copying and adapting from an existing controller.

/add-command — generates all three files for a CQRS Command in one shot: the command record, the handler, and the FluentValidation validator. All in the right folder, all following the project's naming convention.

/write-tests — reads the actual class, identifies its constructor dependencies, and generates an NUnit + Moq test skeleton with the right mock setup and a baseline set of test scenarios. It won't write the test logic for you, but it eliminates the boilerplate that makes developers avoid writing tests in the first place.

These commands know your project's conventions, and combined with what is in your defined CLAUDE.md file, the generated code
looks like your code, not generic code.

Agent Personas — Modes for Different Tasks

Agent personas are a way to put Claude into a specific mode for a specific task. You activate one by mentioning it by name in your prompt.

The one I reach for most is @code-reviewer:

@code-reviewer review the changes in OrderController.cs

Rather than a generic review, it checks against the specific conventions in your CLAUDE.md like layer boundaries, naming, async patterns, error handling. It labels findings as [VIOLATION] (must fix) or [SUGGESTION] (worth considering) and ends with a clear verdict. It reads like a review from someone who actually knows the codebase.

Other useful personas for .NET work: @architect for design decisions and layer questions, @test-writer for generating full test coverage, and @doc-writer for XML comments, ADRs, and API documentation.

What a Session Actually Looks Like

Before — without proper setup

You: Can you create an Order controller for my .NET API?
Claude: [generates a controller with logic directly in the action methods,
         no MediatR, no CancellationToken, wrong folder location,
         inconsistent naming with the rest of the project]
You: No, we use MediatR. Here's how our handlers work...
Claude: [tries again, still puts business logic in the wrong place]
You: [spends 10 minutes fixing and reorganising what was generated]

After — with CLAUDE.md, commands, and MCP configured

You: /scaffold-endpoint Order POST api/orders
Claude: [reads CLAUDE.md, generates a thin Controller with IMediator
         injection, correct ProducesResponseType attributes,
         CancellationToken, points to /api-add-command as next step]

You: /add-command CreateOrder
Claude: [generates CreateOrderCommand record, CreateOrderCommandHandler,
         and CreateOrderCommandValidator — all in the correct
         Application/Commands/CreateOrder/ folder, following the
         project's naming conventions]

You: @code-reviewer review the three new files
Claude: [checks against CLAUDE.md conventions, flags one missing
         null check on the command property, approves everything else,
         returns verdict: APPROVED WITH SUGGESTIONS]

Getting Started

Setting this up properly takes about an hour on a project you already know well.
The rough steps:

Install Claude Code: npm install -g @anthropic-ai/claude-code
Create CLAUDE.md at your repo root and start with Project Overview, Repository Structure, and the Behaviour Rules sections. Those three alone make a noticeable difference.
Add a GitHub MCP config so Claude can see your issues and PRs
Open Claude Code in your repo from the terminal by running claude

The more honest you are in CLAUDE.md about how the project actually works, the better Claude performs. A CLAUDE.md that says "we use Clean Architecture" when the project is actually a flat folder structure will cause more confusion than no CLAUDE.md at all.

Closing

Claude Code is genuinely useful for .NET development. But like most tools, the difference between this is okay and this has changed how I work is in the setup.

CLAUDE.md is the foundation. Everything else like commands, personas, integrations just build on top of it. Get that right first and every other thing will be seamless.

Happy coding!!!

[Boost]

Olabamiji Oyetubo — Sat, 04 Apr 2026 10:24:14 +0000

fmerian

Apr 3

Who's hiring — April 2026

#career #devrel #opensource #startup

Comments 1

2 min read

Using Mockaroo and Entity framework to Seed Sample Data for .NET Applications

Olabamiji Oyetubo — Mon, 15 Dec 2025 13:38:39 +0000

Testing your applications thoroughly requires diverse sample data that's often time-consuming to create manually. Mockaroo simplifies this process by generating realistic test data quickly, and today we'll explore how to use it.

The only thing you’ll need for this tutorial is Visual Studio community edition. You can download it here

Create a Dataset in Mockaroo

Navigate to the Mockaroo Website,
and define the Dataset fields, I have defined mine like so;

Since we’re going to seed the data through EF Core, we’ll select the output format as JSON.

Click on GENERATE DATA and the output file should be downloaded.

Create a Web API project

Open up Visual Studio and click Create a new Project
In the Search Template field, search for ASP.NET Core Web API and click on it.

Give your project a name, I have called mine Mockaroo_Test, then Select .NET 10 as the target framework and leave all the other options as the default values then click Create.

Next, we’re going to install the necessary packages into our project, so open up the package manager console and type in the following commands;

Install-Package Microsoft.EntityFrameworkCore

Install-Package Microsoft.EntityFrameworkCore.InMemory

Install-Package Microsoft.EntityFrameworkCore.Design

Next, Create the a class that has the same structure as the Mockaroo DataSet options we defined earlier

    public class Club
    {
        public int Id { get; set; }

        [JsonPropertyName("club_name")]
        public string ClubName { get; set; }

        [JsonPropertyName("country_location")]
        public string CountryLocation { get; set; }

        [JsonPropertyName("stadium_capacity")]
        public int StadiumCapacity { get; set; }

        [JsonPropertyName("manager_name")]
        public string ManagerName { get; set; }

        [JsonPropertyName("founded_year")]
        public int FoundedYear { get; set; }

        [JsonPropertyName("league_affiliation")]
        public string LeagueAffiliation { get; set; }

        [JsonPropertyName("captain_name")]
        public string CaptainName { get; set; }

        [JsonPropertyName("jersey_color")]
        public string JerseyColor { get; set; }

        [JsonPropertyName("average_attendance")]
        public int AverageAttendance { get; set; }

        [JsonPropertyName("major_rival")]
        public string MajorRival { get; set; }
    }

Now, create a new class called AppDbContext and copy this code into it;

   public class AppDbContext : DbContext
   {
       public AppDbContext(DbContextOptions<AppDbContext> options) : base(options)
       {
       }
       public DbSet<Club> Clubs { get; set; }
   }

Since we’re using an Inmemory database, we need to wire it up in our application, so navigate to the Program.cs class and add this piece of code;

builder.Services.AddDbContext<Mockaroo_Test.AppDbContext>(options =>
{
    options.UseInMemoryDatabase("MockarooDemoDb");
});

Seeding the Data

The next step is to move the .json file downloaded from Mockaroo into your application folder, like so;

Let's then create the class the serializes the data. Do that by creating a class called SeedData and adding this code to it;

    public class SeedData
    {
        public static async Task SeedAsync(AppDbContext context)
        {
            if (context.Clubs.Any()) return;

            var json = await File.ReadAllTextAsync("MOCK_DATA.json");
            var clubs = JsonSerializer.Deserialize<List<Club>>(json);

            context.Clubs.AddRange(clubs!);
            await context.SaveChangesAsync();
        }
    }

The SeedAsync method loads starter information about clubs into the system. It first checks if any clubs already exist, and if the system is empty, it reads club details from a file, converts that information into a usable format, and stores it in the database.

Navigate back to Program.cs and add this piece of code to wire everything up;

using (var scope = app.Services.CreateScope())
{
    var db = scope.ServiceProvider.GetRequiredService<AppDbContext>();
    await SeedData.SeedAsync(db);
}

NB; This code snippet should come after the declaration of the app variable

var app = builder.Build();

And that’s it, If you run the application the MockarooDemoDb Database gets seeded with data from our MOCK_DATA.json file.

We can go one step further and visualize the data to make sure.

In the Controllers folder, Create a class called ClubController with this piece of code;

[ApiController]
[Route("api/[controller]")]
public class ClubContronller : ControllerBase
{
    private readonly AppDbContext _context;

    public ClubContronller(AppDbContext context)
    {
        _context = context;
    }

    [HttpGet]
    public async Task<ActionResult<List<Club>>> Get()
    {
        var clubs = await _context.Clubs.ToListAsync();
        return Ok(clubs);
    }
}

I’ll be using swagger to visualize the data, you can set up swagger for newer .NET projects using this article here

Run the project and navigate to the swagger page.
When you click execute on the GET Endpoint for clubs, we should see the data

If you got lost somewhere along the way, the entire project can be found here

Happy Coding!

Part 2 - High Volume Ticket Booking System using C#, EF Core, Redis Cache and SQL Server

Olabamiji Oyetubo — Sat, 16 Aug 2025 19:57:40 +0000

In Part 1, we built the BookingService and successfully booked a request. However, this was done as a one-off API call, which isn’t the most efficient approach.

In this article, we'll add a Background worker that queues Booking Requests and executes them in the background. We'll also introduce a Redis cache to save frequently assessed seats in a Booking request, which will reduce the load and effort on the database and ultimately improve the performance of the system.

Let's begin.

In TicketBooking.Application, run this command to install the package as we'll be needing it;

Install-Package Microsoft.Extensions.Hosting.Abstractions

Next, add a folder called BackgroundServices and then add these 3 classes BackgroundBookingWorker, IBackgroundBookingQueue, BackgroundBookingQueue with these code snippets

 public interface IBackgroundBookingQueue
 {
     void QueueBooking(AddBookingDto request);
     IAsyncEnumerable<AddBookingDto> DequeueAsync(CancellationToken cancellationToken);
 }

public class BackgroundBookingQueue : IBackgroundBookingQueue
{
    private readonly Channel<AddBookingDto> _queue;

    public BackgroundBookingQueue()
    {
        _queue = Channel.CreateBounded<AddBookingDto>(100);
    }

    public void QueueBooking(AddBookingDto request)
    {
        if (!_queue.Writer.TryWrite(request))
        {
            throw new InvalidOperationException("Booking queue is full.");
        }
    }

    public async IAsyncEnumerable<AddBookingDto> DequeueAsync(CancellationToken cancellationToken)
    {
        while (await _queue.Reader.WaitToReadAsync(cancellationToken))
        {
            while (_queue.Reader.TryRead(out var item))
            {
                yield return item;
            }
        }
    }
}

We created an IBackgroundBookingQueue class, with 2 methods, QueueBooking and DequeueAsync . The former adds a Booking request to the background queue for processing, while the latter asynchronously retrieves the Booking Requests from the queue and processes them.

public class BackgroundBookingWorker : BackgroundService
{
    private readonly IBackgroundBookingQueue _queue;
    private readonly IServiceScopeFactory _scopeFactory;
    private readonly ILogger<BackgroundBookingWorker> _logger;

    public BackgroundBookingWorker(
        IBackgroundBookingQueue queue,
        IServiceScopeFactory scopeFactory,
        ILogger<BackgroundBookingWorker> logger)
    {
        _queue = queue;
        _scopeFactory = scopeFactory;
        _logger = logger;
    }

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        _logger.LogInformation("BackgroundBookingWorker started.");

        await foreach (var bookingRequest in _queue.DequeueAsync(stoppingToken))
        {
            using var scope = _scopeFactory.CreateScope();
            var bookingService = scope.ServiceProvider.GetRequiredService<IBookingService>();

            try
            {
                await bookingService.BookSeatsAsync(bookingRequest);
                _logger.LogInformation("Processed booking for screening {ScreeningId}", bookingRequest.ScreeningId);
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Failed to process booking for screening {ScreeningId}", bookingRequest.ScreeningId);
            }
        }

        _logger.LogInformation("BackgroundBookingWorker stopped.");
    }
}

Here, the BackgroundBookingWorker implements the out of the box BackgroundService class, and then listens constantly for new Booking Requests from IBackgroundBookingQueue and processes them via the ExecuteAsync method.

Next, in TicketBooking.API, navigate to the BookingController in the Controllers folder and add this new method;

[HttpPost]
[Route("queue-booking")]
public IActionResult QueueBooking([FromBody] AddBookingDto request)
{
    _queue.QueueBooking(request);
    return Ok("Booking has been queued successfully");
}

Don't forget to add the new queue property and inject it via the constructor

   private readonly IBookingService _bookingService;
   private readonly IBackgroundBookingQueue _queue;

   public BookingController(IBookingService bookingService, IBackgroundBookingQueue queue)
   {
       _bookingService = bookingService;
       _queue = queue;
   }

And register the new DI via the Program.cs

builder.Services.AddSingleton<IBackgroundBookingQueue, BackgroundBookingQueue>();
builder.Services.AddHostedService<BackgroundBookingWorker>();

When you run the project and execute the QueueBooking endpoint with this payload

{
  "nameOfPerson": "Holland Thompson",
  "screeningId": 3,
  "seatNumbers": [
    "A1","A2"
  ]
}

We get a response the the booking has been queued;

If you navigate to the Logs folder in the project, where we have logged out background process, we see the process Logged and the Booking process has started.

Great, now the last thing we want to do is add a Redis Cache to make sure we don't always have to hit the Database for each request, especially Movies or Seats that are frequently assessed.

In TicketBooking.API add the below package;

Install-Package StackExchange.Redis

Next, in TicketBooking.Application, Navigate to Services --> BookingService and edit the class this way

public class BookingService : IBookingService
{
    private readonly ILogger<BookingService> _logger;
    private readonly ApplicationDbContext _context;
    private readonly IDistributedCache _cache;

    public BookingService(ApplicationDbContext context, ILogger<BookingService> logger, IDistributedCache cache)
    {
        _context = context;
        _logger = logger;
        _cache = cache;
    }

    public async Task<bool> BookSeatsAsync(AddBookingDto bookingDto)
    {
        _logger.LogInformation("Booking started for screening {ScreeningId} with seats: {Seats}",
        bookingDto.ScreeningId, string.Join(", ", bookingDto.SeatNumbers));

        Screening? screening;
        var cacheKey = $"screening:{bookingDto.ScreeningId}";
        try
        {
            var cachedScreening = await _cache.GetStringAsync(cacheKey);
            if (!string.IsNullOrEmpty(cachedScreening))
            {
                screening = JsonSerializer.Deserialize<Screening>(cachedScreening, new JsonSerializerOptions
                {
                    ReferenceHandler = ReferenceHandler.IgnoreCycles,
                    PropertyNameCaseInsensitive = true
                })!;
                _logger.LogInformation("Screening loaded from Redis cache.");
            }
            else
            {
                screening = await _context.Screenings
                    .Include(s => s.Seats)
                    .FirstOrDefaultAsync(s => s.Id == bookingDto.ScreeningId);

                if (screening == null)
                {
                    _logger.LogWarning("Screening not found for ID: {ScreeningId}", bookingDto.ScreeningId);
                    return false;
                }

                var serialized = JsonSerializer.Serialize(screening, new JsonSerializerOptions
                {
                    ReferenceHandler = ReferenceHandler.IgnoreCycles,
                    WriteIndented = false
                });

                await _cache.SetStringAsync(cacheKey, serialized, new DistributedCacheEntryOptions
                {
                    AbsoluteExpirationRelativeToNow = TimeSpan.FromMinutes(10)
                });

                _logger.LogInformation("Screening cached to Redis.");
            }

            var targetSeats = screening.Seats
               .Where(seat => !string.IsNullOrWhiteSpace(seat.SeatNumber)
               && bookingDto.SeatNumbers.Contains(seat.SeatNumber))
               .ToList();

            if(targetSeats.Any(x => x.IsBooked))
            {
                //Seats are taken
                _logger.LogWarning("No available seats found for booking for screening {ScreeningId} with seats: {Seats}",
                    bookingDto.ScreeningId, string.Join(", ", bookingDto.SeatNumbers));
                IEnumerable<string> seatNumber = targetSeats.Where(x => x.IsBooked).Select(x => x.SeatNumber);
                throw new SeatAlreadyBookedException(seatNumber);
            }

            if(targetSeats.Count == 0)
            {
                //Seats does not exist
                _logger.LogWarning("Seats not found for booking for screening {ScreeningId} with seats: {Seats}",
                    bookingDto.ScreeningId, string.Join(", ", bookingDto.SeatNumbers));
                throw new AppException("Seats not found for booking", 404);
            }

            foreach (var seat in targetSeats)
            {
                seat.IsBooked = true;
            }

            var booking = new Core.Entities.Booking
            {
                NameOfPerson = bookingDto.NameOfPerson,
                ScreeningId = bookingDto.ScreeningId,
                BookedSeats = targetSeats.Select(s => s.SeatNumber).ToList(),
                BookedAt = DateTime.UtcNow
            };

            _context.Bookings.Add(booking);

            await _context.SaveChangesAsync();

            await _cache.RemoveAsync(cacheKey);
            _logger.LogInformation("Cache invalidated for screening {ScreeningId}", bookingDto.ScreeningId);

            return true;
        }
        catch (AppException ex)
        {
            _logger.LogWarning(ex, "Booking failed due to: {Message}", ex.Message);
            throw;
        }
        catch (DbUpdateConcurrencyException ex)
        {
            _logger.LogError(ex, "Concurrency conflict while booking seats for screening {ScreeningId}", bookingDto.ScreeningId);
            throw new AppException("Seat booking failed due to a concurrency issue. Please try again.", 409);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Unexpected error in BookSeatsAsync for screening {ScreeningId}", bookingDto.ScreeningId);
            throw;
        }
    }
}

We have introduced the new property

private readonly IDistributedCache _cache;

And then in BookSeatsAsync we have added this block of code;

      var cacheKey = $"screening:{bookingDto.ScreeningId}";
        try
        {
            var cachedScreening = await _cache.GetStringAsync(cacheKey);
            if (!string.IsNullOrEmpty(cachedScreening))
            {
                screening = JsonSerializer.Deserialize<Screening>(cachedScreening, new JsonSerializerOptions
                {
                    ReferenceHandler = ReferenceHandler.IgnoreCycles,
                    PropertyNameCaseInsensitive = true
                })!;
                _logger.LogInformation("Screening loaded from Redis cache.");
            }

We have generated a cacheKey property out of the ScreeningId. It then tries to get cached screening Data from Redis, If cached data is found it deserializes the found data and avoids having to make a database call.

In the Else block, we also have this new implementation;

   else
   {
       screening = await _context.Screenings
           .Include(s => s.Seats)
           .FirstOrDefaultAsync(s => s.Id == bookingDto.ScreeningId);

       if (screening == null)
       {
           _logger.LogWarning("Screening not found for ID: {ScreeningId}", bookingDto.ScreeningId);
           return false;
       }

       var serialized = JsonSerializer.Serialize(screening, new JsonSerializerOptions
       {
           ReferenceHandler = ReferenceHandler.IgnoreCycles,
           WriteIndented = false
       });

       await _cache.SetStringAsync(cacheKey, serialized, new DistributedCacheEntryOptions
       {
           AbsoluteExpirationRelativeToNow = TimeSpan.FromMinutes(10)
       });

       _logger.LogInformation("Screening cached to Redis.");
   }

Here we are adding a new entry to the cache that is frequently accessed.

We also have this block;

await _cache.RemoveAsync(cacheKey);

Which updates a cache entry, ensuring that outdated or irrelevant data is removed from Redis.

And that's it, we have now been able to add a cache to the application which will undoubtedly improve the perfomance of the entire system.

If you got lost somewhere along the way, the entire part 2 project branch can ben found here

Happy coding.

Part 1 - High Volume Ticket Booking System using C#, EF Core, Redis Cache and SQL Server

Olabamiji Oyetubo — Sun, 10 Aug 2025 13:00:04 +0000

A few weeks ago, I went to the cinemas to watch Superman. As expected for a blockbuster, the ticket lines were incredibly long, and the cashiers weren't helping much. This experience got me thinking, 'Why not build an app to simplify this?' And that's exactly what we'll do in this article.

This project will follow Clean architechure, and other best practices to make sure it's scalable.

Part 1 of this project will focus on scaffolding the entire application, Database connection and making sure we can at least make a booking.

In Part 2, we'll focus on Scalability by introducing Background workers and Redis cache

This is going to be the structure of our project

TicketBooking.sln
├─ TicketBooking.API                 // Controllers, Program.cs, DI
├─ TicketBooking.Core                // Entities, DTOs, Exceptions
├─ TicketBooking.Application         // Services, Interfaces (use cases)
├─ TicketBooking.Infrastructure      // DbContext, Migrations, Seed
└─ TicketBooking.Tests               // Unit tests NUnit + Moq

Now, create a folder called TicketBooking and cd into that folder in the command line.

Then execute these commands to create all the projects

dotnet new sln -n TicketBooking
dotnet new webapi -n TicketBooking.API
dotnet new classlib -n TicketBooking.Core
dotnet new classlib -n TicketBooking.Application
dotnet new classlib -n TicketBooking.Infrastructure
dotnet new nunit -n TicketBooking.Tests
dotnet sln add **/*.csproj

Your Solution should look like this

If any project is missing, right-click the TicketBooking solution in the Solution Explorer, then select Add --> Existing Project.
Navigate to the respective project folder and select the .csproj file for that

Now, Let's begin to build the application.

In TicketBooking.Core, add these 4 folders Dtos, Entities, Exceptions, Interfaces

In the Dtos folder, add a class called AddBookingDto with the below code

public class AddBookingDto
{
    public string NameOfPerson { get; set; } = string.Empty;
    public int ScreeningId { get; set; }
    public List<string> SeatNumbers { get; set; } = new List<string>();
}

Next, in the Entities folder add the 4 classes Booking, Movie, Screening, Seat with the following code;

public class Booking
{
    public int Id { get; set; }

    public int ScreeningId { get; set; }

    public List<string> BookedSeats { get; set; } = new List<string>();

    public string NameOfPerson { get; set; }

    public DateTime BookedAt { get; set; } = DateTime.UtcNow;
}

public class Screening
{
    public int Id { get; set; }
    public int MovieId { get; set; }
    public DateTime StartTime { get; set; }
    public ICollection<Seat> Seats { get; set; } = new List<Seat>();
}

public class Movie
{
    public int Id { get; set; }
    public string Title { get; set; } = string.Empty;
    public ICollection<Screening> Screenings { get; set; } = new List<Screening>();
}

public class Seat
{
    public int Id { get; set; }
    public int ScreeningId { get; set; }
    public string SeatNumber { get; set; } = string.Empty;
    public bool IsBooked { get; set; }
}

Next, In our Extensions folder, we'll add 2 classes AppException and SeatAlreadyBookedException

 public class AppException : Exception
 {
     public int StatusCode { get; }

     public AppException(string message, int statusCode = 400) : base(message)
     {
         StatusCode = statusCode;
     }
 }

public class SeatAlreadyBookedException : AppException
{
    public IEnumerable<string> SeatNumbers { get; }

    public SeatAlreadyBookedException(IEnumerable<string> seatNumbers)
        : base($"The following seats are already booked: {string.Join(", ", seatNumbers)}", 409)
    {
        SeatNumbers = seatNumbers;
    }
}

AppException is custom exception class that extends Exception and adds a StatusCode property to represent the HTTP status code, with a default of 400.

SeatAlreadyBookedException is subclass of AppException that represents an exception for already booked seats, with a 409 status code and a list of seat numbers.

Then in the Interfaces folder, add a class called IBookingService with the following code

public interface IBookingService
{
    Task<bool> BookSeatsAsync(AddBookingDto bookingDto);
}

Now, navigate to TickbetBooking.Infrastructure, this project will house all our data operations. Then run these commands to install the neccesary packages in this project;

Install-Package Microsoft.EntityFrameworkCore
Install-Package Microsoft.EntityFrameworkCore.Design
Install-Package Microsoft.EntityFrameworkCore.SqlServer
Install-Package Microsoft.EntityFrameworkCore.Tools
Install-Package Microsoft.Extensions.Configuration.Json

Then, add a folder called Data with these classes; ApplicationDbContext ApplicationDbContextFactory and DbInitializer

 public class ApplicationDbContext : DbContext
 {
     public ApplicationDbContext(DbContextOptions<ApplicationDbContext> options) : base(options) { }

     public DbSet<Movie> Movies => Set<Movie>();
     public DbSet<Screening> Screenings => Set<Screening>();
     public DbSet<Seat> Seats => Set<Seat>();

     public DbSet<Booking> Bookings => Set<Booking>();

     protected override void OnModelCreating(ModelBuilder modelBuilder)
     {
         base.OnModelCreating(modelBuilder);
         modelBuilder.Entity<Seat>().HasIndex(s => new { s.ScreeningId, s.SeatNumber }).IsUnique();
     }
 }

This class inherits from DbContext and provides DbSet properties for the Movie, Screening, Seat, and Booking entities.

 public class ApplicationDbContextFactory : IDesignTimeDbContextFactory<ApplicationDbContext>
 {
     public ApplicationDbContext CreateDbContext(string[] args)
     {
         // Get the connection string from appsettings.json
         var basePath = Path.Combine(Directory.GetCurrentDirectory(), "../TicketBooking.API");

         var configuration = new ConfigurationBuilder()
             .SetBasePath(basePath)
             .AddJsonFile("appsettings.json")
             .Build();
         var optionsBuilder = new DbContextOptionsBuilder<ApplicationDbContext>();
         optionsBuilder.UseSqlServer(configuration.GetConnectionString("TicketDB"));//Or whatever your database name is.

         return new ApplicationDbContext(optionsBuilder.Options);
     }
 }

The ApplicationDbContextFactory class implements IDesignTimeDbContextFactory<ApplicationDbContext>, allowing the creation of ApplicationDbContext at design time. It reads the connection string from appsettings.json, configures the DbContextOptions, and returns an instance of ApplicationDbContext

public static class DbInitializer
{
    public static void SeedFromSqlFile(this ApplicationDbContext db, string path = "seed-data.sql")
    {
        if (db.Movies.Any())
            return;

        var sql = File.ReadAllText(path);
        db.Database.ExecuteSqlRaw(sql);
    }
}

The DbInitializer class is a static utility with an extension method SeedFromSqlFile for seeding the database. If the Movies table is empty, it reads SQL commands from a file and executes them to populate the database. You can download the sample seed-data.sql here

You'll need a add a reference to TicketBooking.Core from this project as well.

Next, in TicketBooking.Application, add these packages to the project as they are needed;

Install-Package Microsoft.EntityFrameworkCore
Install-Package Microsoft.EntityFrameworkCore.SqlServer

Now, create a folder called service and add this class BookingService with the below code;

public class BookingService : IBookingService
{
    private readonly ILogger<BookingService> _logger;
    private readonly ApplicationDbContext _context;

    public BookingService(ApplicationDbContext context, ILogger<BookingService> logger)
    {
        _context = context;
        _logger = logger;
    }

    public async Task<bool> BookSeatsAsync(AddBookingDto bookingDto)
    {
        _logger.LogInformation("Booking started for screening {ScreeningId} with seats: {Seats}",
        bookingDto.ScreeningId, string.Join(", ", bookingDto.SeatNumbers));

        try
        {
            var screening = await _context.Screenings
                .Include(s => s.Seats)
                .FirstOrDefaultAsync(s => s.Id == bookingDto.ScreeningId);

            if (screening == null) return false;

            var targetSeats = screening.Seats
               .Where(seat => !string.IsNullOrWhiteSpace(seat.SeatNumber)
               && bookingDto.SeatNumbers.Contains(seat.SeatNumber))
               .ToList();

            if(targetSeats.Any(x => x.IsBooked))
            {
                //Seats are taken
                _logger.LogWarning("No available seats found for booking for screening {ScreeningId} with seats: {Seats}",
                    bookingDto.ScreeningId, string.Join(", ", bookingDto.SeatNumbers));
                IEnumerable<string> seatNumber = targetSeats.Where(x => x.IsBooked).Select(x => x.SeatNumber);
                throw new SeatAlreadyBookedException(seatNumber);
            }

            if(targetSeats.Count == 0)
            {
                //Seats does not exist
                _logger.LogWarning("Seats not found for booking for screening {ScreeningId} with seats: {Seats}",
                    bookingDto.ScreeningId, string.Join(", ", bookingDto.SeatNumbers));
                throw new AppException("Seats not found for booking", 404);
            }

            foreach (var seat in targetSeats)
            {
                seat.IsBooked = true;
            }

            var booking = new Core.Entities.Booking
            {
                NameOfPerson = bookingDto.NameOfPerson,
                ScreeningId = bookingDto.ScreeningId,
                BookedSeats = targetSeats.Select(s => s.SeatNumber).ToList(),
                BookedAt = DateTime.UtcNow
            };

            _context.Bookings.Add(booking);

            await _context.SaveChangesAsync();
            return true;

        }
        catch (AppException ex)
        {
            _logger.LogWarning(ex, "Booking failed due to: {Message}", ex.Message);
            throw;
        }
        catch (DbUpdateConcurrencyException ex)
        {
            _logger.LogError(ex, "Concurrency conflict while booking seats for screening {ScreeningId}", bookingDto.ScreeningId);
            throw new AppException("Seat booking failed due to a concurrency issue. Please try again.", 409);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Unexpected error in BookSeatsAsync for screening {ScreeningId}", bookingDto.ScreeningId);
            throw;
        }
    }
}

The BookingService class is a service responsible for managing seat bookings in a movie screening. It implements the IBookingService interface we had created earlier on and contains methods to handle booking logic.

It retrieves the screening and associated seats from the database, checking if the specified seats are available. If any seat is already booked, it throws a SeatAlreadyBookedException. If the seats do not exist, it throws a custom AppException

For valid seat selections, the method updates their booking status, creates a new booking entry, and saves the changes to the database. Throughout the method, exceptions are handled with specific catches for different error types (e.g., AppException for business logic errors, DbUpdateConcurrencyException for concurrency issues). Any unexpected errors are logged and re-thrown for further handling.

We'll also be adding references to TicketBooking.Core and TicketBooking.Infrastructure from this project.

Next in TicketBooking.API, we'll install these packages to be used for logging information;

Install-Package Serilog.AspNetCore
Install-Package Serilog.Sinks.Console
Install-Package Serilog.Sinks.File
Install-Package Swashbuckle.AspNetCore

Now, create a new class called BookingController in the Controllers folder with this code snippet;

    [ApiController]
    [Route("api/[controller]")]
    public class BookingController : ControllerBase
    {
        private readonly IBookingService _bookingService;

        public BookingController(IBookingService bookingService)
        {
            _bookingService = bookingService;
        }

        [HttpPost]
        [Route("AddBooking")]
        public async Task<IActionResult> Book(AddBookingDto bookingDto)
        {
            var success = await _bookingService.BookSeatsAsync(bookingDto);
            return success ? Ok("Booking successful") : BadRequest("Booking failed");
        }
    }

Next lets create a global exception handler to handle all our requests since we don't want to do it per class. So in TicketBooking.API create a new folder called Middlewares with a class ExceptionHandlingMiddleware and add the below code;

 public class ExceptionHandlingMiddleware
 {
     private readonly RequestDelegate _next;
     private readonly ILogger<ExceptionHandlingMiddleware> _logger;

     public ExceptionHandlingMiddleware(RequestDelegate next, ILogger<ExceptionHandlingMiddleware> logger)
     {
         _next = next;
         _logger = logger;
     }
     public async Task InvokeAsync(HttpContext context)
     {
         try
         {
             await _next(context);
         }
         catch (AppException ex)
         {
             _logger.LogWarning(ex, "Handled app error");

             context.Response.StatusCode = ex.StatusCode;
             context.Response.ContentType = "application/json";

             await context.Response.WriteAsJsonAsync(new
             {
                 error = ex.Message
             });
         }
         catch (Exception ex)
         {
             _logger.LogError(ex, "Unhandled system exception");

             context.Response.StatusCode = 500;
             context.Response.ContentType = "application/json";

             await context.Response.WriteAsJsonAsync(new
             {
                 error = "An unexpected error occurred."
             });
         }
     }

 }

The ExceptionHandlingMiddleware class handles exceptions during HTTP request processing. It catches specific exceptions like our AppException defined before and general ones, logs them, and then formats an appropriate error response in JSON. If an AppException is caught, it uses the exception's StatusCode; otherwise, it returns a 500 status code for unexpected errors.

Don't forget to add the appropriate project references.

Now, in appsetting.json add a new connection string to your file

  "ConnectionStrings": {
    "TicketDB": "Data Source=localhost\\SQLEXPRESS;Initial Catalog=TicketDB;Integrated Security=True;TrustServerCertificate=True"
  }

Remember to replace TicketDB with whatever your database name is.

Then Modify your Program.cs class so it looks like this;

Log.Logger = new LoggerConfiguration()
    .WriteTo.Console()
    .WriteTo.File("Logs/log.txt", rollingInterval: RollingInterval.Day)
    .Enrich.FromLogContext()
    .MinimumLevel.Information()
    .CreateLogger();

var builder = WebApplication.CreateBuilder(args);

builder.Host.UseSerilog();

// Add services to the container.
builder.Services.AddDbContext<ApplicationDbContext>(options =>
    options.UseSqlServer(builder.Configuration.GetConnectionString("TicketDB")));

builder.Services.AddScoped<IBookingService, BookingService>();

builder.Services.AddControllers();
// Learn more about configuring Swagger/OpenAPI at https://aka.ms/aspnetcore/swashbuckle
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();

var app = builder.Build();

using (var scope = app.Services.CreateScope())
{
    var db = scope.ServiceProvider.GetRequiredService<ApplicationDbContext>();

    // Safe to use now
    db.Database.Migrate();
    db.SeedFromSqlFile();
}


app.UseMiddleware<ExceptionHandlingMiddleware>();

// Configure the HTTP request pipeline.
if (app.Environment.IsDevelopment())
{
    app.UseSwagger();
    app.UseSwaggerUI();
}

app.UseHttpsRedirection();

app.UseAuthorization();

app.MapControllers();

app.Run();

Do not forget to paste the Seed-data.sql file from earlier in your TicketBooking.API directory.

Now, that the project scaffold has been done, open the package manager console and run the following command, also make sure the project is set to TicketBooking.Infrastructure or which ever project your ApplicationDbContext is located;

Before running this command, Set TicketBooking.Infrastructure as the startup project

Add-Migration FirstMigration

After running this command, you should see a new Migrations folder generated

Now run this command to create the Database and Tables

Update-Database

If all goes well, the database and tables have been created. Now set TicketBooking.API back as the startup project and run the application. Remember we created a method that seeds data as well to our database so this is where that operation occurs.

Now, If we tried to create a new booking,

{
  "nameOfPerson": "Peter Jackson",
  "screeningId": 1,
  "seatNumbers": [
    "A1", "A3"
  ]
}

We see that the booking was successful

But if we tried to book seats A1 and A3 again

We see that according to our logic, it works as expected great.

As is best practice, let's add some tests to our application.

So, in the created TicketBooking.Tests project, install these packages as we will be needing them,

Install-Package Microsoft.EntityFrameworkCore
Install-Package Microsoft.EntityFrameworkCore.InMemory
Install-Package Moq

Then, add the following folders - Helpers and ServiceTests .

In the Helpers folder, add a class called TestHelper with the following code

    public static class TestHelper
    {
        public static ApplicationDbContext GetInMemoryDbContextAsync()
        {
            var options = new DbContextOptionsBuilder<ApplicationDbContext>()
                .UseInMemoryDatabase(Guid.NewGuid().ToString())
                .Options;

            var context = new ApplicationDbContext(options);

            var screening = new Screening
            {
                Id = 1,
                MovieId = 1,
                StartTime = DateTime.UtcNow,
                Seats = new List<Seat>
            {
                new Seat { Id = 1, SeatNumber = "A1", IsBooked = false },
                new Seat { Id = 2, SeatNumber = "A2", IsBooked = true },
                new Seat { Id = 3, SeatNumber = "A3", IsBooked = false },
            }
            };

            context.Screenings.Add(screening);
            context.SaveChangesAsync();

            return context;
        }
    }

This class provides a method GetInMemoryDbContextAsync that creates an in-memory ApplicationDbContext, seeds it with a new Screening object, and adds a list of Seat entities. The data is saved asynchronously, allowing the context to be used for testing purposes.

Then in the ServiceTests folder, add a class called BookingServiceTests and add the following code;

public class BookingServiceTests
{
    private ApplicationDbContext _dbContext;
    private Mock<ILogger<BookingService>> _logger;
    private BookingService _bookingService;

    [SetUp]
    public void Setup()
    {
        _dbContext = TestHelper.GetInMemoryDbContextAsync();
        _logger = new Mock<ILogger<BookingService>>();
        _bookingService = new BookingService(_dbContext, _logger.Object);
    }

    [TearDown]
    public void TearDown()
    {
        _dbContext?.Dispose();
    }

    [Test]
    public async Task BookSeatsAsync_Should_BookSeats_Successfully()
    {
        var dto = new AddBookingDto
        {
            NameOfPerson = "John Doe",
            ScreeningId = 1,
            SeatNumbers = new List<string> { "A1", "A3" }
        };

        var result = await _bookingService.BookSeatsAsync(dto);
        Assert.That(result, Is.True);
    }

    [Test]
    public async Task BookSeatsAsync_Should_Throw_SeatAlreadyBookedException_If_Seat_Already_Booked()
    {
        var dto = new AddBookingDto
        {
            NameOfPerson = "Jane Smith",
            ScreeningId = 1,
            SeatNumbers = new List<string> { "A2" } // already booked
        };

        var ex = Assert.ThrowsAsync<SeatAlreadyBookedException>(() => _bookingService.BookSeatsAsync(dto));

        Assert.Contains("A2", ex.SeatNumbers.ToList());
    }

    [Test]
    public async Task BookSeatsAsync_Should_Throw_AppException_If_Seat_Does_Not_Exist()
    {
        var dto = new AddBookingDto
        {
            NameOfPerson = "Alice",
            ScreeningId = 1,
            SeatNumbers = new List<string> { "B99" } // non-existent seat
        };

        var ex = Assert.ThrowsAsync<AppException>(() => _bookingService.BookSeatsAsync(dto));
        Assert.That(ex.StatusCode, Is.EqualTo(404));
    }
}

We have created 3 tests;

BookSeatsAsync_Should_BookSeats_Successfully - which checks that a new booking can be made
BookSeatsAsync_Should_Throw_SeatAlreadyBookedException_If_Seat_Already_Booked - which checks that an already booked seat cannot be booked again.
BookSeatsAsync_Should_Throw_AppException_If_Seat_Does_Not_Exist - which throws an exception if the client tries to book a seat that does not exist.

Add the necessary project references to TicketBooking.Core and TicketBooking.Infrastructure

Run the test project and we see that they all pass;

That concludes part 1 of this series, in Part 2, we'll optimize it by queuing booking requests for async processing and caching screening/seat data using Redis, ensuring efficient reads and cache invalidation after each booking.

If you got lost anywhere, you can find the entire project for Part 1 in the branch here

See you in the next one and happy coding.

Build a Simple Task manager using Winforms and C#

Olabamiji Oyetubo — Sun, 01 Jun 2025 19:59:19 +0000

This article provides a guide on how you can create your own version of the Windows task manager. We’ll use WinForms to create a Simple UI and add functionality to view running process and terminate a process.

First create a new WinForms application in .NET framework 4.8 and name it TaskManager.

The UI interface will look like this

Next, from the ToolBox menu, search for DataGridView item

And then drag it unto the MainForm palate.

Next, click on the DataGridView Dropdown options and click on Edit Columns.

Then add three columns that will act as descriptions as follows

Now, to load your form with running processes, navigate to the your Application’s MainForm

By default, your DatatGridView’s name should be dataGridView1 (Unless you previously changed it)
Then, add this piece of code:

  public partial class Form1 : Form
  {
      public Form1()
      {
          InitializeComponent();
          LoadProcesses();
      }

      private void LoadProcesses()
      {
          dataGridView1.Rows.Clear();

          foreach (var proc in System.Diagnostics.Process.GetProcesses())
          {
              try
              {
                  string status = proc.Responding ? "Running" : "Not Responding";
                  dataGridView1.Rows.Add(proc.ProcessName, proc.Id, status);
              }
              catch
              {
                  Console.WriteLine($"Could not access process {proc.ProcessName} with ID {proc.Id}.");
              }
          }
      }

  }

When you running your application, you should see all your running processes

Now, lets add a button to each row that will kill that running process
Back on the edit columns section of the DataGridView object, Add a new column like so,

Make sure to set the Type to DataGridViewButtonColumn to indicate this column will hold a button
Then, add this piece of code to your Form1.cs

private void dataGridView1_CellContentClick(object sender, DataGridViewCellEventArgs e)
 {
     if (e.RowIndex >= 0 && e.ColumnIndex == dataGridView1.Columns["KillProcess"].Index)
     {
         int pid = Convert.ToInt32(dataGridView1.Rows[e.RowIndex].Cells["PID"].Value);
         try
         {
             var proc = System.Diagnostics.Process.GetProcessById(pid);
             proc.Kill();
             MessageBox.Show($"{proc.ProcessName} has been terminated.", "Info", MessageBoxButtons.OK, MessageBoxIcon.Information);
             LoadProcesses();
         }
         catch (Exception ex)
         {
             MessageBox.Show($"Failed to kill process: {ex.Message}", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
         }
     }
 }

This method will get the particular Process ID when a particular row is clicked, which is used to call both the Process.GetProcessById and Kill() methods.
Don’t forget to wire up your event listener like this

dataGridView1.CellClick += dataGridView1_CellClick;

And that’s it.

If we open up a snipping tool process and then close it from our program, we see that the process was successfully terminated

You can find the full source code of this project here

Happy Coding!!

Build a ClipBoard Manager using Winforms

Olabamiji Oyetubo — Sun, 23 Mar 2025 12:23:27 +0000

If like me, you're a Software developer, you probably do a lot of copying and pasting. While in the zone working, you might copy several items and then struggle to recall where you copied a previous item from. Windows stores these copied items in its clipboard manager, but there's no built-in way to view your clipboard history. While extensions exist to solve this problem, I prefer creating my own solution, so that's what we're going to do today.

First, create a new Winforms (.NET Framework) project.

Name your project ClipBoardManager and click Create

Now, in the default form, add a new ListBox item. This will store the list of copied items.

Rename the listBox1 item as ClipBoardList.

Next, create a class Helper that will store our clip board logic.

Replace the code in Helper with the below code;

 public class Helper : Form
 {
     [DllImport("user32.dll")]
     private static extern IntPtr SetClipboardViewer(IntPtr hWndNewViewer);

     [DllImport("user32.dll")]
     private static extern bool ChangeClipboardChain(IntPtr hWndRemove, IntPtr hWndNewNext);

     private IntPtr nextClipboardViewer;

     public event Action<string> ClipboardUpdated;

     public Helper()
     {
         nextClipboardViewer = SetClipboardViewer(this.Handle);
     }

     protected override void WndProc(ref Message m)
     {
         const int WM_DRAWCLIPBOARD = 0x0308;

         if (m.Msg == WM_DRAWCLIPBOARD)
         {
             if (Clipboard.ContainsText())
             {
                 string text = Clipboard.GetText();
                 ClipboardUpdated?.Invoke(text);
             }
         }

         base.WndProc(ref m);
     }
 }

We're using the Windows API (User32.dll) to detect changes in our environment. WM_DRAWCLIPBOARD listens for clipboard activity and extracts the text using a triggered event anything something is copied.

Now, in Form1, add the code below;

public partial class Form1: Form
{
    public Form1()
    {
        InitializeComponent();

        clipboardHelper = new Helper();
        clipboardHelper.ClipboardUpdated += OnClipboardChange;
    }

    private Helper clipboardHelper;
    private List<string> clipboardHistory = new List<string>();

    private void OnClipboardChange(string text)
    {
        if (!clipboardHistory.Contains(text))
        {
            if (clipboardHistory.Count >= 10)
                clipboardHistory.RemoveAt(0);

            clipboardHistory.Add(text);
            UpdateClipBoardList();
        }
    }

    private void UpdateClipBoardList()
    {
        ClipBoardList.Items.Clear();
        foreach (var item in clipboardHistory)
            ClipBoardList.Items.Add(item);
    }
}

This initializes a new Helper class called clipboardHelper and then assigns ClipboardUpdated action to a new method OnClipboardChange. This method simply utilizies the UpdateClipBoardList method to update our ClipBoardList ListBox item.

And that's it. When you run the code, you get a simple UI, all you have to do is then copy a piece of text and it appears in our list.

If you got lost somewhere along the line, the entire project can be found here

How to use Swagger UI on a .NET 9 Web API project

Olabamiji Oyetubo — Sun, 09 Feb 2025 15:39:13 +0000

If you didn’t know, with the release of .NET 9, Swagger UI for Web API projects no longer comes out of the box. This tutorial will show you how to add Swagger configuration to .NET 9 projects.

First, create a new ASP .NET Core Web API project and set your target framework to .NET 9

Next, navigate to the package manager console.

Once there, use the Browse tab to search for Swashbuckle.AspNetCore, then click install to add it to your project

After the package has been successfully installed, navigate to your Program.cs class and just above the builder.Build() method, add this line of code;

builder.Services.AddSwaggerGen();

This method registers the Swagger generator into the DI container, allowing your application to generate an OpenAPI specification for our API.
Next, modify the app.Environment.IsDevelopment() condition, so it looks like this;

if (app.Environment.IsDevelopment())
{
    app.UseSwagger();
    app.UseSwaggerUI();
}

app.UseSwagger() serves the API documentation as OpenAPI JSON, while app.UseSwaggerUI() provides an interactive UI for testing endpoints.
Your Program.cs should look like this now;

Now, when you run your application, the server and port name should be generated in a prompt like so;

To see the Swagger UI, on your browse, Simply add /swagger/index.html to your server and port number.

Happy Coding!!

How to create an Installer for a Winforms application using Visual Studio and Advanced Installer(Free Edition)

Olabamiji Oyetubo — Tue, 10 Dec 2024 18:05:30 +0000

In this tutorial, we’ll look at creating an installer for a Winforms desktop application using Advanced Installer(Free edition).

Prerequisites:

The only prerequisite for this tutorial is Visual Studio Community edition, go ahead and download the installer here

After downloading, go ahead and install and open Visual Studio.

Next, we want to create a project, we will create a small Winforms application for this demo.

I have created a Winforms application called CurrencyConverter, you can clone the project from my GitHub here

ps: This project runs on .NET 9, so you'll need that particular SDK to run it

Alright, next thing is to navigate to the Advanced Installer page, to download a free trial.

After downloading it, click and run the installer

Follow the prompts and use the default options provided.

If you were able to install the application successfully, it should be launched and you should see this screen.

Next, Make sure the MSI Installer tab is selected, then Click on Visual Studio Application and then click on Create New Project

You'll be ask to provide a project and Manufacturer name. I have named the former Currency Converter and the latter as simply my own name. Then click Next.

Since we're using the free trial, the only extension type we have available is a standard MSI setup file. So you can then click Next.

Now, We'll be asked to choose where the project will reside in your local machine, you can just leave the default values and click Next.

Next, you'll be asked to choose the Visual Studio solution you want to use for this project.

Navigate to whatever folder you cloned the starter project and select that.

And then click the next button

Next, You'll be asked to choose whatever project configuration you application was complied under. Since this is for tutorial purposes, I will select the Debug configuration only as that is where my project was built.
I will also check the Build Selected Configuration before proceeding option, just so we're sure there are no unwanted errors.

Next, we'll be greeted with a screen to select the files that have been detected as output files in our project build. For this part, just click on the Select All checkbox.

Next, is the panel that asks if you want to create both Desktop and Program files shortcut for your application. I will leave these as is and click Next.

Next, you can choose to Launch the Application after install, make sure to choose the application EXE

Next, You'll be asked to select the Installation UI, we'll use the default selection for the purpose of this tutorial

Next is the License Agreement page, if you would like your users to sign a license agreement before proceeding with the installation, you can add that here. We're going to skip this step since this is just a practice application.

You can then click the Finish button as we have now reached the end of the configuration

You should now see all the details of the installer project

There are several options and configurations you can do, but for this tutorial, we're just going to keep it simple and continue with the configurations we have already added. Next build your project by clicking the build button

From the picture above, you can see the build was successful with no errors
Now, to use your created MSI file, you have 2 options, you can either just click the Run button at the top of your application or navigate to the folder you defined earlier as the project output path. I will use the later.

Click on the Open Output Folder options at the top

And we see the MSI file created. You can then click it to installer your application.

When you click the installer you see the Installation UI we configured earlier

You can just follow the prompts to the install the application and click finish when its done

We can then see the application opens up like we wanted

Happy coding everyone.

Visualize Code coverage in .NET applications using NDepend and NUnit

Olabamiji Oyetubo — Wed, 06 Nov 2024 17:26:39 +0000

In this tutorial, we're going to visualize Code Coverage metrics using NDepend.

What is NDepend?
NDepend is a feature rich static code analysis tool that helps .NET developers analyze, maintain and improve code quality. It provides detailed metrics, visualization of code dependencies, and quality rules to identify technical debt, architectural issues, and potential problems in C# and VB.NET codebases.

For this tutorial, we are going to use NDepend's inbuilt dashboard to visualize the percentage of code we have tested.

For readers new to unit testing and code coverage, I've written detailed introductions on both topics: Unit Testing Guide and Code Coverage Explained.

Before starting, download NDepend from their official website. You can opt for either the trial version or Pro version (if you have purchased a license).

Our IDE of choice will be Visual Studio on Windows, so follow this guide on how to setup the NDepend extension on your Visual Studio instance.

Create a new console Application by running this command;

dotnet new console -o CalculatorApp

Open up your project in Visual studio and add a new class Calculator and add the below code;

    public class Calculator
    {
        public int Add(int x, int y)
        {
            return x + y;
        }

        public int Subtract(int x, in int y)
        {
            return x - y;
        }

        public int Multiply(int x, int y)
        {
            return x * y;
        }

        public int Divide(int x, int y)
        {
            return x / y;
        }
    }

These are basic operations that can be done on a calculator.

Okay great, let's create a unit test project for our implementation.

Create a new project by right-clicking on your solution file and adding a new NUnit project and call it CalculatorTests

Don't forget to add a Project reference to CalculatorApp

Now, let's add the following code to the Class UnitTest1

public class Tests
{
    Calculator calc;
    [SetUp]
    public void Setup()
    {
        calc = new Calculator();
    }

    [Test]
    public void Add_TwoNumbers_ReturnsSum()
    {
        //Arrange
        int numOne = 5, numTwo = 10, expectedValue = 15;

        //Act
        var actualValue = calc.Add(numOne, numTwo);

        //Assert
        Assert.That(expectedValue,Is.EqualTo(actualValue));
    }

    [Test]
    public void Subtract_TwoNumbers_ReturnsDifference()
    {
       //Arrange
       int numOne = 10, numTwo = 5, expectedValue = 5;

       //Act
       var actualValue = calc.Subtract(numOne, numTwo);

       //Assert
       Assert.That(expectedValue, Is.EqualTo(actualValue));
    }
}

When you run the tests, we get 2 passing tests.

Next, we want to use NDepend in our project. From Visual studio extensions Tab, locate the Ndepend extension and Select Attach New NDepend project to Current VS Solution like below

The Ndepend dialong pops up that shows the project that will be analyzed the one that will be filtered out

Go ahead and click on the Analyze a Single .NET Assembly button

NDepend will analyize your project for various metrics and give you a great report that tells you a lot about your code.

If its your first time using NDepend, you'll also get an nice dialog that shows what was just done.

Now, let's try to measure our code coverage. NUnit projects now come with Coverlet out of the box to enable us generate code coverage in our test project.

First, create a file in the directory of the test project, and call it coverlet.runsettings, and add this piece of code:

<RunSettings>
  <DataCollectionRunSettings>
    <DataCollectors>
      <DataCollector friendlyName="XPlat Code Coverage">
        <Configuration>
          <Format>opencover</Format>
          <ExcludeByFile>**/Program.cs</ExcludeByFile>
        </Configuration>
      </DataCollector>
    </DataCollectors>
  </DataCollectionRunSettings>
</RunSettings>

We're simply adding this so the program.cs does not get in the way of our demo and setting the output format to OpenCover so NDepend can parse the file.

Then, while still in the the Test directory, run this command;

dotnet test --collect:"XPlat Code Coverage" --settings coverlet.runsettings

This will run your tests and generate a coverage.opencover xml file in the TestResults folder

Now, let's use NDepend to parse this file and see our test coverage from the NDepend dashboard

From the Extensions Tab, Select NDepend and then select NDepend Project properties

Next Click on the Analysis tab and then select settings for Code coverage

Next, Use the first Option to import your test coverage file from your testResults folder and click Ok

All you have to do is run NDepend Analysis again(you can also automate this process in your CI/CD pipeline)

After the analysis is done, simple Navigate to your NDepend Dashboard

From the NDepend Dashboard, we see a bunch of useful metrics that can help you improve the overall state of your project.

For this tutorial, we're mostly concerned about code coverage, and we can see that we have it at 50% but that is to be expected, since we only wrote tests for 2 out of our 4 methods.

Let's fix that.

Modify UnitTest1 class so it looks like this;

public class Tests
{
    Calculator calc;
    [SetUp]
    public void Setup()
    {
        calc = new Calculator();
    }

    [Test]
    public void Add_TwoNumbers_ReturnsSum()
    {
        //Arrange
        int numOne = 5, numTwo = 10, expectedValue = 15;

        //Act
        var actualValue = calc.Add(numOne, numTwo);

        //Assert
        Assert.That(expectedValue, Is.EqualTo(actualValue));
    }

    [Test]
    public void Subtract_TwoNumbers_ReturnsDifference()
    {
        //Arrange
        int numOne = 10, numTwo = 5, expectedValue = 5;

        //Act
        var actualValue = calc.Subtract(numOne, numTwo);

        //Assert
        Assert.That(expectedValue, Is.EqualTo(actualValue));
    }

    [Test]
    public void Multiply_TwoNumbers_ReturnsProduct()
    {
        //Arrange
        int numOne = 2, numTwo = 3, expectedValue = 6;

        //Act
        var actualValue = calc.Multiply(numOne, numTwo);

        //Assert
        Assert.That(expectedValue, Is.EqualTo(actualValue));
    }

    [Test]
    public void Divide_TwoNumbers_ReturnsRemainder()
    {
        //Arrange
        int numOne = 10, numTwo = 5, expectedValue = 2;

        //Act
        var actualValue = calc.Divide(numOne, numTwo);

        //Assert
        Assert.That(expectedValue, Is.EqualTo(actualValue));
    }
}

Run the test and see that it passes.

Now run the commands to generate the test coverage once more.

The run NDepend analysis once more and navigate to the dashboard

Now, we see that we have 100% code coverage

NDepend can also help you generate reports to track improvements over time, analyxze dependencies between code components, measuring code complexityand more. Check out the docs here

Happy coding.

CRUD operations using Blazor Web App, Entity Framework and SQL Server

Olabamiji Oyetubo — Thu, 12 Sep 2024 12:28:59 +0000

In this tutorial, we’ll explore how to do simple CRUD (Create, Read, Update, and Delete) Operations in a Blazor web App.

What you'll need for this tutorial;

Visual Studio community edition. You can download it here
SQL Server (Express edition). Can be downloaded here
SQL Server Management Studio (Optionally). Can be downloaded here

Create a Blazor project

Open up Visual Studio and click Create a new Project
In the Search Template field, search for Blazor Web App and click on it.

Give your project and name, I have called mine BlazorWebApp, then Select .NET 8 as the target framework and leave all the other options as the default values then click Create.
Next, we’re going to install the necessary packages into our project, so open up the package manager console and type in the following commands;

Install-Package Microsoft.EntityFrameworkCore

Install-Package Microsoft.EntityFrameworkCore.SqlServer

Install-Package Microsoft.EntityFrameworkCore.Tools

Install-Package Microsoft.EntityFrameworkCore.Design

Scafollding DbContext

Now, we're going to create a model/entity that most of our buisness logic will be based on;

Create a folder called Models and add a new class called Club
The Club class will have the structure as below;

    public class Club
    {
        public int Id { get; set; }
        public string ClubName { get; set; }
        public string YearFounded { get; set; }
        public string Country { get; set; }
    }

Next, still in the Models folder, create a new class called ClubDbContext and copy this code into it;

    public class ClubDbContext : DbContext
    {
        public ClubDbContext(DbContextOptions<ClubDbContext> options) : base(options)
        {
        }
        public DbSet<Club> Clubs { get; set; }
    }

We can now create both our Database and Table.
Add this to your appsettings.json file;

  "ConnectionStrings": {
    "DefaultConnection": "Server=(localdb)\\mssqllocaldb;Database=BlazorDB;Trusted_Connection=True;"
  }

This contains the connection string for our database.

Now, create a class called DbContextFactory and add the following code;

    public class DbContextFactory : IDesignTimeDbContextFactory<ClubDbContext>
    {
        public ClubDbContext CreateDbContext(string[] args)
        {
            var optionsBuilder = new DbContextOptionsBuilder<ClubDbContext>();

            // Get the connection string from appsettings.json
            var configuration = new ConfigurationBuilder()
                .AddJsonFile("appsettings.json")
                .Build();
            optionsBuilder.UseSqlServer(configuration.GetConnectionString("DefaultConnection"));
            return new ClubDbContext(optionsBuilder.Options);
        }
    }

The DbContextFactory class is implementing the IDesignTimeDbContextFactory<ClubDbContext> interface. This interface is used to create instances of our DbContext (ClubDbContext) at design time.

So far, your project should look like this.

Next, in Program.cs add this line of code so your project knows the correct Database String to reference;

builder.Services.AddDbContext<ClubDbContext>(c =>
    c.UseSqlServer(builder.Configuration.GetConnectionString("DefaultConnection")));

Running Migrations

Now that all that has been setup, lets create the first migration
Open up the Package Manager Console and run this command;

Add-Migration FirstMigration -Context ClubDbContext

This command creates a Migrations folder in the project based on the current state of our ClubDbContext.

In other to finish this process and create the Clubs table, we are going to have to update the database. So go ahead, and run the below command in the Package Manager console as well;

Update-Database

If all goes well, you should get a response that the build Succeeded and a response saying Applying migration '20240911173037_FirstMigration', which means our migration has been applied and our Clubs table has been created.

Before we move on, let us create a Services folder that will act as the hub for where most of the service implementation will reside.
In the services folder create an Interface called IClubService and add the below code;

    public interface IClubService
    {
        Task<List<Club>> GetClubs();
        Task<Club> GetClub(int id);
        Task AddClub(Club club);
        Task UpdateClub(Club club);
        Task DeleteClub(int id);
    }

Then, still in the Services folder, create a new class that will implement that Interface called ClubService and copy the below code into it;

public class ClubService : IClubService
{
    private readonly ClubDbContext _context;

    public ClubService(ClubDbContext context)
    {
        _context = context;
    }

    public async Task<List<Club>> GetClubs()
    {
        return await _context.Clubs.ToListAsync();
    }

    public async Task<Club> GetClub(int id)
    {
        var club = await _context.Clubs.FindAsync(id);
        if (club == null)
        {
            throw new Exception("club not found");
        }
        return club;
    }

    public async Task AddClub(Club club)
    {
        _context.Clubs.Add(club);
        await _context.SaveChangesAsync();
    }

    public async Task UpdateClub(Club club)
    {
        _context.Entry(club).State = EntityState.Modified;
        await _context.SaveChangesAsync();
    }

    public async Task DeleteClub(int id)
    {
        var club = await _context.Clubs.FindAsync(id);
        if (club != null)
        {
            _context.Clubs.Remove(club);
            await _context.SaveChangesAsync();
        }
    }
}

Make sure to register both the Interface and its implementation by adding the below code to Program.cs;

builder.Services.AddScoped<IClubService, ClubService>();

At this point, your project should look like this;

Implementing CRUD Operations

Let’s insert some data into our Club table. From your project, navigate to the Components folder and then to the Pages folder, and then create a Razor Component and call this Club.razor
In Club.razor page, add this piece of code;

@page "/club"
@rendermode InteractiveServer
@inject NavigationManager Navigation
@inject BlazorWebApp.Services.IClubService ClubService

<h3>Club Table</h3>

@if (clubs == null)
{
    <p><em>Loading...</em></p>
}
else
{
    <table class="table">
        <thead>
            <tr>
                <th>ID</th>
                <th>Club Name</th>
                <th>Year Founded</th>
                <th>Country</th>
                <th>Actions</th>
            </tr>
        </thead>
        <tbody>
            @foreach (var club in clubs)
            {
                <tr>
                    <td>@club.Id</td>
                    <td>@club.ClubName</td>
                    <td>@club.YearFounded</td>
                    <td>@club.Country</td>
                    <td>
                        <button class="btn btn-warning btn-sm" @onclick="() => NavigateToUpdate(club.Id)">Update</button>
                        <button class="btn btn-danger btn-sm" @onclick="() => DeleteClub(club.Id)">Delete</button>
                    </td>
                </tr>
            }
        </tbody>
    </table>

}

<button class="btn btn-primary" @onclick="OpenAddClubModal">Add New Club</button>

@code {
    private List<Models.Club> clubs;

    protected override async Task OnInitializedAsync()
    {
        // Load the club when the component is initialized
        clubs = await ClubService.GetClubs();

    }

    private void OpenAddClubModal()
    {
        Navigation.NavigateTo("/add-club");
    }

    private void NavigateToUpdate(int clubId)
    {
        Navigation.NavigateTo($"/update/{clubId}");
    }

    private async Task DeleteClub(int clubId)
    {

        await ClubService.DeleteClub(clubId);

        clubs = await ClubService.GetClubs();
    }
}

Next, Let’s Create a page where we can add a Club.
So still in Pages folder, create a razor page called Add-club.razor and add this code to it;

@page "/add-club"
@rendermode InteractiveServer
@using BlazorWebApp.Models
@inject BlazorWebApp.Services.IClubService ClubService
@inject NavigationManager Navigation

<h3>Add New Club</h3>

<div class="mb-3">
    <label for="clubName" class="form-label">Club Name</label>
    <input type="text" class="form-control" id="clubName" @bind="newClubName" />
</div>
<div class="mb-3">
    <label for="yearFounded" class="form-label">Year Founded</label>
    <input type="text" class="form-control" id="yearFounded" @bind="yearFounded" />
</div>
<div class="mb-3">
    <label for="country" class="form-label">Country</label>
    <input type="text" class="form-control" id="country" @bind="newCountry" />
</div>

<button class="btn btn-secondary" @onclick="Cancel">Cancel</button>
<button class="btn btn-primary" @onclick="InsertClub">Save</button>

@code {
    private string newClubName;
    private string yearFounded;
    private string newCountry;

    private async Task InsertClub()
    {
        // Create a new club object
        var club = new Models.Club
            {
                ClubName = newClubName,
                YearFounded = yearFounded,
                Country = newCountry
            };

        // Insert the club into the database
        await ClubService.AddClub(club);

        // Close the modal and navigate back to the club page
        Navigation.NavigateTo("/club");
        StateHasChanged();
    }

    private void Cancel()
    {
        // Close the modal and navigate back to the club page
        Navigation.NavigateTo("/club");
    }
}

Finally, we'll need to create an Update page so create a page called Update.razor
Then add this piece of code to it;

@page "/update/{clubId:int}"
@rendermode InteractiveServer
@using BlazorWebApp.Models
@inject BlazorWebApp.Services.IClubService ClubService
@inject NavigationManager Navigation

<h3>Update Club</h3>

@if (club == null)
{
    <p><em>Loading...</em></p>
}
else
{
    <div class="mb-3">
        <label for="clubName" class="form-label">Club Name</label>
        <input type="text" class="form-control" id="clubName" @bind="club.ClubName" />
    </div>
    <div class="mb-3">
        <label for="country" class="form-label">Country</label>
        <input type="text" class="form-control" id="country" @bind="club.Country" />
    </div>
    <button class="btn btn-secondary" @onclick="Cancel">Cancel</button>
    <button class="btn btn-primary" @onclick="UpdateClub">Save</button>
}

@code {
    [Parameter]
    public int clubId { get; set; }

    private Models.Club club;

    protected override async Task OnInitializedAsync()
    {
        // Load the club to be updated
        club = await ClubService.GetClub(clubId);
    }

    private async Task UpdateClub()
    {
        // Update the club using the service
        await ClubService.UpdateClub(club);

        // Redirect back to the club list page
        Navigation.NavigateTo("/club");
    }

    private void Cancel()
    {
        // Navigate back to the club list page
        Navigation.NavigateTo("/club");
    }
}

We’ll need to add the home Club component to the Nav bar so we can see it.
Navigate to the Components folder and in the Layouts folder, select NavMenu.Razor
Replace the code in NavMenu with the below;

<div class="top-row ps-3 navbar navbar-dark">
    <div class="container-fluid">
        <a class="navbar-brand" href="">BlazorWebApp</a>
    </div>
</div>

<input type="checkbox" title="Navigation menu" class="navbar-toggler" />

<div class="nav-scrollable" onclick="document.querySelector('.navbar-toggler').click()">
    <nav class="flex-column">
        <div class="nav-item px-3">
            <NavLink class="nav-link" href="" Match="NavLinkMatch.All">
                <span class="bi bi-house-door-fill-nav-menu" aria-hidden="true"></span> Home
            </NavLink>
        </div>
        <div class="nav-item px-3">
            <NavLink class="nav-link" href="club">
                <span class="bi bi-list-nested-nav-menu" aria-hidden="true"></span> Clubs
            </NavLink>
        </div>

    </nav>
</div>

Now, run the Application and navigate to the Clubs page

Clicking on Add New Club will redirect us to the Add-Club razor page we created, where we can add a new club.

Clicking save will add the club, and we can add some more as well

To Edit a club, simply click the Update button

We can then choose to change the club name or country if we want

To delete a Club, simply click the delete button.

And that’s it

If you got lost somewhere along the line, the entire project can be found here

Happy Coding!