DEV Community: Olabamiji Oyetubo

[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!

Where to find Open Source C# Projects to contribute to

Olabamiji Oyetubo — Mon, 15 Jul 2024 13:50:08 +0000

Open Source in C# has become really popular over time. Especially since Microsoft decided to open-source .NET(Core). It's amazing to see people from all over the world getting involved and building great projects. Many people have different reasons why they would like to get into Open Source. Some do it because they're very excited about a particular piece of technology. Others see it as a great way to sharpen their skills. There are those who love the idea of working together with a community of like-minded individuals. And let's not forget the hobbyists who simply enjoy tinkering in their free time.

But here's the thing - whether you're a coding whiz or just starting out, you might find yourself wondering, Where do I even begin? or What kind of projects could use my help? Don't worry, these are common questions that almost everyone asks when they're first dipping their toes into the open-source world.

This article concentrates on the latter and will outline four methods for identifying open-source C# projects to contribute to.

A Piece of tech you've used

This is by far the easiest and most straight forward way to contribute to an open-source project. If you have worked with an open-source Library, framework, or extension, making contributions will be easier as you are already familiar with what that project is about. Two popular examples are Entity Framework Core and MSTest

Official .NET Repository

The .NET platform's official GitHub repository is also another great place to find projects to contribute to.

As of the time this article was written, there and 259 projects, all of which are open source and welcome contributions from the community.

.NET foundation projects

The .NET Foundation is an independent, non-profit organization established to support an innovative, commercially friendly, open-source ecosystem around the .NET platform.

There are many projects the foundation supports and they are all welcoming to community contributors to make the projects better. Check them out here

UpForGrabs

Up for grabs is a list of projects which have curated tasks specifically for new contributors and are generally very beginner friendly.

You can filter by either .NET or C# to see projects listed. Tasks in the issue section are usually marked as good first issue or up for grabs

Of course, there are a lot of other places to find open source C# projects but these are the most popular i've seen. Remember to always be kind and follow the Code of conduct for any project you might be interested in contributing to.

Happy Coding!

Beginner's Guide to Test Coverage with NUnit, Coverlet, and ReportGenerator

Olabamiji Oyetubo — Mon, 17 Jun 2024 12:57:08 +0000

Hi guys, today I am going to show a quick and simple way to get started with Test Coverage in your code.

What is Test Coverage?

Test coverage is the percentage of code that is tested by automated tests. That is, it measures the extent to which a codebase is covered by tests we write.

Prerequisites for this tutorial;
Basic knowledge of C# and Unit testing.

Requirements;

Visual Studio - Powerful IDE for .NET and C++ development on Windows.
NUnit - Unit Testing framework for .NET. More here
Coverlet - Cross-platform code coverage framework for .NET. More here
ReportGenerator - Powerful code coverage visualization tool. More here

Let's set-up our test application.

Create a new console Application using .NET Framework

Give your project a name TestCoverageDemo. Then select .NET framework 4.7.2 as the target framework and click Create.

Great, now In your application add a simple class called Calculator and add the following code

public class Calculator
{
    public static int Add(int number)
    {
        int sum = 20;
        return sum + number;
    }
}

This class contains a simple implementation that takes a number, adds 20 to it, and returns the result. Seems simple enough.

Write a unit test for the implementation.

Create a new project by right-clicking on your solution file and selecting Add -> New project

Search NUnit

You can leave the default NUnit project name of TestProject1. Click next. Select .NET Framework 4.7.2 as the target framework and click Create.

After Creating, your project should look like this.

Next, add a reference to the main TestCoverageDemo project from the test project

Now, Add the following code to the Class UnitTest1

    public class Tests
    {
        [SetUp]
        public void Setup()
        {
        }

        [Test]
        public void Test1()
        {
            // Arrange
            int number = 2;
            int expected = 22;

            // Act
            int actual = Calculator.Add(number);

            // Assert
            Assert.That(actual, Is.EqualTo(expected));
        }
    }

Your class should look something like this;

Now, right-click on the Test name and select Run Tests

After running the test, we see that we get a passing test;

Next, Install Coverlet by navigating to the command line of your test project and running this command;

dotnet add package coverlet.collector

Next, 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>
          <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.

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.cobertura xml file in the TestResults folder

This file is hard to read, so we need the ReportGenerator tool to visualize it.

To Install ReportGenerator, run this command;

dotnet tool install -g dotnet-reportgenerator-globaltool

Next, run this command;

reportgenerator -reports:"TestCoverageDemo\TestProject1\TestResults\e36a31dc-6f0e-410a-a860-cc32118ec3a8\coverage.cobertura.xml" -targetdir:"coverageresults" -reporttypes:Html

This command will go into the location of where the coverage.cobertura file is located, parse that file and present the result as a viewable Html site in the target directory we specified: coverageresults

Navigating to the Test project folder, we see that the folder coverageresults has been generated

Navigate into the coverageresults folder and click on index, the coverage results have been presented in a nice way and we have 100% coverage;

Scrolling down, we will see a better breakdown of what is covered

Clicking on TestCoverageDemo.Calculator we see that we have 100% of coverage and that all the lines of code we've written are covered by the unit test.

Great.

Let's make some modifications to the Add method in the calculator class, by adding this code:

 public static int Add(int number)
 {
     int sum;

     if(number % 2 == 0)
     {
         sum = 20;
     }
     else
     {
         sum = 30;
     }
     return sum + number;
 }

Now, in your test explorer run the test Test1 again

We see that the test still passes as expected.

Now, Let's try to recalculate the test coverage once more. Run these 2 commands in the directory of the test project again,

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

reportgenerator -reports:"TestCoverageDemo\TestProject1\TestResults\e36a31dc-6f0e-410a-a860-cc32118ec3a8\coverage.cobertura.xml" -targetdir:"coverageresults" -reporttypes:Html

Now, navigate to the coverageresults folder once more and click the index.

We see that the coverage has dropped from 100% to 70%

If we investigate further by checking TestCoverageDemo.Calculator class, we can see why;

The else block is not covered by the test because we have not created any scenario where that part of the code is tested.

Let's fix that.

Add this piece of code to the UnitTest1 class;

 public void Test2()
 {
     // Arrange
     int number = 3;
     int expected = 33;

     // Act
     int actual = Calculator.Add(number);

     // Assert
     Assert.That(actual, Is.EqualTo(expected));
 }

Run the test and see that it passes.

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

Navigate to coverageresult and click Index once more.

We see that the test coverage is back to 100%.

Checking TestCoverageDemo.Calculator will reveal a further breakdown;

And we see that the new code we introduced to the system is now covered by the tests as well.

This was a very brief introduction to test coverage in C# applications we have gone through. You can check out some of the tools we used in this tutorial and use them in your projects as well.

Happy coding