DEV Community: Karen Payne

dotnet Framework life cycle tool

Karen Payne — Mon, 25 May 2026 22:36:16 +0000

Introduction

Learn how to create a dotnet Global Tool that lists all NET Core Frameworks with release and end-of-life information.

💡 For my other article on creating various dotnet tools see
C# .NET Tools with System.CommandLine.

This tool is extremely simple: unlike most tools, there are no required arguments or help; the code reads information from the following URL and displays it.

dotnetcli.azureedge.net

Main code

Core Source code

Located in CommonLibrary project

using CommonLibrary.Models;
using System.Text.Json;

namespace CommonLibrary;

public static class DotNetReleaseService
{
    private static readonly HttpClient _httpClient = new();

    public static async Task<List<ReleaseIndexItem>> GetReleaseIndexAsync(CancellationToken cancellationToken = default)
    {
        const string url = "https://dotnetcli.azureedge.net/dotnet/release-metadata/releases-index.json";

        using HttpResponseMessage response = await _httpClient.GetAsync(url, cancellationToken);
        response.EnsureSuccessStatusCode();

        await using var stream = await response.Content.ReadAsStreamAsync(cancellationToken);

        var root = await JsonSerializer.DeserializeAsync<ReleasesIndexRoot>(
            stream,
            Options,
            cancellationToken);

        return root?.ReleasesIndex ?? [];
    }


    public static JsonSerializerOptions Options 
        => new() { PropertyNameCaseInsensitive = true };
}


public sealed class ReleaseIndexItem
{
    [JsonPropertyName("channel-version")]
    public string? ChannelVersion { get; set; }

    [JsonPropertyName("latest-release")]
    public string? LatestRelease { get; set; }

    [JsonPropertyName("latest-release-date")]
    public DateTime? LatestReleaseDate { get; set; }

    [JsonPropertyName("security")]
    public bool Security { get; set; }

    [JsonPropertyName("latest-runtime")]
    public string? LatestRuntime { get; set; }

    [JsonPropertyName("latest-sdk")]
    public string? LatestSdk { get; set; }

    [JsonPropertyName("product")]
    public string? Product { get; set; }

    /// <summary>
    /// Gets or sets the support phase of the release.
    /// </summary>
    /// <remarks>
    /// The support phase indicates the current lifecycle stage of the release, 
    /// such as "active", "preview", or "eol" (end of life).
    /// </remarks>
    [JsonPropertyName("support-phase")]
    public string? SupportPhase { get; set; }

    [JsonPropertyName("eol-date")]
    public DateTime? EndOfLifeDate { get; set; }

    [JsonPropertyName("release-type")]
    public string? ReleaseType { get; set; }

    [JsonPropertyName("releases.json")]
    public string? ReleasesJsonUrl { get; set; }
}


public sealed class ReleasesIndexRoot
{
    [JsonPropertyName("releases-index")]
    public List<ReleaseIndexItem>? ReleasesIndex { get; set; }

Entry point code

Source code

using CommonLibrary;
using Spectre.Console;
using SpectreConsoleLibrary.Core;
using System.CommandLine;

namespace FrameworkLifeCycle;

internal partial class Program
{
    static async Task Main(string[] args)
    {
        RootCommand rootCommand = new("Get dotnet framework life cycles");

        var releases = await DotNetReleaseService.GetReleaseIndexAsync();

        SpectreConsoleHelpers.InfoPill(Justify.Left, $"Found {releases.Count} releases.");
        Console.WriteLine();

        var table = new Table().Title("[bold blue] .NET Release Information [/]");
        table.AddColumn(new TableColumn("[bold yellow]Channel[/]"));
        table.AddColumn(new TableColumn("[bold yellow]Latest[/]"));
        table.AddColumn(new TableColumn("[bold yellow]ReleaseType[/]"));
        table.AddColumn(new TableColumn("[bold yellow]End Of Life Date[/]"));
        table.AddColumn(new TableColumn("[bold yellow]Support[/]"));

        foreach (var item in releases)
        {

            var eolText = item.EndOfLifeDate.HasValue
                ? item.EndOfLifeDate.Value.ToString("MM/dd/yyyy")
                : "Not set";

            var releaseType = item.ReleaseType ?? "Unknown";
            if (releaseType != "Unknown")
            {
                releaseType = releaseType.ToUpper();
            }

            table.AddRow(
                FrameworkUtilities.IsProjectFramework(item.ChannelVersion ?? ""),
                item.LatestRelease ?? "",
                releaseType,
                eolText,
                Colorize(item.SupportPhase ?? "Unknown"));
        }

        AnsiConsole.Write(table);
        Console.WriteLine();

    }

    private static string Colorize(string input) =>
        input switch
        {
            { } s when s.Contains("active", StringComparison.OrdinalIgnoreCase) => "[green]Active[/]",
            { } s when s.Contains("eol", StringComparison.OrdinalIgnoreCase) => "[red]eol[/]",
            { } s when s.Contains("preview", StringComparison.OrdinalIgnoreCase) => "[yellow]preview[/]",
            _ => input,
        };
}

Project file

<PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net10.0</TargetFramework>
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>enable</Nullable>
    <PackAsTool>true</PackAsTool>
    <ToolCommandName>flc</ToolCommandName>
    <PackageOutputPath>./nupkg</PackageOutputPath>
    <GeneratePackageOnBuild>True</GeneratePackageOnBuild>
    <Version>1.0.0</Version>
</PropertyGroup>

PackAsTool Indicate this as a dotnet tool
ToolCommandName the command to run as at the command line
PackageOutputPath Path to binaries

Summary

Once installed, typing flc will list all dot net Framework life cycles and for many developers be their first useful donet tool.

💡 For my other article on creating various dotnet tools, see
C# .NET Tools with System.CommandLine, which shows how to work with arguments and provide help.

EF Core Named query filters

Karen Payne — Tue, 19 May 2026 00:20:54 +0000

Introduction

EF Core 10 introduces named query filters, an improvement to global query filters that makes common patterns like soft deletion and multitenancy easier to manage. In earlier versions, each entity type effectively had one combined filter, which meant disabling filters for a special query was all-or-nothing. With EF Core 10, filters can be given individual names, such as SoftDeletionFilter or TenantFilter, allowing developers to define multiple filters on the same entity and selectively disable only the ones needed for a specific LINQ query. This gives applications more precise control while keeping the default filtering behavior clean, consistent, and centralized. (learn.microsoft.com)

Topics covered

Creating filters
Ignoring filters
Using supplied language extensions for checking filter(s) exists for a model

Source code

The provided source code is fully documented.
SQL has been provided to create the database.

Source code samples Source code for language extension

Table schema for code samples

Employee schema, IsDeleted column for soft delete, IsManager indicates if the record is a manager.

Soft delete DbContext setup

SaveChanges event needs to be overridden so that a record is not removed, instead State is set to modified and IsDeleted column/property is set to true.

public override async Task<int> SaveChangesAsync(CancellationToken cancellationToken = default)
{
    ChangeTracker.DetectChanges();

    foreach (var entry in ChangeTracker.Entries())
    {
        if (entry.State == EntityState.Deleted)
        {
            // Change state to modified and set delete flag
            entry.State = EntityState.Modified;
            entry.Property("IsDeleted").CurrentValue = true;
        }
    }

    return await base.SaveChangesAsync(cancellationToken);

}

public override int SaveChanges()
{

    ChangeTracker.DetectChanges();

    foreach (var entry in ChangeTracker.Entries())
    {
        if (entry.State == EntityState.Deleted)
        {
            // Change state to modified and set delete flag
            entry.State = EntityState.Modified;
            entry.Property("IsDeleted").CurrentValue = true;
        }
    }

    return base.SaveChanges();

}

Filter setup

For the provided code sample, there is a filter for soft delete and a filter for if a record is a manager.

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<Employee>(entity =>
    {
        entity.Property(e => e.FirstName)
            .IsRequired()
            .HasMaxLength(50);
        entity.Property(e => e.LastName)
            .IsRequired()
            .HasMaxLength(50);

        entity.HasQueryFilter("SoftDelete", e => !e.IsDeleted);
        entity.HasQueryFilter("IsManager", e => e.IsManager);

    });

    OnModelCreatingPartial(modelBuilder);
}

Performing a soft delete

In this case the overridden SaveChangesAsync is used which changes the State from Deleted to Modified.

AnsiConsole.MarkupLine is from Spectre.Console

private static async Task PerformDelete()
{

    SpectreConsoleHelpers.PrintPink();

    int id = 2;

    await using var context = new Context();
    var employee = await context.Employees.FirstOrDefaultAsync(x => x.Id == id);

    if (employee is not null)
    {
        context.Employees.Remove(employee).State = EntityState.Deleted;
        var affected = await context.SaveChangesAsync();
        AnsiConsole.MarkupLine(affected > 0
            ? $"[green]Successfully deleted employee with ID {id}.[/]"
            : $"[red]Failed to delete employee with ID {id}. Affected rows: {affected}[/]");
    }
    else
    {
        AnsiConsole.MarkupLine($"[yellow]Employee with ID {id} not found.[/]");
    }
}

Ignore a filter

using var context = new Context();
var employees = context.Employees
    .IgnoreQueryFilters(["SoftDelete"])
    .ToList();

Get query filter language extensions

These can be helpful when a developer doesn't have the DbContext source code.

public static class DbContextExtensions
{

    extension(DbContext context)
    {

        public bool HasQueryFilter<TEntity>()  where TEntity : class
        {
            var entityType = context.Model.FindEntityType(typeof(TEntity));
            return entityType?.GetDeclaredQueryFilters() != null;
        }

        public IReadOnlyCollection<IQueryFilter>? GetQueryFilters<TEntity>() where TEntity : class
        {
            var entityType = context.Model.FindEntityType(typeof(TEntity));
            return entityType?.GetDeclaredQueryFilters();
        }

        public IReadOnlyCollection<IQueryFilter> TryGetQueryFilters<TEntity>() where TEntity : class
        {
            var entityType = context.Model.FindEntityType(typeof(TEntity));
            var filters = entityType?.GetDeclaredQueryFilters();
            return filters ?? [];
        }

    }
}

One sample

private static void DisplayEmployeeQueryFilters()
{
    using var context = new Context();
    if (context.HasQueryFilter<Employee>())
    {
        var filters = context.GetQueryFilters<Employee>();

        if (filters is null) return;

        foreach (var (index, filter) in filters.Index())
        {
            AnsiConsole.MarkupLine($"{index, -4}" +
                                    $"[cyan]Name[/] {filter.Key} " +
                                    $"[cyan]Expression[/] {filter.Expression}");
        }
    }
    else
    {
        AnsiConsole.MarkupLine("[red]No query filters found for Employee entity.[/]");
    }
}

Summary

The EF Core team has made it easy to set multiple query filters, and by following the instructions and sample code provided, developers can use named query filters.

ASP .NET Core Bootstrap toast

Karen Payne — Sat, 16 May 2026 20:23:02 +0000

Introduction

Bootstrap toasts are lightweight notifications that mimic the push notifications popularized by mobile and desktop operating systems.

Learn how to merge C# code into toast to make toast flexible.

Source code net10

Get coding

Toast options for demonstration are read from appsettings.json, while toast options may be hard-coded in code.

{
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft.AspNetCore": "Warning"
    }
  },
  "AllowedHosts": "*",
  "ToastOptions": {
    "DatabaseError": {
      "ToastMessage": "Failed to open database!",
      "ToastTitle": "Error",
      "ToastDelay": 10000
    }
  }
}

In the above ToastOptions has DatabaseError item which allows you to have multiple toast configurations.

These classes are used to parse the json above.

public class ToastOptions
{
    public ToastMessageOptions DatabaseError { get; set; } = new();
}

public class ToastMessageOptions
{
    public string ToastMessage { get; set; } = string.Empty;
    public string ToastTitle { get; set; } = string.Empty;
    public int ToastDelay { get; set; }
}

Program.cs code using dependency injection to read settings.

public class Program
{
    public static void Main(string[] args)
    {
        var builder = WebApplication.CreateBuilder(args);

        // Add services to the container.
        builder.Services.AddRazorPages();

        // Configure ToastOptions using the appsettings.json configuration section  
        builder.Services.Configure<ToastOptions>(
            builder.Configuration.GetSection(nameof(ToastOptions)));

        // Register the ReadToastConfiguration service for dependency injection
        builder.Services.AddScoped<ReadToastConfiguration>();

        var app = builder.Build();

        ...

Razor page front-end

The top section is where the business code resides. Here is a button to trigger the toast
asp-page-handler="ShowToast" relates to the following post event public IActionResult OnPostShowToast()
The bottom section is the toast which uses model properties to configure the toast

@page
@model IndexModel
@{
    ViewData["Title"] = "Bootstrap Toast Demo";
}

<div class="container mt-5">

    <h1 class="mb-4 fs-4 text-center">Bootstrap 5 Toast from C#</h1>

    <main>
        <form method="post" asp-page-handler="ShowToast" class="text-center">
            <button type="submit" class="btn btn-danger">
                Show error Toast
            </button>
        </form>
    </main>

</div>

@if (!string.IsNullOrWhiteSpace(Model.ToastMessage))
{
    <div class="toast-container position-fixed bottom-0 end-0 p-3">
        <div id="serverToast"
             class="toast text-bg-danger border-0"
             role="alert"
             aria-live="assertive"
             data-bs-delay="@Model.ToastDelay"
             aria-atomic="true">

            <div class="toast-header">
                <span class="me-2">
                    <img src="images/databasex.svg" alt=""/>
                </span>
                <strong class="me-auto">@Model.ToastTitle</strong>
                <small>@DateTime.Now.ToShortTimeString()</small>
                <button type="button"class="btn-close" data-bs-dismiss="toast" aria-label="Close"></button>
            </div>

            <div class="toast-body">
                @Model.ToastMessage
            </div>
        </div>
    </div>
}

@section Scripts {
    @if (!string.IsNullOrWhiteSpace(Model.ToastMessage))
    {
        <script>
            document.addEventListener("DOMContentLoaded", function () {
                const toastElement = document.getElementById("serverToast");

                if (toastElement) {
                    const toast = new bootstrap.Toast(toastElement, {
                        autohide: true
                    });

                    toast.show();
                }
            });
        </script>
    }
}

Razor page back-end

Primary constructor for ReadToastConfiguration setup in Program.cs
Post to set toast options

public class IndexModel(ReadToastConfiguration readToast) : PageModel
{
    [TempData]
    public string? ToastMessage { get; set; }

    [TempData]
    public string? ToastTitle { get; set; }

    [TempData]
    public int ToastDelay { get; set; }

    public void OnGet()
    {
    }

    public IActionResult OnPostShowToast()
    {
        var options = readToast.GetToastOptions();

        ToastTitle = options.DatabaseError.ToastTitle;
        ToastMessage = options.DatabaseError.ToastMessage;
        ToastDelay = options.DatabaseError.ToastDelay;

        return RedirectToPage();

    }
}

Summary

In this article, developers are shown how to create a Bootstrap toast efficiently, with JavaScript needed only to set up one event to show the toast.

Never stop learning

Karen Payne — Sat, 02 May 2026 23:20:43 +0000

Introduction

It’s a wonderful time to be a developer with rich tools, documentation, and artificial intelligence. Still, at least for now and the foreseeable future, developers must learn to write code, as artificial intelligence tools are not perfect and may produce code that is difficult to integrate into an existing code base.

For developers just starting out, they need to learn the basics, then OOP and database work.

For experienced developers, the next step is to hone their skills to get and keep a full-time job. For instance, C# .NET Core has a new feature; take time to learn it, even if there is no immediate use for it. Another path is to check out questions in developer forums, analyze all aspects of a question, and what can be learned or avoided.

The following applies to developers using Microsoft Visual Studio, C#, and .NET 8 or higher.

Visual Studio solution for learning

Create a Visual Studio solution for learning and use solution folders to categorize topics.

When code appears useful across multiple projects, place it in a class project (note the folder for class projects in the screenshot below).

Starter learning ideas

Request for a login for a console project

First, check out the following thread in its entirety, which is what AI might form a response from. Now let's explore a better way using Spectre.Console NuGet package.

Spectre.Console TextPrompt prompts users to enter text input with validation, default values, and secret input masking.

Will be used to ensure a non-empty string is returned
The password text is masked
Both username and password use the same colors
Has sufficient validation for testing purposes, hard-coded

using Spectre.Console;
using SpectreLoginSample.Classes.Core;

namespace SpectreLoginSample.Classes;
internal class Prompts
{
    public static string PromptStyleColor { get; set; } = "cyan";
    public static string PromptColor { get; set; } = "bold";

    public static bool TryLogin(int maxAttempts = 3)
    {
        for (int attempt = 1; attempt <= maxAttempts; attempt++)
        {
            var username = GetUserName(allowEmpty: false);
            var password = GetPassword();

            if (ValidateCredentials(username, password))
            {
                AnsiConsole.MarkupLine("[green]Login successful[/]");
                return true;
            }

            /*================================================================
             * The text displays remaining attempts which is optional.
             * Showing remaining attempts can be a helpful for testing.
             ================================================================*/

            if (attempt < maxAttempts)
            {
                AnsiConsole.MarkupLine($"[red]Invalid credentials[/] - Attempts remaining: {maxAttempts - attempt} press [bold]ENTER[/] to retry");
                SpectreConsoleHelpers.ContinuePrompt();
            }
            else
            {
                AnsiConsole.MarkupLine("[red]Maximum attempts reached. Access denied.[/] press [bold]ENTER[/] to exit");
                SpectreConsoleHelpers.ContinuePrompt();
            }


        }

        return false;
    }

    public static bool ValidateCredentials(string username, string password)
    {
        return username == "admin" && password == "password";
    }

     public static string GetUserName(bool allowEmpty)
    {
        return allowEmpty
            ? AnsiConsole.Prompt(
                new TextPrompt<string>($"[{PromptColor}]User name[/]")
                    .PromptStyle(PromptStyleColor)
                    .AllowEmpty())
            : AnsiConsole.Prompt(
                new TextPrompt<string>($"[{PromptColor}]User name[/]:")
                    .PromptStyle(PromptStyleColor));
    }


    public static string GetPassword() =>
        AnsiConsole.Prompt(
            new TextPrompt<string>($"[{PromptColor}]Password[/]:")
                .PromptStyle("grey50")
                .Secret()
                .DefaultValueStyle(new Style(Color.Aqua)));
}

Source code

This is considered a good learning experience, as once the login code is finished, there is more to explore in this library. Where this library is good for: dotnet tools and console project utilities.

File Globbing to the rescue

File globbing is a topic every developer needs to learn. A glob is a term used to define patterns for matching file and directory names based on wildcards. Globbing is the act of defining one or more glob patterns and yielding files from either inclusive or exclusive matches.

Imagine a developer uses OneDrive for backups, and once the backup completes, all files are removed from the local drive. So the developer reverts the backup and learns that some files have copies. Rather than manually deleting the copies (in this case, 5,000+ copies), after learning about file globbing, the developer can write code to remove them in a simple console project.

Code to create a list of copies.

💡 AddExcludePatterns excludes folders that may need special permissions to read.

public static async Task<List<FileMatchItem>> GetDuplicatesTask(string parentFolder )
{
    List<FileMatchItem> list = [];
    Matcher matcher = new();
    matcher.AddIncludePatterns([
        "**/* - Copy .*", 
        "**/* - Copy (*.*"
    ]);
    matcher.AddExcludePatterns([
        "**/My Music/**",
        "**/My Pictures/**",
        "**/My Videos/**"
    ]);

    await Task.Run(() =>
    {
        foreach (string file in matcher.GetResultsInFullPath(parentFolder))
        {
            list.Add(new FileMatchItem(file));
        }
    });

    await File.WriteAllLinesAsync($"Duplicates.txt", 
        list.Select(item => item.ToString()));

    return list;
}

Code to remove files

public static async Task ProcessOneDriveDuplicates()
{
    var folder = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);
    var list = await Globbing.GetDuplicatesTask(folder);

    if (list.Count >0)
    {
        AnsiConsole.MarkupLine($"[bold green]Found {list.Count} duplicate files.[/]");

    }else
    {
        AnsiConsole.MarkupLine($"[bold green]No duplicate files found in {folder}.[/]");
        return;
    }

    foreach (var (index, item) in list.Index())
    {
        try
        {
            if (File.Exists(item.FullName))
            {
                File.Delete(item.FullName);
            }
            else
            {
                AnsiConsole.MarkupLine($"[yellow bold]{item.FullName}[/]");
            }
        }
        catch (Exception e)
        {
            AnsiConsole.MarkupLine($"[red bold]Failed to delete " +
                                    $"{index} {item.FullName}[/]");
        }
    }


}

Source code

Summary

No matter if a developer vibes codes, uses artificial intelligence for what they get stuck on or doesn’t use AI try and learn something new at least once a week. Karen tries to learn something new several times a week.

Display project Attributes (C#)

Karen Payne — Sun, 26 Apr 2026 20:35:47 +0000

Introduction

Learn how to read project properties stored in a C# project file.

By storing property values in the project file rather than in code or appsettings.json.

💡 No tampering once pushed to production.

Step 1

Add the following PropertyGroup to a .csproj file and replace values with your values.

<PropertyGroup>
    <Product>Code sample</Product>
    <Description>A sample project demonstrating assembly metadata retrieval.</Description>
    <Company>Payne services</Company>
    <Copyright>2019-$([System.DateTime]::Now.Year)</Copyright>
</PropertyGroup>

Step 2

Add the following project reference to the project Source code , which contains code to read values from the project file in step 1.

Step 3

Display values in an ASP.NET Core project.

Index.cshtml.cs

public class IndexModel(ILogger<IndexModel> logger) : PageModel
{
    [BindProperty]
    public required Details Details { get; set; }
    private readonly ILogger<IndexModel> _logger = logger;

    public void OnGet()
    {
        Details = GetAllInfo();
    }

    Details GetAllInfo() =>
        new()
        {
            Company = Info.GetCompany(),
            Copyright = Info.GetCopyright(),
            Product = Info.GetProduct(),
            Description = Info.GetDescription(),
            Version = Info.GetVersion().ToString()
        };
}

Index.cshtml (using Bootstrap 5x)

@page
@model IndexModel
@{
    ViewData["Title"] = "Home page";
}
<style>
    .table tr > td:first-child {
        font-weight: bold;
        text-align: right;
    }
    H1 {
        margin-bottom: 1em;
    }
</style>

<div class="container">
    <main>
        <h1 class="fs-3">Code sample</h1>
        <table class="table table-striped table-borderless">
            <tr>
                <td>Product</td>
                <td>@Model.Details.Product</td>
            </tr>
            <tr>
                <td>Version</td>
                <td>@Model.Details.Version</td>
            </tr>
            <tr>
                <td>Copyright</td>
                <td>@Model.Details.Copyright</td>
            </tr>
            <tr>
                <td>Company</td>
                <td>@Model.Details.Company</td>
            </tr>
            <tr>
                <td>Description</td>
                <td>@Model.Details.Description</td>
            </tr>
        </table>
    </main>
</div>

Display values in a Console Core project.

Uses the same class project as used in the ASP.NET Core project
The following method gets the values to display using NuGet package Spectre.Console.

internal static void ShowDetails()
{
    var table = new Table()
        .RoundedBorder()
        .BorderColor(Color.Pink1)
        .Title("[yellow bold]Information[/]");

    table.AddColumn("[yellow bold]Attribute[/]");
    table.AddColumn("[yellow bold]Value[/]");

    var details = GetAllInfo();
    table.AddRow("[cyan]Product[/]", details.Product);
    table.AddRow("[cyan]Version[/]", details.Version);
    table.AddRow("[cyan]Copyright[/]", details.Copyright);
    table.AddRow("[cyan]Company[/]", details.Company);
    table.AddRow("[cyan]Description[/]", details.Description);
    AnsiConsole.Write(table);


    Details GetAllInfo()
    {
        return new Details()
        {
            Company = Info.GetCompany(),
            Copyright = Info.GetCopyright(),
            Product = Info.GetProduct(),
            Description = Info.GetDescription(),
            Version = Info.GetVersion().ToString()
        };
    }
}

Display code.

internal partial class Program
{
    static void Main(string[] args)
    {

        ShowDetails();

        SpectreConsoleHelpers.ExitPrompt(Justify.Left);
    }
}

.NET 9 Core source

Core class project

ASP.NET Core project

Console project

ASP.NET Core startup validation part 4

Karen Payne — Sun, 22 Mar 2026 22:10:30 +0000

Introduction

Learn how to use a class that implements IValidateOptions to validate that sections exist with the required keys in the appsettings.json file.

Source code

Source code requires Microsoft Visual Studion 2022 or higher.

appsettings.json

{
  "Logging": {
    "LogLevel": {
      "Microsoft.EntityFrameworkCore.Database.Command": "Information",
      "Default": "Information",
      "Microsoft.AspNetCore": "Warning"
    }
  },
  "AllowedHosts": "*",
  "Helpdesk": {
    "Phone": "123-456-7890",
    "Email": "helpdesk@example.com"
  }
}

In the file, we want to validate that both Logging and HelpDesk are validated.

Required classes

💡 properties must be nullable for validation code to work.

public class LogLevelSettings
{
    public string? Default { get; set; } = string.Empty;

    [ConfigurationKeyName("Microsoft.AspNetCore")]
    public string? MicrosoftAspNetCore { get; set; } = string.Empty;

    [ConfigurationKeyName("Microsoft.EntityFrameworkCore.Database.Command")]
    public string? MicrosoftEntityFrameworkCoreDatabaseCommand { get; set; } = string.Empty;
}

public class HelpDesk
{
    public string? Phone { get; set; }
    public string? Email { get; set; }
}

_Layout.cshtml

Note that the following lines are needed for displaying HelpDesk values

@using GetSettingFromAppSettings.Models
@using Microsoft.Extensions.Options
@inject IOptions<HelpDesk> HelpdeskOptions

Validation class

Responsible for the validation of a section in the above appsettings file.

The Validate method checks:
- For required sections
- Calls ValidateValue to check that the required keys exist

If errors list is not empty indicates failure.

public sealed class LoggingSettingsValidation(IConfiguration configuration) : 
    IValidateOptions<LoggingSettings>
{

    public ValidateOptionsResult Validate(string? name, LoggingSettings options)
    {
        List<string> errors = [];

        var loggingSection = configuration.GetSection("Logging");
        if (!loggingSection.Exists())
        {
            errors.Add("Configuration section 'Logging' is missing.");
            return ValidateOptionsResult.Fail(errors);
        }

        var logLevelSection = configuration.GetSection("Logging:LogLevel");
        if (!logLevelSection.Exists())
        {
            errors.Add("Configuration section 'Logging:LogLevel' is missing.");
            return ValidateOptionsResult.Fail(errors);
        }

        ValidateValue("Logging:LogLevel:Default", errors);
        ValidateValue("Logging:LogLevel:Microsoft.AspNetCore", errors);
        ValidateValue("Logging:LogLevel:Microsoft.EntityFrameworkCore.Database.Command", errors);

        return errors.Count > 0
            ? ValidateOptionsResult.Fail(errors)
            : ValidateOptionsResult.Success;
    }


    private void ValidateValue(string key, List<string> errors)
    {
        var value = configuration[key];

        if (string.IsNullOrWhiteSpace(value))
        {
            errors.Add($"Configuration value '{key}' is missing or empty.");
        }
    }
}

Program.cs code

The following code is used to invoke LoggingSettingsValidation assertions.

builder.Services
    .AddOptions<LoggingSettings>()
    .Bind(builder.Configuration.GetSection("Logging"))
    .ValidateOnStart();

builder.Services.AddSingleton<IValidateOptions<LoggingSettings>, LoggingSettingsValidation>();

Summary

Some developers may think the code presented is great, while others might consider the validation presented overkill. It depends on how the code is tested and if there are steps to manually check that sections and keys exist. To keep a web application running correctly, test and use the provided code.

Optional

If more than one web application requires appsetting validation, consider moving the code to a class project compiled to a local NuGet package for consistency and maintenance.

Pushing skills to a new level

Karen Payne — Mon, 16 Mar 2026 00:07:42 +0000

Introduction

As a developer, a professional, or just starting out, you must continually learn and hone your craft. There is a great way to accomplish this: first, write down objectives, then create a side project.

The objective here is to create a contact solution using a SQL Server relational database and Microsoft EF Core to interact with it, implemented in a class project.

Database creation

Developers should consider using AI tools to build their databases, especially if they have limited experience with relational databases and proper indices.

Using ChatGPT to create the database

Prompt

For the contact database, the following prompt was used.

For Microsoft SQL Server, create a new relational database script for the following to create a contact database.

Database name: Contacts

Person table, gender reference table (Male, Female, Other), United States reference table, Address type reference table, Address table, Device table (Home phone, Work phone, Home email, Work email)

What other tables do I need?

The last sentence allows ChatGPT (or whatever tool is used) to make recommendations. In this case, several junction tables were included.

Note
A junction table (also known as an associative, bridge, or linking table) is a standard relational database design practice used to manage many-to-many relationships between two other tables.

Populating database tables

For reference tables, the ChatGPT-generated script included several tables, including a gender table populated with data.

Executing the script created by ChatGPT

Using SSMS (SQL Server Management Studio)

Create the Contacts database
Run the script generated by ChatGPT
Create a backup of the database
Fully populate one contact
Read the contact using the following statement to validate the schema

SELECT P.PersonId,
       P.FirstName,
       P.LastName,
       P.MiddleName,
       P.DateOfBirth,
       P.GenderId,
       G.GenderName,
       P.CreatedAt,
       P.UpdatedAt,
       D.IsActive,
       D.DeviceValue,
       DT.DeviceTypeName,
       DT.DeviceKind,
       DT.DeviceTypeId,
       P.Notes
FROM dbo.DeviceType AS DT
         INNER JOIN dbo.Device AS D
                    ON DT.DeviceTypeId = D.DeviceTypeId
         INNER JOIN dbo.PersonDevice AS PD
                    ON D.DeviceId = PD.DeviceId
         INNER JOIN dbo.Person AS P
                    ON PD.PersonId = P.PersonId
         INNER JOIN dbo.Gender AS G
                    ON P.GenderId = G.GenderId;

Continue with the current schema or make adjustments and re-validate the schema.

Reverse engineering the database

This is best done with a Microsoft Visual Studio extension, EF Power Tools which is easy to use.

Watch a 25-minute demo to get an introduction to the tool

The reverse engineering is done in a class project, which one or more frontend projects can work with, rather than reverse-engineering in a frontend project.

Integration to a frontend

The next step is to select the frontend project type from desktop, mobile, or web.

Rather than start coding or using an AI tool to create the frontend, this should be a time to learn by first creating a plan for the look and feel, identifying which classes are needed for forms or pages, and adding modals as needed.

Planning

Here are two ways to start planning.

Using a document and images
Gherkin syntax Behaviour-Driven Development (BDD)

Before coding

Create a GitHub repository for the solution, which can be private or public, and should house only working code.

Coding

Take your time, follow your plan, and, in many cases, it can change while coding; if so, update it.

Documentation

Don’t think that documentation is not needed, consider that you may not fully understand code written today next week.

Each project needs a README.md to at least describe the project
Document all classes and, methods and inline code
For mobile and web document CSS styles

Summary

Although the database base code and database script have been provided, consider trying this out on your next learning project.

For the frontend project selection, there will be plenty to learn, and resist the urge to use AI tools unless you are stuck.

Keep in mind the reason for all of this is to learn which is the number one reason to steer clear of vibe coding.

Source code

Essential Visual Studio Extensions

Karen Payne — Mon, 09 Mar 2026 00:45:45 +0000

Introduction

Microsoft Visual Studio extensions are add-ons that expand the capabilities of the Visual Studio IDE beyond what comes built in. They allow developers to install additional tools, language support, templates, analyzers, productivity helpers, and integrations with other services. Extensions can modify the editor, add new menus or windows, automate tasks, provide debugging or profiling tools, or support frameworks and technologies not included by default. In practice, they let developers customize Visual Studio to better fit their workflow, whether that means improving code quality, speeding up development, or integrating external tools directly into the environment.

Although Microsoft Visual Studio provides everything a developer needs for daily work, installing the right extensions can make working in Visual Studio easier and more productive.

The extensions listed here are not in any order.

📌 .github + MCP

❇️ Great extension

.github + MCP Adds GitHub, optional Claude and Agents, and MCP Servers nodes to Solution Explorer. Quickly access and manage AI customization files and GitHub-specific files, plus Model Context Protocol (MCP) server configurations - all without leaving Visual Studio.

Features

AI Nodes in Solution Explorer

The extension adds dedicated AI nodes directly under your solution:

GitHub - always shown, backed by the .github folder
Claude - shown when a .claude folder exists
Agents - shown when a .agents folder exists

Copilot Customization

Add Copilot Instructions - Create an instructions file (.instructions.md) in the instructions folder
Add Agent - Create a custom Copilot agent (.agent.md) in the agents folder
Add Prompt - Create a reusable prompt file (.prompt.md) in the prompts folder
Add Skill - Create an agent skill folder with skill.md in the skills folder

GitHub Configuration

These commands are available only when you right-click in the GitHub (.github) node tree:

Add Workflow - Create a new GitHub Actions workflow (.yml) in the workflows folder
Add Dependabot Config - Create a dependabot.yml for automated dependency updates
Add Issue Template - Create an issue template in the ISSUE_TEMPLATE folder
Add Pull Request Template - Create a PULL_REQUEST_TEMPLATE.md file
Add CODEOWNERS - Create a CODEOWNERS file for automatic reviewer assignment
Add FUNDING.yml - Create a FUNDING.yml file for sponsor button configuration
Add SECURITY.md - Create a SECURITY.md file for security policy documentation

Folder-Specific Commands

When you right-click on a specific folder (e.g., agents, prompts, skills, instructions, or workflows), the relevant "Add" command appears directly in the context menu for quick access.

File and Folder Management

Copy Path - Copy the full path to the clipboard
Rename - Rename files or folders directly from the context menu
Delete - Delete files or folders with confirmation

Utilities

Open in File Explorer - Open the folder in Windows File Explorer
Open Containing Folder - Open the parent folder and select the file in File Explorer
Open on GitHub - Open the file or folder directly on GitHub.com in your browser

Git Status Icons

Files and folders display Git status icons, similar to Solution Explorer:

Unchanged - Files committed to the repository with no changes
Modified - Files with local changes
Staged - Files staged for commit
Added/Untracked - New files not yet tracked by Git
Deleted - Files marked for deletion
Conflict - Files with merge conflicts
Renamed - Files that have been renamed

MCP Servers Node in Solution Explorer

The extension adds an MCP Servers node that provides centralized access to all Model Context Protocol (MCP) server configurations in your solution. The MCP Servers node appears directly below the GitHub node, making it easy to manage both GitHub-specific files and MCP server configurations from one place.

Community Templates with Provider Selection

When creating Copilot agents, instructions, prompts, or skills, the dialog supports multiple template providers.

Currently included providers:

GitHub Awesome Copilot - Community templates from awesome-copilot for agents, prompts, instructions, and skills
dotnet/skills plugins - Templates from dotnet/skills/plugins for agents and skills
anthropics/skills - Templates from anthropics/skills for skills

Works with

Visual Studio 2026 (Arm64), 2026 (amd64), 2022 (Arm64), 2022 (amd64)

📌 File Explorer

File Explorer gives access to all files and folders from the file system under the solution root folder. All in the same Solution Explorer view.

Works with

Visual Studio 2026 (Arm64), 2026 (amd64), 2022 (Arm64), 2022 (amd64)

📌 Markdown Editor v2

❇️ Recommended

Documenting project purpose, important instructions, and code should be done at the solution, project, and folder levels, where appropriate, separately from written business requirements done outside of a Microsoft solution.

The markdown editor provides everything a developer or documenter needs to write documentation using GitHub Markdown syntax.

Works with

Visual Studio 2026 (Arm64), 2026 (amd64), 2022 (Arm64), 2022 (amd64)

Features (not all are listed)

Supports CommonMark, GitHub-flavored Markdown, FrontMatter YAML, Mermaid, and math notation.
Floating toolbar: When you select text in the markdown editor, a floating toolbar appears near the selection with quick access to common formatting commands
Live preview window with scroll sync and dark theme support.
Drag and drop images directly from Solution Explorer or File Explorer.
Generating table of contents
Fenced code blocks
Supports all Mermaid diagram types for visualizing complex information.
Tables
Emoji IntelliSense
Anchor IntelliSense
Heading-based navigation

📌 EF Core Power Tools

❇️ Must have for working with EF Core

This extension is perfect for developers at all levels working with Entity Framework Core and an existing database to generate POCO classes (Plain Old CLR/C# Object) and configure database properties, along with views, stored procedures, and functions supported by the selected database.

Watch a 25-minute demo to get an introduction to the tool.

Works with

Visual Studio 2026 (Arm64), 2026 (amd64), 2022 (Arm64), 2022 (amd64)

Requirements

Visual Studio 2022/2026 (amd64) and the .NET 6 x64 (for EF Core 6 unsupported) or .NET 8 x64 (for EF Core 8 and 9) runtime.

If you do not use Visual Studio, a cross-platform command line tool for reverse engineering is available, more information here

Features

To get started in most cases all that is needed is the server name and database name to reverse engineer a database
Provides and option to install EF Core NuGet packages
Working with PostgreSQL, SQLite, Oracle, MySql or FireBird refer to the following documentation.
DbContext Model Diagram - Adds a DGML graph from your DbContext Model
Option to store the connection string in code, which is good for testing the generated code. Once an initial test is done, it's recommended to move the connection string to appsettings.json.
With EF Power Tools, each database table is configured as shown below: indices, related tables, constraints, and various property configurations.

modelBuilder.Entity<Employees>(entity =>
{
    entity.HasKey(e => e.EmployeeID);

    entity.HasIndex(e => e.ContactTypeIdentifier, "IX_Employees_ContactTypeIdentifier");

    entity.HasIndex(e => e.CountryIdentifier, "IX_Employees_CountryIdentifier");

    entity.HasIndex(e => e.ReportsToNavigationEmployeeID, "IX_Employees_ReportsToNavigationEmployeeID");

    entity.Property(e => e.Address).HasMaxLength(60);
    entity.Property(e => e.BirthDate).HasColumnType("datetime");
    entity.Property(e => e.City).HasMaxLength(15);
    entity.Property(e => e.Extension).HasMaxLength(4);
    entity.Property(e => e.FirstName)
        .IsRequired()
        .HasMaxLength(10);
    entity.Property(e => e.HireDate).HasColumnType("datetime");
    entity.Property(e => e.HomePhone).HasMaxLength(24);
    entity.Property(e => e.LastName)
        .IsRequired()
        .HasMaxLength(20);
    entity.Property(e => e.PostalCode).HasMaxLength(10);
    entity.Property(e => e.Region).HasMaxLength(15);
    entity.Property(e => e.TitleOfCourtesy).HasMaxLength(25);

    entity.HasOne(d => d.ContactTypeIdentifierNavigation).WithMany(p => p.Employees)
        .HasForeignKey(d => d.ContactTypeIdentifier)
        .HasConstraintName("FK_Employees_ContactType");

    entity.HasOne(d => d.CountryIdentifierNavigation).WithMany(p => p.Employees)
        .HasForeignKey(d => d.CountryIdentifier)
        .HasConstraintName("FK_Employees_Countries");

    entity.HasOne(d => d.ReportsToNavigationEmployee).WithMany(p => p.InverseReportsToNavigationEmployee).HasForeignKey(d => d.ReportsToNavigationEmployeeID);

    entity.HasMany(d => d.Territory).WithMany(p => p.Employee)
        .UsingEntity<Dictionary<string, object>>(
            "EmployeeTerritories",
            r => r.HasOne<Territories>().WithMany()
                .HasForeignKey("TerritoryID")
                .OnDelete(DeleteBehavior.ClientSetNull)
                .HasConstraintName("FK_EmployeeTerritories_Territories"),
            l => l.HasOne<Employees>().WithMany()
                .HasForeignKey("EmployeeID")
                .OnDelete(DeleteBehavior.ClientSetNull)
                .HasConstraintName("FK_EmployeeTerritories_Employees"),
            j =>
            {
                j.HasKey("EmployeeID", "TerritoryID").IsClustered(false);
                j.HasIndex(new[] { "TerritoryID" }, "IX_EmployeeTerritories_TerritoryID");
                j.IndexerProperty<string>("TerritoryID").HasMaxLength(20);
            });
});

Reverse engineer options

📌 Solution Favorites

❇️ Great extension

Solution Favorites pins your most important files to the top of Solution Explorer, whether they're in your solution or anywhere else on disk. Stop digging through folders

This extension adds a Favorites node to Solution Explorer where you can organize quick links to the files you use most, including files outside your solution. Built in response to a highly requested feature from the Visual Studio community.

Feature	Description
Pin Files	Double-click to instantly open your most-used files
Pin Folders	Add entire folders with their contents to Favorites
Add External Files	Browse and add files from anywhere on disk
Virtual Folders	Organize favorites into custom folder hierarchies
Drag & Drop	Drag files from Solution Explorer onto Favorites, or rearrange within
Team Sharing	`favorites.json` lives in your solution folder—commit it to share with your team
Toggle Visibility	Hide/show Favorites from the Solution Explorer toolbar
Missing File Detection	Visual indicators when files have been moved or deleted

Team or Personal

Favorites are stored in favorites.json in your solution directory.

Share with team: Commit the file to source control
Keep personal: Add favorites.json to .gitignore

Works with

Visual Studio 2026 (Arm64), 2026 (amd64), 2022 (Arm64), 2022 (amd64)

📌 ReSharper

JetBrains ReSharper is a powerful productivity extension for Microsoft Visual Studio designed to help developers write cleaner, more maintainable code with greater efficiency. It integrates directly into the IDE and enhances the development experience by providing advanced code analysis, refactoring tools, navigation features, and automated code generation. ReSharper continuously analyzes code as you type, highlighting issues and suggesting improvements that follow best practices and established coding standards. For developers working in C#, .NET, and related technologies, it can dramatically reduce repetitive work and make large codebases easier to manage.

Key features include:

Advanced Code Analysis – Detects errors, code smells, and potential bugs in real time.
Powerful Refactoring Tools – Safely rename, extract methods, change signatures, and restructure code.
Intelligent Code Navigation – Quickly jump to files, types, symbols, or usages across large solutions.
Automated Code Generation – Generate constructors, properties, equality members, and more.
Code Cleanup and Formatting – Enforce consistent coding styles automatically.
Unit Testing Support – Built-in integration with common .NET testing frameworks.
Context-Aware Suggestions – Offers quick fixes and improvements directly within the editor.

Subscription Options and Pricing

Works with

Visual Studio 2026, 2022, 2019, 2017, 2015, 2013

📌 CSV Editor

CSV Editor transforms flat, hard-to-read data files into colorful, navigable documents. Supports both CSV and TSV files

✨ Key Features at a Glance

Syntax Highlighting — Color-coded columns for instant visual parsing
Column Alignment — Align columns visually with a single command for table-like readability
Shrink Columns — Remove leading/trailing whitespace from all cells
Alternate Row Colors — Toggle alternating row backgrounds for improved readability
Copy as Markdown — Copy selection as a formatted Markdown table
Smart Header Detection — Automatically identifies header rows
QuickInfo Tooltips — Hover over any cell to see column name, index, and detected data type
Column Sorting — Sort ascending or descending directly from the tooltip
Error Detection — Rows with inconsistent column counts are highlighted
Go To Column — Jump to any column by number
Large File Support — Optimized for files with 100K+ lines

Works with

Visual Studio 2026 (Arm64), 2026 (amd64), 2022 (Arm64), 2022 (amd64)

📌 VSColorOutput64

VSColorOutput can change the color of a line emitted to the output window based on specified rules. The rules consist of regular expressions. Rules map to classifications, which in turn map to colors.

Works with

Visual Studio 2026 (Arm64), 2026 (amd64), 2022 (Arm64), 2022 (amd64)

📌 Bookmark Studio for Visual Studio

Manage color-coded code bookmarks across your solution with slots, search, and fast navigation.

Bookmark Studio

What You Get

Instant navigation - Press Alt+Shift+1 through Alt+Shift+9 to jump directly to your most important bookmarks. No searching, no scrolling.
Visual organization - Color-code bookmarks by purpose (red for bugs, green for features, blue for TODOs) and group them into folders. See exactly what each bookmark represents at a glance.
Team sharing - Commit your bookmarks file to source control so the whole team can navigate to key code locations - perfect for onboarding or code reviews.

Works with

Visual Studio 2026 (Arm64), 2026 (amd64), 2022 (Arm64), 2022 (amd64)

Side project idea II

Karen Payne — Sun, 01 Mar 2026 20:44:31 +0000

Introduction

A great way for a developer to expand their knowledge is by creating side projects, which can turn into useful applications or code that can be used in another project.

When setting out on a side/learning project, consider writing down the objectives of what you intend to learn, rather than, for example, coding a game. Always document the code for future reference.

Make sure to check out Side project idea I which is the same other that a different approach was taken and more added.

Another reason for side projects is to showcase what you are capable of during interviews when applying for a new job.

Source code

Project objectives

Given a path to a Microsoft Visual Studio solution, read the target framework from each project group by framework version. Also presented is code that identifies projects that target multiple frameworks in a console project.

Main method

For some developers, the main method might seem a mess, but once time is spent with the code, the code will make sense, as this is how a learning project may appear, while the meat of the code is well thought out and fully documented.

Example json

{
    "Framework": "net8.0",
    "Projects": [
      {
        "ProjectName": "BogusDateOnlyTimeOnlyApp",
        "ProjectPath": "C:\\DotnetLand\\VS2022\\HowToSeriesSolution\\BogusDateOnlyTimeOnlyApp\\BogusDateOnlyTimeOnlyApp.csproj"
      },
      {
        "ProjectName": "BogusLibrary1",
        "ProjectPath": "C:\\DotnetLand\\VS2022\\HowToSeriesSolution\\BogusLibrary1\\BogusLibrary1.csproj"
      }
    ]
  }

Learning points

Using models (classes) rather than anonymous types
- Entire project organization
Traversing directories for .csproj, .vbproj and .fsproj files to retrieve frameworks

public static List<ProjectFrameworkInfo> ReadSolution(string solutionPath)
{
    if (!File.Exists(solutionPath))
        throw new FileNotFoundException("Solution not found.", solutionPath);

    var slnDir = Path.GetDirectoryName(Path.GetFullPath(solutionPath))!;
    var projectPaths = GetProjectPathsFromSln(solutionPath, slnDir);

    var results = new List<ProjectFrameworkInfo>();

    foreach (var projPath in projectPaths)
    {
        var info = ReadProjectFrameworks(projPath);
        results.Add(info);
    }

    return results;
}

private static List<string> GetProjectPathsFromSln(string slnPath, string slnDir)
{
    // Very simple .sln parsing: finds lines like:
    // Project("{GUID}") = "Name", "path\to\proj.csproj", "{GUID}"
    var paths = new List<string>();

    foreach (var line in File.ReadLines(slnPath))
    {
        if (!line.StartsWith("Project(", StringComparison.OrdinalIgnoreCase))
            continue;

        var parts = line.Split(',');
        if (parts.Length < 2)
            continue;

        var rel = parts[1].Trim().Trim('"');

        // only MSBuild-style projects
        if (!rel.EndsWith(".csproj", StringComparison.OrdinalIgnoreCase) &&
            !rel.EndsWith(".vbproj", StringComparison.OrdinalIgnoreCase) &&
            !rel.EndsWith(".fsproj", StringComparison.OrdinalIgnoreCase))
            continue;

        var full = Path.GetFullPath(Path.Combine(slnDir, rel));
        if (File.Exists(full))
            paths.Add(full);
    }

    return paths.Distinct(StringComparer.OrdinalIgnoreCase).ToList();
}

private static ProjectFrameworkInfo ReadProjectFrameworks(string projectPath)
{
    var doc = XDocument.Load(projectPath, LoadOptions.PreserveWhitespace);

    // SDK-style csproj usually has no XML namespace; handle both anyway.
    var root = doc.Root ?? throw new InvalidOperationException($"Invalid project XML: {projectPath}");
    XNamespace ns = root.Name.Namespace;

    // Prefer explicit TargetFramework(s) anywhere in PropertyGroup
    var tf = root.Descendants(ns + "TargetFramework").Select(e => (string?)e).FirstOrDefault(v => !string.IsNullOrWhiteSpace(v))?.Trim();
    var tfsRaw = root.Descendants(ns + "TargetFrameworks").Select(e => (string?)e).FirstOrDefault(v => !string.IsNullOrWhiteSpace(v))?.Trim();

    var tfs = SplitFrameworks(tfsRaw);

    return new ProjectFrameworkInfo
    {
        ProjectName = Path.GetFileNameWithoutExtension(projectPath),
        ProjectPath = projectPath,
        TargetFramework = tf,
        TargetFrameworks = tfs
    };
}

New to some developers

Grouping data
Use of SelectMany projects each element of a sequence to an IEnumerable<T> and flattens the resulting sequences into one sequence.

List<GroupedItems> groupedByFramework =
    projects
        .SelectMany(p => p.AllFrameworks.Select(f => new GroupedProject(f, p)))
        .GroupBy(x => x.Framework)
        .OrderBy(g => g.Key)
        .Select(g => new GroupedItems(g.Key, g
            .OrderBy(x => x.Project.ProjectName)
            .Select(x => new GroupedItem(x.Project.ProjectName, x.Project.ProjectPath))
            .ToList()))
        .ToList();

ToDictionary

Dictionary<string, List<string>> groupedDictionary =
    projects
        .SelectMany(p => p.AllFrameworks.Select(f => new GroupedProject(f, p)))
        .GroupBy(x => x.Framework)
        .ToDictionary(
            g => g.Key,
            g => g
                .OrderBy(x => x.Project.ProjectName)
                .Select(x => x.Project.ProjectName)
                .ToList()
        );

Use of AI tools

When using AI, make sure to fully understand its responses, as the purpose of learning projects is to learn, not vibe-code.

Summary

Both side project one and two are for learning, while the next in the series will focus on a project which provides an idea on designing a database using AI and how to code against the database using EF Core, while the frontend will be left to the reader, as this provides the reader a choice of frontend project from desktop, mobile, or web-based.

Side project idea I

Karen Payne — Sat, 21 Feb 2026 23:34:19 +0000

Introduction

A great way for a developer to expand their knowledge is by creating side projects, which can turn out to be useful applications or code that can be used in another project.

The incentive for this project came from a Stackoverflow question.

Is there a way to check for a C# .NET application to check if the used .NET version is still supported?

Working on a solution

💡 If a developer decides to use AI to assist with the solution, try to keep its use to a minimum to support learning.

In the Stackoverflow question, there is a URL in the comments that returns JSON for each .NET Core version.

Each property has a lower-case property name, along with commas in most of the properties. In the class representing information JsonPropertyNameAttribute provides a way to map a property to be used to store information.

[JsonPropertyName("support-phase")]
public string? SupportPhase { get; set; }

Complete class for storing data found here.

Next, a method is needed to read data back, which may need some research, or a developer might use AI to write the method.

public static class DotNetReleaseService
{
    private static readonly HttpClient _httpClient = new();

    public static async Task<List<ReleaseIndexItem>> GetReleaseIndexAsync(CancellationToken cancellationToken = default)
    {
        const string url = "https://dotnetcli.azureedge.net/dotnet/release-metadata/releases-index.json";

        using HttpResponseMessage response = await _httpClient.GetAsync(url, cancellationToken);
        response.EnsureSuccessStatusCode();

        await using var stream = await response.Content.ReadAsStreamAsync(cancellationToken);


        var root = await JsonSerializer.DeserializeAsync<ReleasesIndexRoot>(
            stream,
            Options,
            cancellationToken);

        return root?.ReleasesIndex ?? [];
    }

    public static JsonSerializerOptions Options => new() { PropertyNameCaseInsensitive = true };
}

Possible enhancements: wrap code that may fail in a try/catch and a CancellationToken.

The code above shows how to return details of frameworks, and the code below shows how to determine whether the current project framework is not considered end of life.

public static class FrameworkUtilities
{

    public static Version? GetTargetFrameworkVersion(this Assembly assembly)
    {

        var framework = assembly.GetCustomAttribute<TargetFrameworkAttribute>()?.FrameworkName;

        if (string.IsNullOrWhiteSpace(framework))
            return null;

        // Common format: ".NETCoreApp,Version=v9.0"
        const string marker = "Version=v";
        var id = framework.IndexOf(marker, StringComparison.OrdinalIgnoreCase);
        if (id >= 0)
        {
            var versionText = framework[(id + marker.Length)..].Trim();
            var comma = versionText.IndexOf(',');
            if (comma >= 0) versionText = versionText[..comma];

            return Version.TryParse(versionText, out var v) ? v : null;
        }

        // Alternate format some devs may see: ".NET 9.0"
        var lastSpace = framework.LastIndexOf(' ');
        if (lastSpace < 0 || lastSpace + 1 >= framework.Length) return Version.TryParse(framework, out var direct) ? direct : null;
        {
            var versionText = framework[(lastSpace + 1)..].Trim();
            return Version.TryParse(versionText, out var v) ? v : null;
        }

    }


    public static string IsProjectFramework(string sender)
    {
        if (string.IsNullOrWhiteSpace(sender))
        {
            return sender;
        }

        var frameworkVersion = FrameworkVersion();
        var currentFramework = frameworkVersion?.ToString();

        return string.Equals(sender, currentFramework, StringComparison.OrdinalIgnoreCase)
            ? $"{sender} :check_mark:"
            : $"{sender}";
    }


    public static async Task<(bool found, bool isActive)> ProjectFrameworkActive()
    {
        var frameworkVersion = FrameworkVersion();
        var currentFramework = frameworkVersion?.ToString();

        var current = (await DotNetReleaseService.GetReleaseIndexAsync()).FirstOrDefault(x => x.ChannelVersion == currentFramework);
        if (current is not null)
        {
           return (true, current.SupportPhase.Contains("active", StringComparison.OrdinalIgnoreCase));
        }
        else
        {
            return (false, false);
        }
    }

    private static Version? FrameworkVersion()
    {
        Assembly? entryAssembly = Assembly.GetEntryAssembly();
        Version? frameworkVersion = entryAssembly?.GetTargetFrameworkVersion();
        return frameworkVersion;
    }
}

Usage

internal partial class Program
{
    static async Task Main(string[] args)
    {

        var (found, isActive) = await FrameworkUtilities.ProjectFrameworkActive();
        if (found)
        {
            Console.WriteLine($"Project framework is {(isActive ? "active" : "not active")}.");
        }
        else
        {
            Console.WriteLine("Project framework not found.");
        }
    }
}

Source code

Summary

An idea has been presented to expand a developer’s knowledge, along with possible use in an application. The source code provided goes past usage to what has been presented. Rather than simply using the provided code, take time to understand the code and consider the following.

Adding exception handling which includes logging errors to a log file.
Creating a class project so the code can be used in other projects
- Create a NuGet package on NuGet or local source.

EF Core HasQueryFilter II

Karen Payne — Mon, 16 Feb 2026 21:26:05 +0000

Introduction

EF Core has the HasQueryFilter extension method, which is a LINQ query predicate applied to EF Core entity models. This is especially useful in scenarios requiring soft deletion. A developer may need to view data without a filter, which is done using IgnoreQueryFilters extension method.

Source code

Learn how

Filter on properties rather than soft deletes and archiving, see the following for soft deletes.
Control filters using settings from appsettings.json

{
  "ContextOptions": {
    "UseAuditInterceptor": true,
    "CustomersOptions": {
      "UseQueryFilter": true,
      "CountryCode": 20
    },
    "CategoryOptions": {
      "UseQueryFilter": true,
      "Id": 2
    }
  }
}

Example 1

Using a customer table in a database, filter by country code.

We can hard-code a country code in the OnModelCreating method of the dbContext.

modelBuilder.Entity<Customer>()
    .HasQueryFilter(c =>
        EF.Property<int?>(c,
            nameof(Models.Customer.CountryIdentifier)) == 20); // 20 is the CountryIdentifier for USA in Northwind database

Or use a bool and int properties from appsettings.json.

Below HasQueryFilter is wrapped with an if condition to use HasQueryFilter or not.

if (ContextSettings.Instance.CustomerOptions.UseQueryFilter)
{

    modelBuilder.Entity<Customer>()
        .HasQueryFilter(c =>
            EF.Property<int?>(c,
                nameof(Models.Customer.CountryIdentifier)) ==
            ContextSettings.Instance.CustomerOptions.CountryCode);
}



public class CustomerOptions
{
    public bool UseQueryFilter { get; set; }
    public int CountryCode { get; set; }
}



public sealed class ContextSettings
{
    private static readonly Lazy<ContextSettings> Lazy = new Lazy<ContextSettings>(() => new ContextSettings());

    public static ContextSettings Instance => ContextSettings.Lazy.Value;

    public CustomerOptions CustomerOptions { get; set; }

      private ContextSettings()
    {
        // Config is set up in the project file to bind the configuration
        // to the ContextOptions class, so we can directly retrieve it here.
        ContextOptions options = Config.Configuration.JsonRoot()
            .GetSection(nameof(ContextOptions))
            .Get<ContextOptions>()!;

        CustomerOptions = options.CustomersOptions; 
    }
}

Example 2

Uses the same logic as in example 1, this time to use HasQueryFilter for filtering on a category for products.

if (ContextSettings.Instance.CategoryOptions.UseQueryFilter)
{

    modelBuilder.Entity<Category>()
        .HasQueryFilter(c =>
            EF.Property<int?>(c,
                nameof(Models.Category.CategoryId)) ==
            ContextSettings.Instance.CategoryOptions.Id);

}

Another option, perform a contains for multiple category identifiers.

appsettings.json

if (ContextSettings.Instance.CategoryOptions.UseQueryFilter)
{
    var ids = ContextSettings.Instance.CategoryOptions.Identifiers;
    modelBuilder.Entity<Category>()
        .HasQueryFilter(c =>
            ids.Contains(EF.Property<int>(c, nameof(Models.Category.CategoryId))));
}

Sample code uses a conditional to try out both.

#if UseThis
            if (ContextSettings.Instance.CategoryOptions.UseQueryFilter)
            {

                modelBuilder.Entity<Category>()
                    .HasQueryFilter(c =>
                        EF.Property<int?>(c,
                            nameof(Models.Category.CategoryId)) ==
                        ContextSettings.Instance.CategoryOptions.Id);

            }
#else
            if (ContextSettings.Instance.CategoryOptions.UseQueryFilter)
            {
                var ids = ContextSettings.Instance.CategoryOptions.Identifiers;
                modelBuilder.Entity<Category>()
                    .HasQueryFilter(c =>
                        ids.Contains(EF.Property<int>(c, nameof(Models.Category.CategoryId))));
            }
#endif

EF Core 10: Using multiple query filters

Introduces named query filters, which allow you to manage each filter separately, including selectively disabling one but not the other.

modelBuilder.Entity<Blog>()
    .HasQueryFilter("SoftDeletionFilter", b => !b.IsDeleted)
    .HasQueryFilter("TenantFilter", b => b.TenantId == tenantId);

Summary

This article has provided some alternative uses of global filtering in EF Core beyond what most web examples offer, such as soft deletes and the ability to control filter enabling without recompiling the application.

ASP.NET Core warmup EF Core

Karen Payne — Sun, 15 Feb 2026 01:36:25 +0000

Introduction

Learn how to warm up Microsoft EF Core for ASP.NET Core projects when a project has many models with complex configurations.

This is done using a hosted service that warms up Entity Framework Core (EF Core) by preloading the model and executing a lightweight query. This service ensures that EF Core's query compilation and model initialization occur during application startup, reducing latency for the first database operation at runtime.

Recommendations

As presented in the source code, log errors for failures and, when dealing with databases that may take time to connect, set a timeout with the provided CancellationToken.

Configuration

Add the following two classes, which provide access to settings in appsettings.json for when a CancellationToken timeout is needed in the hosted service.

public sealed class AppConfiguration
{
    private static readonly Lazy<AppConfiguration> _instance = new(() => new AppConfiguration());

    public static AppConfiguration Instance => _instance.Value;

    public bool Use { get; }

    public int Timeout { get; }

    private AppConfiguration()
    {
        var configuration = new ConfigurationBuilder()
            .SetBasePath(AppContext.BaseDirectory)
            .AddJsonFile("appsettings.json", optional: false, reloadOnChange: false)
            .Build();

        var settings = configuration
                           .GetSection(UseCancellationTokenTimedSettings.SectionName)
                           .Get<UseCancellationTokenTimedSettings>();

        Use = settings!.Use;
        Timeout = settings.Timeout;
    }
}

public sealed class CancellationTokenSettings
{
    public const string SectionName = "CancellationTokenSettings";

    public bool Use { get; init; }
    public int Timeout { get; init; } // milliseconds
}

appsettings.json

{
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft.AspNetCore": "Warning"
    }
  },
  "AllowedHosts": "*",
  "ConnectionStrings": {
    "DefaultConnection": "Data Source=(localdb)\\MSSQLLocalDB;Initial Catalog=FluentValidation1;Integrated Security=True"
  },
  "UseCancellationTokenTimed": {
    "Use": false,
    "Timeout": 3000 
  }
}

Add this class which is used to warm-up EF Core

Replace Context for GetRequiredService with your DbContext
Replace Person used for AnyAsync with any model in your DbContext
Log.Error is from Serilog, change this if not using Serilog

using Microsoft.EntityFrameworkCore;
using Serilog;


public class EntityCoreWarmupService(IServiceProvider serviceProvider) : IHostedService
{

    public async Task StartAsync(CancellationToken cancellationToken)
    {

        if (AppConfiguration.Instance.Use)
        {
            var cts = new CancellationTokenSource(TimeSpan.FromMilliseconds(AppConfiguration.Instance.Timeout));
            cancellationToken = cts.Token;
        }

        try
        {
            using (var scope = serviceProvider.CreateScope())
            {
                var context = scope.ServiceProvider.GetRequiredService<Context>();
                _ = context.Model;

                // Execute a simple, lightweight query to warm up query compilation
                await context.Person.Take(1).AnyAsync(cancellationToken);
            }

            await Task.CompletedTask;
        }
        catch (Exception exception)
        {
            Log.Error(exception, "EF Core warmup failed");
        }

    }
}

In Program.cs, add the following after adding your dbContext service.

Validate appsettings.json for CancellationToken in the warm-up service
Using dependency injection add the warm-up service

builder.Services
    .AddOptions<UseCancellationTokenTimedSettings>()
    .Bind(builder.Configuration.GetSection(UseCancellationTokenTimedSettings.SectionName))
    .Validate(s => s.Timeout >= 0, "Timeout must be >= 0")
    .ValidateOnStart();

builder.Services.AddHostedService<EntityCoreWarmupService>();

var app = builder.Build();

Source code

Under MSSQLLocalDB create the following database FluentValidation1 best done with SSMS.
Finish by creating table and populating tables with populate.sql under DatabaseScripts folder in the sample project.

Web Source code Console Source code

🛑 Important

The sample code uses a single table to keep it simple to follow along with the instructions, while the presented service is meant for use with multiple tables.

Summary

The presented hosted service will warm up database code at the start of an ASP.NET Core web application, rather than when a user needs to interact with data. Take time regarding testing for timeouts and ensure errors are logged.

DEV Community: Karen Payne

dotnet Framework life cycle tool

Introduction

Main code

Entry point code

Project file

Summary

EF Core Named query filters

Introduction

Topics covered

Source code

Table schema for code samples

Soft delete DbContext setup

Filter setup

Performing a soft delete

Ignore a filter

Get query filter language extensions

Summary

ASP .NET Core Bootstrap toast

Introduction

Get coding

Summary

See also

Never stop learning

Introduction

Visual Studio solution for learning

Starter learning ideas

Summary

Display project Attributes (C#)

Introduction

Step 1

Step 2

Step 3

.NET 9 Core source

ASP.NET Core startup validation part 4

Introduction

appsettings.json

Required classes

_Layout.cshtml

Validation class

Program.cs code

See also

Summary

Optional

Pushing skills to a new level

Introduction

Database creation

Using ChatGPT to create the database

Populating database tables

Executing the script created by ChatGPT

Reverse engineering the database

Integration to a frontend

Planning

Before coding

Coding

Documentation

Summary

Essential Visual Studio Extensions

Introduction

📌 .github + MCP

Features

Works with

📌 File Explorer

Works with

📌 Markdown Editor v2

Works with

Features (not all are listed)

📌 EF Core Power Tools

Works with

Requirements

Features

📌 Solution Favorites

Works with

📌 ReSharper

Works with

📌 CSV Editor

Works with

📌 VSColorOutput64

Works with

📌 Bookmark Studio for Visual Studio