DEV Community: Ssewannonda Keith Edwin

The Delta Difference: Unleashing .NET, EF Core, and PostgreSQL Performance with Delta

Ssewannonda Keith Edwin — Thu, 12 Jun 2025 16:27:45 +0000

Introduction

In the world of web development, performance is king. Fast-loading applications keep users happy, reduce server load, and improve overall user experience. One of the most effective ways to achieve this is through intelligent caching. When a client requests data that hasn't changed since their last request, wouldn't it be great if we could just tell them "you already have this"? That's exactly what the HTTP 304 Not Modified status code is for.

However, implementing 304 Not Modified effectively can be tricky, especially when in the real world data lives in a database. How do you efficiently determine if the data has truly changed without re-fetching and re-processing everything? This is where Delta comes in. As SimonCropp says

Delta is an approach to implementing a 304 Not Modified leveraging DB change tracking.
The approach uses a last updated timestamp from the database to generate an ETag. All dynamic requests then have that ETag checked/applied.

Tech Stack choice

I chose this combination because:

1.Dot net is the most performant framework
2.EF Core has gotten better and provides a slew of performance steps
3.PostgreSQL is a powerful, open source object-relational database that safely stores and scales the most complicated data workloads.
4.Delta An efficient approach to implementing a 304 Not Modified leveraging DB change tracking

Steps to use Delta

Postgres requires track_commit_timestamp flag to be enabled. Log into the psql with a user that has admin privileges.

psql -U <insert_your_user_name> 
ALTER SYSTEM SET track_commit_timestamp = on;

Restart the Postgres service.

Add Delta.EF to your .NET solution. dotnet add package Delta.EF --version 6.4.2
Enable row versioning in your AppDbContext.

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

    public DbSet<Product> Products { get; set; }

    protected override void OnModelCreating(ModelBuilder builder)
    {
        var product = builder.Entity<Product>();
        product.HasKey(p => p.Id);
    }
}

Update your Program.cs file.

var builder = WebApplication.CreateBuilder(args);

AppContext.SetSwitch("Npgsql.EnableLegacyTimestampBehavior", true);

builder.Services.AddDbContextPool<ApplicationDbContext>(options =>
{
 options.UseNpgsql(builder.Configuration.GetConnectionString("DefaultConnection"), opts =>
    {
        opts.EnableRetryOnFailure(maxRetryCount: 5,
            maxRetryDelay: TimeSpan.FromSeconds(30),
            errorCodesToAdd: null);
            opts.CommandTimeout(60);
    });

    if (Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT") != "Development") return;
    options.EnableDetailedErrors();
    options.EnableSensitiveDataLogging();
});


var app = builder.Build();
// activate Delta
app.UseDelta<ApplicationDbContext>();

Results

Ran two endpoints

Get a resource item.

Before enabling Delta

After enabling Delta

The response time reduced from 7ms to 6ms

Stress tested using a getAll resource endpoint returning 1000 items.

Before enabling Delta

After enabling Delta

The response time reduced from 13ms to 7ms

Conclusion

The Delta approach, by cleverly leveraging database change tracking, offers a powerful and efficient way to implement 304 Not Modified. It moves the responsibility of determining "what has changed" to the database, where it's the most efficient, freeing up your application server to focus on serving dynamic content. By embracing this strategy, you can significantly improve the performance, scalability, and user experience of your web applications. Consider integrating Delta into your caching strategy and unlock the full potential of 304 Not Modified!
Feel free to leave question or a comment about this.
Star Delta or sponsor Simon Cropp to give the package the platform it deserves.

OpenTelemetry in ASP .NET with Aspire

Ssewannonda Keith Edwin — Fri, 21 Feb 2025 14:02:02 +0000

OpenTelemetry

Its an Observability framework and toolkit designed to manage telemetry data that is traces, metrics, and logs.
It can be paired either #open source# tools like Aspire dashboard, Prometheus, and commercial ones like datadog.

Observability

Observability in software, is the potential to understand the internal state of a system by examining its telemetry data.
To make a system observable, it must be instrumented.

Why OpenTelemetry?

You own the data that you generate which is essential today in AI.
You need a single set of APIs and standards for all. These create the flexibility needed to create a modern application.

OpenTelemetry in ASP .NET

Search for OpenTelemetry.* in your project. There are many nuget packages for open telemetry as seen below.
Add them to your project:
Update your Program.cs file.

using OpenTelemetry.Resources;
using OpenTelemetry.Metrics;
using OpenTelemetry.Trace;
using OpenTelemetry.Logs;
using OpenTelemetry.Exporter;

var builder = WebApplication.CreateBuilder(args);
// code ommitted for brevity

builder.Services.AddOpenTelemetry()
.ConfigureResource(resource => 
    resource.AddService(ApiConstants.ApiName))
    .WithMetrics(metric =>
     {
       metric.AddAspNetCoreInstrumentation()
       .AddHttpClientInstrumentation();
       metric.AddOtlpExporter(options => 
       {
          options.Endpoint = new Uri("<url_to_export _to>");
       });
 })
 .WithTracing(trace =>
 {
     trace.AddAspNetCoreInstrumentation()
     .AddHttpClientInstrumentation();
     trace.AddOtlpExporter(options =>
     {
          options.Endpoint = new Uri("<url_to_export _to>");
      });
 });

 builder.Logging.AddOpenTelemetry(options => 
 {    
      options.AddConsoleExporter()
      .SetResourceBuilder(ResourceBuilder.CreateDefault()
      .AddService(ApiConstants.ApiName));

      options.AddOtlpExporter(options =>
      {
           options.Endpoint = new Uri("<url_to_export _to>");                   
      });
  });

Your application should be able to emit logs, traces and metrics.

Aspire dashboard

The open source standalone dashboard provides a great UI for viewing telemetry and can be used by any application.
To spin it up locally without auth, use this command
docker run --rm -it -d -p 18888:18888 -p 4317:18889 --name aspire-dashboard mcr.microsoft.com/dotnet/aspire-dashboard:9.0 -e DOTNET_DASHBOARD_UNSECURED_ALLOW_ANONYMOUS=true
For more .NET Aspire dashboard configuration

Feel free to leave question or a comment about this.
Star these wonderful projects to give them the platform they deserve:

TDD helper in c#

Ssewannonda Keith Edwin — Thu, 23 Jan 2025 16:16:33 +0000

Visibility is crucial in all aspects of life. This cuts through in programming as well. This is further given light when one is using #tdd(Test Driven Developemnt).

Logging significantly enhances TDD by providing insights into the behavior and execution of code.

How it helps

Debugging failing tests. In TDD, tests are first and then code to make them pass. If a test fails, logging can help you understand why by providing detailed runtime information. Logs capture intermediate states, variable values and execution flow making it easier to pinpoint issues at any step.
Tracking execution flow. Logs verify whether the control flow matches your expectations, especially in complex logic, without needing to use a debugger. One is able to confirm if specific code paths like conditionals or loops are being executed as intended. For example a coffee shop when one orders a latte not a macchiato.
Capturing edge cases. Logs provide a clear record of how the system behaves in edge cases. This feedback is invaluable when refining tests to ensure comprehensive coverage and also enforcing defensive coding techniques.
Understanding system behavior Whether initiating new functionality or refactoring code, logs help ensure that intended behavior remains consistent and aligns with the expected outputs defined by tests made.
Supporting collaboration. Dev teams need a common reference point for understanding and diagnosing issues discovered during test runs and logging provides that out of the box. This minimizes the need for extensive verbal explanations by showing exact system behavior in an instant.
Improving test quality. Logs help identify gaps in test cases by highlighting untested paths or unexpected behavior that may not yet be covered in tests.
Reproducing sporadic failures For flaky or irregular test failures, logs capture valuable information like timestamps, system state, exceptions that can help diagnose and resolve the issue.

Logging in `c#` tests

Neovolve.Logging.Xunit written by Rory Primrose
is a NuGet package that provides an ILogger or ILogger<T>, which integrates with the ITestOutputHelper used by xUnit. This helper enables log messages to be written directly to the test output during each test execution. As a result, any log messages from the tested classes are included in the xUnit test result output.

public class OrderServiceTests
{
    private readonly ITestOutputHelper _output;

    public OrderServiceTests(ITestOutputHelper output)
    {
        _output = output;
    }

    [Fact]
    public void PrepareOrderReturnsValue()
    {
        using var logger = output.BuildLoggerFor<OrderService>();

        var act = new OrderService(logger);

        var result = act.PrepareOrder();

        // The xUnit test output should now include the log message from OrderService.PrepareOrder()

        result.Should().NotBeNull();
    }
}

By integrating logging into your TDD workflow, one gains a clearer understanding of system behavior, resulting in faster debugging and more reliable tests and visibility in business logic.

Feel free to leave question or a comment about this and to star this wonderful nuget.

🚀 Create a CRUD web API with DATA API builder and EFCORE Power Tools 🚀

Ssewannonda Keith Edwin — Thu, 15 Aug 2024 20:18:00 +0000

In today's agile software development world, efficiency is paramount. I'm excited to share a quick way to create a fully functional CRUD Web API in just minutes using Data API Builder and EF Core Power Tools.

🔧 Why This Stack?

Data API Builder: Build and configure data-driven APIs with minimal effort. It abstracts much of the complexity, allowing you to focus on business concerns.
EF Core Power Tools: Generates clean, maintainable code for the database access layer, simplifying using EF Core.

📈 The Benefits:

Speed: Generates API endpoints rapidly without compromising on quality.
Scalability: With the solid foundation that EF Core provides, your applications can scale effortlessly.
Productivity: Focus on your business logic rather than boilerplate code, boosting your productivity and project timelines.

If you're on a project that needs rapid prototyping for a backend or want to streamline the development process, this combination is definitely worth exploring.

🔗 Ready to try it? Dive in and see how much time you can save!

Feel free to leave questions below

The ultimate Nuxt3 Vuetify3 setup

Ssewannonda Keith Edwin — Tue, 11 Apr 2023 14:07:01 +0000

Nuxt 3 has many advantages and is the best way to harness Vue 3 awesomeness.

Create a new Nuxt 3 project

use the following guide to create a new Nuxt 3 project
Upon successfully ✨ creating the Nuxt project with v3 template,Next steps:
Enter the project folder that you have just created
cd <project_folder>
Install dependencies using your favourite node package manager

// using npm
npm install 

// using yarn
yarn install 

// using pnpm
pnpm install

Start development server.

// using npm
npm run dev 

// using yarn
yarn dev

// using pnpm
pnpm run dev

Add Vuetify 3

Vuetify 3 is powerful Vue Component Framework based on Google’s Material Design specification and comes with hundreds of customisation options that fit any style or design; even if it’s not Material.
Add Vuetify to your project and support packages for sass and icons

// using npm
npm install vuetify@^3.1.13 sass @mdi/font

// using yarn
yarn add vuetify@^3.1.13 sass @mdi/font

// using pnpm
pnpm install vuetify@^3.1.13 sass @mdi/font

Create Vuetify plugin

There is need to add Vuetify as a Nuxt plugin.

Create a plugins folder and create a file named vuetify.js in it.

Add this code snippet in the vuetify.js file:

import { createVuetify } from "vuetify";
import * as components from "vuetify/components";
import * as directives from "vuetify/directives";

export default defineNuxtPlugin((nuxtApp) => {
  const vuetify = createVuetify({
    components,
    directives,
    ssr: true,
  });
  nuxtApp.vueApp.use(vuetify);
});

Vue 3 has no way to automatically detect if SSR is used — so nuxt, gridsome, and other SSR frameworks must manually set the ssr option to true in order to properly render the application.

Add nuxt config

Create nuxt config file with name nuxt.config.ts if it does not exist and add the following config:

// https://nuxt.com/docs/api/configuration/nuxt-config
export default defineNuxtConfig({
  css: [
     "vuetify/lib/styles/main.sass", 
     "@mdi/font/css/materialdesignicons.css"
  ],
  build: {
    transpile: [
      "vuetify"
    ],
  },
})

With this, you should be able to use Vuetify 3 components as you like.

The demo of the finished setup is here and the final code can be found here.

Mudblazor for Blazor

Ssewannonda Keith Edwin — Fri, 30 Sep 2022 20:53:51 +0000

There are two methods in software design. One is to make the program so simple, there are obviously no errors. The other is to make it so complicated, there are no obvious errors. - Tony Hoare

A software framework is a concrete or conceptual platform where common code with generic functionality can be selectively specialized or overridden by developers simplifying programming. Frameworks are libraries with a well-defined Application Program Interface (API) reusable anywhere within the software under development.

Introduction

.NET has had various templating frameworks since its inception in the early 2000's. From the likes of Windows Presentation Foundation (WPF), Windows Forms(WF), ASP.NET Core MVC, Razor Pages to Blazor and now .NET MAUI.
Microsoft offers a way to choose an ASP.NET Core web UI for developers to find the right user interface(UI) to use for their solution. The focus however is on Blazor and in particular for webAssembly.

WebAssembly

Shortened to Wasm, it is a binary instruction format for a stack-based virtual machine. Enables interoperability of programming languages, leading to deployment on the web for client and server applications.

Advantages

Efficient and fast using common hardware capabilities on a wide range of platforms
Open and debuggable designed to be pretty-printed in a textual format(on the web) for debugging, testing, experimenting, optimizing, educating and writing programs by hand.
Memory-safe in sandboxed execution environment usually inside existing JavaScript virtual machines. When embedded in the web, WebAssembly enforces the same-origin and permissions security policies of the browser.
WebAssembly is designed to maintain the versionless, feature-tested, and backwards-compatible nature of the web. WebAssembly modules call into and out of the JavaScript context and access browser functionality through the same Web APIs accessible from JavaScript. It also supports non-web embeddings.

Blazor

It is framework for building interactive client-side web UI.
Blazor apps are component based. Just like many JavaScript frameworks making the transition from them to Blazor easy. Blazor was initiated in 2018.

Advantages

Write code in C# instead of JavaScript.
Leverage the existing .NET ecosystem of .NET libraries.
Share app logic across server and client.
Benefit from .NET's performance, reliability, and security.
Stay productive cross platform Windows, Linux, or macOS.
Build on a common set of languages, frameworks, and tools that are stable, feature-rich, and easy to use.

Mudblazor

Just like any framework in JavaScript, it is never enough as a developer wants more advanced features which the different communities create. This makes software development easier as common tasks like authentication, state management to mention a few become a standard for the given framework. React JS has NextJS, Remix, Gatsby to mention a few, Vue has NuxtJS et al. So Blazor has MudBlazor which that extends its capabilities by adding functionalities that go beyond the display layer, which React is limited to.

Prerequisites

System that compiles and runs the .NET Framework
.NET SDK. The main version MudBlazor is using (LTS version).
A code editor, Jet Brains Rider, Visual Studio or VS Code.

This set up of Mudblazor either from scratch or in an existing Blazor project should get you started.

Demo Project

For a Demo project, I created a UI showing SpaceX launches upto date. At the time of writing it was in .NET 6.

SpaceX API

Space Exploration Technologies Corp. (doing business as SpaceX) is an American spacecraft manufacturer, space launch provider, and a satellite communications corporation headquartered in Hawthorne, California. Founded in 2002 by Elon Musk, to reduce space transportation costs to enable the colonization of Mars. It manufactures the Falcon 9 and Falcon Heavy launch vehicles, several rocket engines, Cargo Dragon, crew spacecraft, and Starlink communications satellites.

Demo

The live demo can be found here.

The information gotten from a SpaceX REST API
One is able to see a list of MudBlazor cards showing the name and image for a mission with card actions showing a learn more button and another to show the video launch on YouTube if it exists. So many components were used which are common in various JavaScript frameworks showing the ease to use.

Github repo

The source code can be found here.

Future

The future is certainly bright in terms of improvements of the performance of Blazor as seen in the blog post.

Seq on Azure Web Apps is no more

Ssewannonda Keith Edwin — Fri, 02 Sep 2022 15:09:50 +0000

What is Seq?

Seq is is a real-time centralized, search and analysis server for structured application log data. Its richly featured user interface, JSON event store, and familiar query language syntax makes it efficient to detect and diagnose issues in complex applications and microservices.

As it is self-hosted and cross platform it can be deployed either on-premise or in the cloud.
The cloud option makes it an attractive proposition to use as it is as easy to setup as azure make this a seamless process.

Azure web app support ends

However, in August 2022, the maintainers of this popular open source application log ingesting service, announced that they had stopped support for both Azure websites and Azure web apps.
The main reason as per the documentation

These services permit container instances to run concurrently, which will cause storage corruption when hosting Seq.

The issues related to this have been reported since 2018 as seen per the GitHub issues below.

In one of the responses, as seen in the screenshot below, they had advised against using this approach.

Alternative options

Serverless

Those who still want to use serverless Docker container hosting in Azure, Azure Container Instances (ACI) is an option.
However, for persistent storage an Azure Premium Files share must be used. Seq further recommends using Azure Kubernetes Services (AKS)

Virtual machine

This serves as a better alternative in my experience as there is no interference in Seq data and then the complete control over it's management.

A swiss knife for a developer

Ssewannonda Keith Edwin — Sat, 16 Jul 2022 10:48:47 +0000

According to Macmillan dictionary, A swiss knife means

a method or system that deals with situations of all types.

For a typical developer during times of prototyping where a demo is required and you want to get placeholders whether in either a front-end or back-end setting, you need a few types on the go to so that you concentrate on the business need than extras that will articulate your designs. However, most online tools offer one solution like formatting a json object, getting a GUID (UUID v4) and so on.

IT tools tech is that swiss knife for a developer. It is a responsive application made with VueJS that enables a developer reduce time either scraping the web or installing a flurry of CLI tools to get quick sample types needed for a prototype showcase.

Sidebar

It has well categorized sidebar making finding what you find easily. As of version 2.5.1, these are the categories;

Crypto
Converter
Web
Development
Math
Text

Search bar

This auto complete which offers simple and flexible type-ahead functionality leading to dynamic search of the tools in the IT Tools.

Main

This features a responsive card grid of the available tools on the site with brief descriptions of what they do. This makes it easier in accessing the tools. They have both light and dark themes to make it comfortable for the eyes at the the different time of the day.

Conclusion

Dealing with tokens, Date-time IT Tools a super App for developers.
Do not forget to try it out leave a GitHub star or sponsor the creators for the awesome and handy tool they envisioned.

Elegant seeding of data in ASP .NET 6

Ssewannonda Keith Edwin — Wed, 04 May 2022 14:48:11 +0000

Seeding data to a database is one of those to-dos a backend developer encounters when they have to initialize an API that they are building while in the development phase. This gives the both the backend and front end teams data to work with and to a certain extent the end to end integration required. This eases the work front end teams to integrate with a given API without them referring tom mock ups.

In this quick post, I show you how to seed data to any database in ASP.NET 6 Web API.

Initial Setup

Once you've created your Web API you need to add Entity Framework NuGet packages:

dotnet add package Microsoft.EntityFrameworkCore --version 6.0.3
dotnet add package Microsoft.EntityFrameworkCore.Abstractions --version 6.0.3 
dotnet add package Microsoft.EntityFrameworkCore.Analyzers --version 6.0.3
dotnet add package Microsoft.EntityFrameworkCore.Design --version 6.0.3 
dotnet add package Microsoft.EntityFrameworkCore.InMemory --version 6.0.3
dotnet add package Microsoft.EntityFrameworkCore.SqlServer --version 6.0.3 
dotnet add package Microsoft.EntityFrameworkCore.Tools --version 6.0.3

Add Entity

You then create an entity that will be used by the API. Here I used the default WeatherForecast model that comes with the new Web API project from the previous step.

public class WeatherForecast 
{
     public DateTime Date { get; set; }
     public int TemperatureC { get; set; }
     public string? Summary { get; set; }
}

Add ApplicationDbContext

using Microsoft.EntityFrameworkCore;

namespace SeedWebApplication.Data.Context
{
#nullable disable
    public class ApplicationDbContext : DbContext
    {
        public ApplicationDbContext()
        {
        }

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

        public DbSet<WeatherForecast> WeatherForecasts { get; set; }
    }
}

Create a seed class

This is the class that adds a few records to your database.

namespace SeedWebApplication.Data
{
    public static class SeedData
    {
        public static void PopulateDb(IApplicationBuilder app)
        {
            using var serviceScope = app.ApplicationServices.CreateScope();
            AddInitialData(serviceScope.ServiceProvider.GetService<ApplicationDbContext>()!);
        }

        private static void AddInitialData(ApplicationDbContext context)
        {
            if (!context.WeatherForecasts.Any())
            {
                var summaries = new[]
                {
                    "Freezing", "Bracing", "Chilly", "Cool", "Mild", "Warm", "Balmy", "Hot", "Sweltering", "Scorching"
                };

                var seedForecasts = Enumerable.Range(1, 20).Select(index =>
                       new WeatherForecast
                       {
                           Id = Guid.NewGuid(),
                           Date = DateTime.Now.AddDays(index),
                           Created = DateTime.Now.AddDays(-7),
                           Updated = DateTime.Now.AddDays(-5),
                           TemperatureC = Random.Shared.Next(-20, 55),
                           Summary = summaries[Random.Shared.Next(summaries.Length)]
                      })
                    .ToList();

                context.WeatherForecasts.AddRange(seedForecasts);
                context.SaveChanges();
                Console.WriteLine("Seeded data to the Database");
            }
        }
    }
}

Modify program.cs

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddDbContext<ApplicationDbContext>(options =>
         options.UseInMemoryDatabase("inmemo"));


var app = builder.Build();


SeedData.PopulateDb(app);

app.Run();

And yes you have successfully seeded data to your database!

Source code for complete solution can be found on my Github

Until next time, love your neighbor, love yourself!

DEV Community: Ssewannonda Keith Edwin

The Delta Difference: Unleashing .NET, EF Core, and PostgreSQL Performance with Delta

Introduction

Tech Stack choice

Steps to use Delta

Results

Before enabling Delta

After enabling Delta

Before enabling Delta

After enabling Delta

Conclusion

OpenTelemetry in ASP .NET with Aspire

OpenTelemetry

Observability

Why OpenTelemetry?

OpenTelemetry in ASP .NET

Aspire dashboard

TDD helper in c#

How it helps

Logging in c# tests

🚀 Create a CRUD web API with DATA API builder and EFCORE Power Tools 🚀

🔧 Why This Stack?

📈 The Benefits:

The ultimate Nuxt3 Vuetify3 setup

Create a new Nuxt 3 project

Add Vuetify 3

Create Vuetify plugin

Add nuxt config

Mudblazor for Blazor

Introduction

WebAssembly

Advantages

Blazor

Advantages

Mudblazor

Prerequisites

Demo Project

SpaceX API

Demo

Github repo

Future

Seq on Azure Web Apps is no more

What is Seq?

Azure web app support ends

Alternative options

Serverless

Virtual machine

A swiss knife for a developer

Sidebar

Search bar

Main

Conclusion

Elegant seeding of data in ASP .NET 6

Initial Setup

Add Entity

Add ApplicationDbContext

Create a seed class

Modify program.cs

Logging in `c#` tests