DEV Community: Karen Payne

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.

C# 14 extension blocks

Karen Payne — Sun, 01 Feb 2026 00:20:03 +0000

Introduction

Learn about C# 14 extension blocks while targeting NET Core 9. This can be done by adding the following to the project file.

What are convention extension methods?

C# extension methods let you add new methods to existing types without modifying their source code or creating subclasses. They’re defined as static methods in a static class, with the first parameter prefixed by this to indicate the type being extended. Once in scope, they look and feel like native instance methods, which makes code more readable and expressive.

extension blocks benefits

Unlike the old syntax, extension blocks allow you to define extension properties, operators, and static members for a type.

Old syntax

public static class StringExtensions
{
    public static string CapitalizeFirstLetter(this string sender)
        => string.IsNullOrEmpty(sender) ? sender : $"{char.ToUpper(sender[0])}{sender[1..].ToLower()}";
}

New syntax

public static class StringExtensions
{
    extension(string sender)
    {
        public string CapitalizeFirstLetter()
            => string.IsNullOrEmpty(sender) ? sender : $"{char.ToUpper(sender[0])}{sender[1..].ToLower()}";

    }
}

Usage

string firstName = "KAREN";
string lastName = "SMITH";

var fullName = $"{firstName.CapitalizeFirstLetter()} {lastName.CapitalizeFirstLetter()}";

The "receiver" (the instance you are extending) is once for the entire block, making the code cleaner and more organized.

public static class BoolExtensions
{
    extension(bool value)
    {
        public string IsEmpty() =>
            value switch
            {
                true => "Yes is empty",
                _ => "No is not empty"
            };

        public string ToYesNo() =>
            value switch
            {
                true => "Yes",
                _ => "No"
            };
    }
}

Inside the block, members are declared like regular instance members. You don't need to repeat the this parameter for every method.

Not supported prior to C# 14

Static operators can be used with C# 14, but not in preview.

public static class EnumerableExtensions
{
    // The generic T is defined at the block level
    extension<T>(IEnumerable<T> first)
    {
        // Extension Operator
        // Note: At least one parameter must match the extended type (IEnumerable<T>)
        public static IEnumerable<T> operator +(IEnumerable<T> left, IEnumerable<T> right)
            => left.Concat(right);

        // Extension Compound Assignment (C# 14 feature)
        // This allows 'collection += item' behavior
        public static IEnumerable<T> operator +(IEnumerable<T> left, T item)
            => left.Append(item);
    }
}

Sample usage

var list1 = new[] { 1, 2 };
var list2 = new[] { 3, 4 };
var combined = list1 + list2; // Yields { 1, 2, 3, 4 }

Rules for Extension Operators

Static Context: Like standard operators, extension operators must be declared public static.
Identity Rule: One of the operator's parameters must be identity-convertible to the type being extended (e.g., if you extend T[], one parameter must be T[]).
Compound Assignments: C# 14 also introduces user-defined compound assignment operators (like +=), which can now be implemented as extensions.

Constrained Generic Operators

You can combine extension operators with Generic Math constraints (e.g., INumber) to perform arithmetic on collections of numbers.

public static class NumericExtensions
{
    extension<T>(IEnumerable<T> source) where T : INumber<T>
    {
        public IEnumerable<T> OnlyPositive => source.Where(x => x > T.Zero);
    }
}

Article source code

Source code

Summary

Using extension blocks means a developer has cleaner code, both for readability and maintenance, than before C#14. When using extension blocks in a team of developers, make sure to explain them to team members, especially developers who tend not to work with conventional extension methods.

C# Console menus with Actions

Karen Payne — Sun, 25 Jan 2026 23:14:17 +0000

Introduction

The focus of this article is to provide an easy-to-use menu system for C# console projects.

NuGet package Spectre.Console is required to construct the menu using Actions to execute items in the menu.

Benefits of using a menu

A developer can easily test different operations, whether to learn something new, quickly try out code slated for a project, or provide options for a dotnet tool.

Also, many online classes are organized into chapters/sections. Consider breaking them up into menu items.

Base parts

A class which is responsible for displaying menu items and what code to execute using an Action with or without parameters.

public class MenuItem
{

    public int Id { get; set; }
    public required string Text { get; set; }
    public required Action Action { get; set; }
    public override string ToString() => Text;
}

A class that builds the menu using the class above, and another class that has methods to execute when a menu item is selected.

In the sample projects provided

The MenuOperations class is responsible for building the menu
The Operations class contains methods to execute using an Action from the menu selection
- Each method has code to display the method name along with code to stop execution, which, when pressing ENTER, returns to the menu.

Entry point

A while statement is used to present a menu, with one menu option to exit the application.

Example 1 uses an Action with no parameters

internal partial class Program
{
    static void Main(string[] args)
    {
        while (true)
        {
            Console.Clear();
            var menuItem = AnsiConsole.Prompt(MenuOperations.SelectionPrompt());
            menuItem.Action();
        }
    }
}

Example 2 uses an Action with a parameter whose menuItem.Id property references a primary key in a database table; the operation, in this case, saves an image to disk.

internal partial class Program
{
    static void Main(string[] args)
    {
        while (true)
        {
            Console.Clear();
            var menuItem = AnsiConsole.Prompt(MenuOperations.SelectionPrompt());
            menuItem.Action(menuItem.Id);
        }
    }
}

dotnet tool example to read column descriptions for tables in a database.

Implmentation

Using one of the provided sample projects, create a new console project.

Add NuGet package Spectre.Console to the project
Add folders, Models and Classes
Add MenuItem under the Models folder
Add an empty MenuOperations class under the Classes folder
Add code provided from one of Main methods to display the menu
Export the project as a new project template for a starter project

Tips

When something is unclear, set breakpoints and examine the code in the local window
Consider writing code in class projects that are executed from the Operations class, as in this class project, Customer record used here.

Source code

Source code 1 Source code 2 Source code 3

How to: NuGet local feeds

Karen Payne — Sat, 10 Jan 2026 21:49:04 +0000

Introduction

NuGet packages are the standard way .NET developers share, version, and consume reusable code, whether it’s core libraries, third-party tools, or internal company components. A NuGet package is essentially a zipped bundle that contains compiled assemblies, metadata, and dependency information, which allows Visual Studio and the .NET CLI to automatically restore the correct versions your project needs. This system has been around for years, and it works because it enforces consistency: you no longer copy DLLs by hand; instead, you declare what you depend on and let NuGet manage updates, conflicts, and builds in a predictable and repeatable way.

In this article, learn how to write code to publish to a local source.

Individual accounts on NuGet.org

You must create an individual account to publish and manage packages on NuGet.org.

Local feed/source

A NuGet local feed is simply a folder on your machine or network that NuGet treats as a package source, allowing you to create, store, and consume NuGet packages without publishing them to a remote repository like nuget.org.

Local feeds are fast, offline-friendly, and ideal for in-house or experimental packages; however, they lack the governance, versioning discipline, and auditability that you get from a proper package server.

When to create local packages

A developer uses the same code over and over again.
The code is proprietary to a developer or an organization.
Easy to maintain and allows multiple versions to be available.

Starter example 1

A developer or team of developers needs to create a type handler for Dapper to understand DateOnly and TimeOnly structs. This would be a good example which in this case could be local or public as shown here.

public class SqlDateOnlyTypeHandler : SqlMapper.TypeHandler<DateOnly>
{
    public override void SetValue(IDbDataParameter parameter, DateOnly date) 
        => parameter.Value = date.ToDateTime(new TimeOnly(0, 0));
    public override DateOnly Parse(object value) => DateOnly.FromDateTime((DateTime)value);
}

public class SqlTimeOnlyTypeHandler : SqlMapper.TypeHandler<TimeOnly>
{
    public override void SetValue(IDbDataParameter parameter, TimeOnly time)
    {
        parameter.Value = time.ToString();
    }

    public override TimeOnly Parse(object value) => TimeOnly.FromTimeSpan((TimeSpan)value);
}

Starter example 2

A developer or a team develops a proprietary API that is solely used internally. These packages need to be protected as a seasoned developer, or a hacker can easily get to the package source code. A package file is just as easy to hack as a .DLL file.

Publishing to Local feed/source tool

The purpose of a tool is to copy a package file to a local feed folder for personal use or for a team of developers.

Source code

Screen shot

Using the tool

Select a package, then select a version of the package. Click the Publish button, which presents a confirmation dialog to continue. If a package exists, it will be overwritten when clicking yes in the confirmation dialog.

Configuration

To configure the tool: open appsettings.json

PackageLocation points to the folder where your local NuGet packages are stored for Microsoft Visual Studio.

Visual Studio options dialog for NuGet package sources

ClassProjects section: In this section, add one or more paths to project folders that contain one or more .nupkg files.

A path points to a project folder not the path to nupkg files.
Paths can be in one or more Visual Solutions.

Example appsettings.json file with five paths; each path in ClassProjects points to a project under different Visual Studio solutions.

{
  "PackageLocation": "C:\\NuGetLocal",
  "ProjectItems": [
    {
      "Path": "C:\\DotnetLand\\VS2022\\ProjectTemplates2025\\SpectreConsoleLibrary"
    },
    {
      "Path": "C:\\DotnetLand\\VS2022\\BogusTrainingSolution\\BogusLibrary"
    },
    {
      "Path": "C:\\DotnetLand\\VS2022\\SerilogSolution\\SeriLogThemesLibrary"
    },
    {
      "Path": "C:\\DotnetLand\\VS2022\\ConsoleHelpersSolution\\ConsoleConfigurationLibrary"
    },
    {
      "Path": "c:\\DotnetLand\\VS2019\\dapper-libraries\\Dapper.Handlers"
    }
  ]
}

Important

💡 The method DirectoryHelper.ProjectItems traverses folders specified from ClassProjects in appsettings.json. Only paths that exist and contain at least one .nupkg will be displayed in the tool.

Summary

Instructions and why a developer or team of developers may want to use local NuGet packages along with a tool to copy packages to a local feed folder in this article to assist with working with local NuGet packages.

ASP .NET Core IDisplayMetadataProvider

Karen Payne — Sun, 21 Dec 2025 22:24:16 +0000

Introduction

Learn how to use a class that implements IDisplayMetadataProvider to transform property names such as FirstName to First Name.

Example for an HTML table

Example for a standard edit page

Using the provided class is not a replacement for using the Display attribute; instead, it is an option to consider.

Example class using the Display attribute

public partial class Person
{
    public int PersonId { get; set; }
    [Display(Name = "First Name")]
    public string FirstName { get; set; }
    [Display(Name = "Last Name")]
    public string LastName { get; set; }
    [Display(Name = "Email Address")]
    public string EmailAddress { get; set; }
}

Example class using the the custom provider

public partial class Person
{
    public int PersonId { get; set; }
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public string EmailAddress { get; set; }
}

Using PascalCaseDisplayMetadataProvider

PascalCaseDisplayMetadataProvider setup.

builder.Services.AddControllersWithViews(options =>
{
    options.ModelMetadataDetailsProviders.Add(
        new PascalCaseDisplayMetadataProvider([typeof(Person)], 
            includeDerivedTypes: false));
});

Parameter 1: A collection of objects representing the target types for which the display metadata should be customized.
Parameter 2: A boolean value indicating whether derived types of the specified in parameter 1.

Alternate setup which dynamically gets all classes under a specific folder.

In this case all classes are in a folder named Models. Add the following method to Program.cs

static string[] GetClassNamesFromAssembly(Assembly assembly, string? @namespace = null) =>
    assembly
        .GetTypes()
        .Where(t => t is { IsClass: true, IsAbstract: false })
        .Where(t => @namespace == null || t.Namespace == @namespace)
        .Select(t => t.Name)
        .Distinct()
        .OrderBy(n => n)
        .ToArray();

Setup in Main method

string ns = typeof(Program).Namespace!;

string[] classNames = GetClassNamesFromAssembly(typeof(Program).Assembly, $"{ns}.Models");

// Configures a custom display metadata provider to format PascalCase property names into a more readable format.
builder.Services.AddControllersWithViews(options =>
{
    options.ModelMetadataDetailsProviders.Add(
        new PascalCaseDisplayMetadataProvider(
            [.. classNames
                .Select(name => Type.GetType($"{ns}.Models.{name}"))
                .Where(type => type is not null)
                .Cast<Type>()],
            includeDerivedTypes: false));
});

💡 A developer, rather than copy PascalCaseDisplayMetadataProvider to their project, use the provided class project AspCoreHelperLibrary and create a project reference.

⌨️ Source code

The sample project provided was selected at random, which, in addition to demonstrating code that showcases PascalCaseDisplayMetadataProvider, also illustrates how to utilize FluentValidation and specify required properties via CSS.

Source code

More to follow

Will be creating more articles on this topic soon.

Checkbox Aria TagHelper

Karen Payne — Sun, 07 Dec 2025 21:22:14 +0000

Introduction

Learn how to initialize all check inputs that reside in an ASP.NET Core page using a custom TagHelper.

The TagHelper evaluates the checked attribute value on page load and adds and sets the aria-checked attribute. This is important for screen readers to assist people with limited or no vision.

Source code

How to use

In an ASP.NET Core project, create a folder in Solution Explorer named TagHelpers, and add the following class.

using Microsoft.AspNetCore.Razor.TagHelpers;

[HtmlTargetElement("input", Attributes = "asp-for")]
public class CheckboxAriaTagHelper : TagHelper
{
    public override void Process(TagHelperContext context, TagHelperOutput output)
    {
        if (!output.Attributes.TryGetAttribute("type", out var type) || type.Value.ToString() != "checkbox") return;

        var isChecked = output.Attributes.TryGetAttribute("checked", out var chk);
        output.Attributes.SetAttribute("aria-checked", isChecked);
    }
}

Next, add the following to Pages\_ViewImports.cshtml. Replace CheckedListBox with the current project namespace.

@addTagHelper *, CheckedListBox

Handling check change

Set up check inputs; the following is included in the source code.

@for (var index = 0; index < Model.CheckModels.Count; index++)
{
    <div class="row">
        <div class="col-6 ms-3">

            <!-- Hidden Id -->
            <input asp-for="CheckModels[index].Id" type="hidden" />

            <div class="form-check">

                <!-- 
                This is where the CheckboxAriaTagHelper runs
                -->
                <input asp-for="CheckModels[index].Checked"
                       type="checkbox"
                       class="form-check-input js-aria-checkbox" />

                <!-- Hidden Name to bind back on post -->
                <input asp-for="CheckModels[index].Name" type="hidden" />

                <label asp-for="CheckModels[index].Checked" class="form-check-label">
                    @Model.CheckModels[index].Name
                </label>
            </div>

        </div>
    </div>
}

Next, add a JavaScript event for the change event on the page.

@section Scripts {
    <script>
        document.addEventListener("DOMContentLoaded", () => {

            document.querySelectorAll("input.js-aria-checkbox[type='checkbox']").forEach(function (cb) {
                    // Update aria-checked whenever the checkbox changes
                    cb.addEventListener("change", function () {
                        this.setAttribute("aria-checked", this.checked ? "true" : "false");
                    });
                });

        });
    </script>
}

Test

Testing can be done by displaying the page, opening Developer Tools, selecting a check input, and toggling the check state, which will be displayed in Developer Tools.

Summary

The TagHelper makes it easy to set up aria-check attribute which provides a better user experience for those visiting a site where the visitor has vision disabilities.

DEV Community: Karen Payne

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

Works with

Side project idea II

Introduction

Project objectives

Main method

Learning points

New to some developers

Use of AI tools

Summary

Side project idea I

Introduction

Working on a solution

Summary

EF Core HasQueryFilter II

Introduction

Learn how

Example 1

Example 2

EF Core 10: Using multiple query filters

Summary

ASP.NET Core warmup EF Core

Introduction

Recommendations

Configuration

Source code

Summary

C# 14 extension blocks

Introduction

Not supported prior to C# 14

Rules for Extension Operators

Constrained Generic Operators

Article source code

Summary