DEV Community: Karen Payne

EF Core UseIdentityColumns

Karen Payne — Sat, 04 Jul 2026 16:04:46 +0000

Introduction

UseIdentityColumns is useful to set a custom seed and increment value, such as starting IDs at 1000 instead of 1 or starting at 1 and configuring the increment, for example, starting at 1 and incrementing by 10.

💡 Only for SQL Server

Product	Versions
Entity Framework Core	6.0, 7.0, 8.0, 9.0, 10.0

Used

Microsoft Visual Studio 2026
NET 10 Framework
EF Core 10.0.8

Model for demonstrations

public partial class Customer
{
    public int CustomerId { get; set; }

    public string FirstName { get; set; }

    public string LastName { get; set; }
}

Start primary key at 100, increment by 1

A business rule requires the Customer CustomerId to start at 100 and increment by 1.

Pass 100 into UseIdentityColumns.

Start primary key at 10, increment by 10

A business rule requires the Customer CustomerId to start at 10 and increment by 10.

Sample code

Source code

Has been set up to create the database each time the console project runs to try out different configurations for UseIdentityColumns.

The connection string is in appsettings.json

{
  "ConnectionStrings": {
    "MainConnection": "Data Source=(localdb)\\MSSQLLocalDB;Initial Catalog=EF_IdentityOptions;Integrated Security=True;Encrypt=False"
  }
}

Classes\DataOperations.cs has all EF Core operations.
SpectreConsoleLibrary is included for custom console output

Commitment to improvement

Karen Payne — Sat, 20 Jun 2026 23:34:27 +0000

Introduction

Becoming a professional developer requires a commitment to continuous improvement and to thinking ahead.

This means that developers, regardless of their years of experience, should always evaluate new features of their primary programming language, which in this case is C#. Evaluating new features allows a developer to grow, and means using a new feature just because it's new.

While learning new features, a developer needs to learn how to consolidate code to reduce the need to copy it from project to project or from one class to another.

Intent

The goal is to teach how to reduce code repetition by showing the development environment for an ASP.NET Core project.

Written using

Microsoft Visual Studio 2026, Framework NET10

ASP.NET Core: Show environment

Unless a project is a single page, a novice developer will copy the following across pages. If requirements change, this means a developer must change the code in each page.

Microsoft docs Environment Tag Helper

<environment include="Development">
    <div class="row">
        <div class="col-auto badge bg-success ms-3">
            Development
        </div>
    </div>
</environment>

<environment include="Staging">
    <div class="row">
        <div class="col-auto badge bg-warning  ms-4">
            Staging
        </div>
    </div>
</environment>

<environment include="Production">
    <div class="row">
        <div class="col-auto badge bg-danger  ms-4">
            Production
        </div>
    </div>
</environment>

Better evolution

A better idea is to centralize code in a single location using a partial page/view so that code changes are all in one place.

Same code as above
Same usage:
💡 Hold the control key and clicking on the view traverses to the view code.
Partial views are usually located under the Pages\Shared folder

Best solution

Create a custom TagHelper in a class project so one or more projects can use it, ensuring consistency across projects.

💡 Consider using an AI tool to create the custom TagHelper. The custom TagHelper below was generated with AI.

Prompt: Create an ASP.NET Core TagHelper for a label showing the current environment.

The resulting code turned out to be greater than expected.

Create a new class project named WebClassLibrary in a Microsoft Visual Studio solution and add the following FrameworkReference to the project file.

WebClassLibrary Source code

<Project Sdk="Microsoft.NET.Sdk">

   <PropertyGroup>
      <TargetFramework>net10.0</TargetFramework>
      <ImplicitUsings>enable</ImplicitUsings>
      <Nullable>enable</Nullable>
   </PropertyGroup>

   <ItemGroup>
      <FrameworkReference Include="Microsoft.AspNetCore.App" />
   </ItemGroup>

</Project>

Create the TagHelper to meet the requirements above, along as shown below are class style override.

using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Razor.TagHelpers;

namespace WebClassLibrary.TagHelpers;


[HtmlTargetElement("environment-label")]
public class EnvironmentLabelTagHelper(IWebHostEnvironment environment) : TagHelper
{
    public string? Class { get; set; }

    public override void Process(TagHelperContext context, TagHelperOutput output)
    {
        var environmentName = environment.EnvironmentName;

        output.TagName = "span";
        output.TagMode = TagMode.StartTagAndEndTag;

        var cssClass = string.IsNullOrWhiteSpace(Class)
            ? GetDefaultCssClass(environmentName)
            : Class;

        output.Attributes.SetAttribute("class", cssClass);
        output.Attributes.SetAttribute("title", $"Current environment: {environmentName}");

        output.Content.SetContent(environmentName);

    }


    private static string GetDefaultCssClass(string environmentName)
    {
        return environmentName switch
        {
            "Development" => "badge bg-success",
            "Staging" => "badge bg-warning text-dark",
            "Production" => "badge bg-danger",
            _ => "badge bg-secondary"
        };
    }
}

Build the project to ensure there are no errors.

Next, add a project reference to an ASP.NET Core project to the class project.

Frontend Source code

Open _ViewImports.cshtml and add @addTagHelper line below.

 @addTagHelper WebClassLibrary.TagHelpers.*, WebClassLibrary

Add the following to a page:

<div class="container">
    <div class="row">
        <div class="col-2">
            <environment-label></environment-label>
        </div>
    </div>
</div>

Try with a custom style:

<div class="container">
    <div class="row mt-2">
        <div class="col-2">
            @* 
            provide a custom class which overrides the default style  
            env-label is defined in wwwroot/css/site.css
            *@
            <environment-label class="env-label"></environment-label>
        </div>
    </div>
</div>

Perhaps in the footer in _Layout.cshtml

<footer class="border-top footer text-muted">
    <div class="container">
        &copy; @DateTime.Now.Year - Environment Application <environment-label></environment-label>
    </div>
</footer>

Summary

The ideas presented will result in easier-to-maintain code and a consistent user interface. To go one step further, package class projects as local NuGet packages.

ASP .NET Core/BS-5 badge

Karen Payne — Mon, 15 Jun 2026 00:13:29 +0000

Introduction

Learn how to use the Bootstrap 5 badge component without JavaScript in ASP.NET Core projects.

💡 Secret sauce is to treat a badge no different than any other read-only input.

What is a badge

A Bootstrap 5 badge is a small inline label used to highlight counts, statuses, categories, or short pieces of metadata, such as “New,” “Active,” or “12.” It is created with the .badge class and usually paired with background utility classes like .bg-primary, .bg-success, or .bg-danger to control its color. Badges scale to match the size of their parent text, making them useful inside headings, buttons, lists, and navigation items. In Bootstrap 5, badges can also be rounded into pill shapes using .rounded-pill, which is commonly used for notification counts or status indicators.

Code walkthrough

In this code sample, appsettings.json reads and writes the value displayed in the badge, whereas in a real application, the badge value may be retrieved from a service.

Source code

Frontend

<form method="post">
    <div class="mt-4 mb-2 d-flex gap-3">

        <button type="button" class="btn btn-primary position-relative">
            Inbox
            <span class="position-absolute top-0 start-100 translate-middle badge rounded-pill bg-danger">
                @Model.BadgeDisplay
                <span class="visually-hidden">unread messages</span>
            </span>
        </button>

        <button type="submit" asp-page-handler="Increment" class="btn btn-success">
            Increment Badge
        </button>

        <button type="submit" asp-page-handler="Decrement" class="btn btn-secondary">
            Decrement Badge
        </button>

    </div>
</form>

Two buttons are available to simulate incrementing and decrementing the badge value, which both have post events (see below).

Backend

public class BadgeDemoModel : PageModel
{
    public int BadgeCount { get; set; }

    public string BadgeDisplay => BadgeCount > 99 ? "99+" : BadgeCount.ToString();

    public void OnGet()
    {
        BadgeCount = BadgeOperations.BadgeCount();
    }

    public IActionResult OnPostDecrement()
    {
        int currentBadgeCount = BadgeOperations.BadgeCount();

        currentBadgeCount--;

        if (currentBadgeCount < 0)
            currentBadgeCount = 0;

        BadgeOperations.Save(currentBadgeCount);

        return RedirectToPage();
    }
    public IActionResult OnPostIncrement()
    {
        int currentBadgeCount = BadgeOperations.BadgeCount();

        currentBadgeCount++;

        BadgeOperations.Save(currentBadgeCount);

        return RedirectToPage();

    }
}

OnPostIncrement increments the badge count and OnPostDecrement decrements the badge count and both save the current

Support class

public class BadgeOperations
{

    public static int BadgeCount()
    {
        var appSettingsPath = AppSettingsPath();

        string json = ReadAllText(appSettingsPath);

        JsonNode? root = JsonNode.Parse(json);

        BadgeSettings? badgeSettings = root?[nameof(BadgeSettings)]?.Deserialize<BadgeSettings>();

        return badgeSettings?.BadgeCount ?? 1;

    }


    public static void Save(int badgeCount)
    {
        var appSettingsPath = AppSettingsPath();

        string json = ReadAllText(appSettingsPath);

        JsonNode? root = JsonNode.Parse(json) ?? new JsonObject();

        var badgeSettings = new BadgeSettings
        {
            BadgeCount = badgeCount
        };

        root[nameof(BadgeSettings)] = JsonSerializer.SerializeToNode(badgeSettings);


        WriteAllText(appSettingsPath, root.ToJsonString(Indented));
    }


    private static string AppSettingsPath()
    {
        return Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "appsettings.json"); 
    }

    public static JsonSerializerOptions Indented => new() { WriteIndented = true };
}

Model

public class BadgeSettings
{
    public int BadgeCount { get; set; }
}

Summary

The main takeaway from this article is that JavaScript is not always required for backend code to communicate with frontend code.

C# Pattern matching

Karen Payne — Sat, 13 Jun 2026 21:41:53 +0000

Introduction

Learn about pattern matching with easy-to-follow code samples. The emphasis is on the code samples, as Microsoft documentation is good.

💡 Code was written using NET10, Microsoft Visual Studio 2026

Use the is expression, the switch statement, and the switch expression to match an input expression against any number of characteristics. C# supports multiple patterns, including declaration, type, constant, relational, property, list, var, and discard. You can combine patterns by using the Boolean logic keywords and, or, and not.

Above is Microsoft docs

Important

💡 The patterns presented should only be used once you understand a specific pattern, rather than forcing a pattern just because it's new.

Source code

Positional pattern

Use a positional pattern to deconstruct an expression and match the resulting values against the corresponding nested patterns.

Example

Here, rather than one value being evaluated in a switch, two values (properties on the class Money) are evaluated.


public sealed class Money(decimal amount, string currencyCode)
{
    public decimal Amount { get; } = amount;
    public string CurrencyCode { get; } = currencyCode;

    // Positional patterns use this method.
    public void Deconstruct(out decimal amount, out string currencyCode)
    {
        amount = Amount;
        currencyCode = CurrencyCode;
    }
}

public static void PositionalPatternSample()
{
    var list = MockData.MoneyList();

    foreach (var money in list)
    {
        Console.WriteLine($"{money.Amount,-5}{money.CurrencyCode}: {Identify(money)}");
    }
}

private static string Identify(Money money) => money switch
{
    (0m, "USD") => "No US dollars",
    ( > 0m and < 100m, "USD") => "Small US dollar amount",
    ( >= 100m, "USD") => "Large US dollar amount",
    ( > 0m, "EUR") => "Positive euro amount",
    ( < 0m, _) => "Negative amount",
    (_, _) => "Some other amount"
};

Identify uses the Deconstruct of Money for the switch.

Data used

public static List<Money> MoneyList() =>
[
    new(0m, "USD"),
    new(25m, "USD"),
    new(125m, "USD"),
    new(50m, "EUR"),
    new(-10m, "USD")
];

Results

Property pattern

Use a property pattern to match an expression's properties or fields against nested patterns.

Example

Classes

public class Person : IPerson
{
    public int Id { get; set; }
    public string? FirstName { get; set; }
    public string? LastName { get; set; }
    public DateOnly BirthDate { get; set; }
    public int Age => BirthDate.GetAge();
    public Address? Address { get; set; }
}

public class Employee : IPerson
{
    public int Id { get; set; }
    public string? FirstName { get; set; }
    public string? LastName { get; set; }
    public DateOnly BirthDate { get; set; }
    public required string Badge { get; set; }
    public int Age => BirthDate.GetAge();
}

public class Address
{
    public string State { get; set; } = "";
    public string City { get; set; } = "";
}

Data

public static List<IPerson> PeopleList() =>
[
    new Person { Id = 1, FirstName = "Alice", LastName = "Smith",
        BirthDate = new DateOnly(1990, 5, 15) ,
        Address = new Address { State = "OR", City = "Salem" }},

    new Person { Id = 2, FirstName = "Bob", LastName = "Johnson", 
        BirthDate = new DateOnly(1985, 11, 23) },
    new Employee() { Id = 3, FirstName = "Bob", LastName = "Johnson", 
        BirthDate = new DateOnly(1985, 11, 23), Badge = "AA1234"},
    new Person { Id = 4, FirstName = "Charlie", LastName = "Williams", 
        BirthDate = new DateOnly(2001, 1, 1)
    }
];

public static void PropertyPatternSample()
{

    SpectreConsoleHelpers.PrintPink();

    if (MockData.PeopleList().FirstOrDefault() is not Person person) return;

    if (person is { Age: >= 18, Address.State: "OR" })
    {
        Console.WriteLine($"{person.FirstName} is an adult living in Oregon.");
    }

    string category = person switch
    {
        { Age: < 13 } => "Child",
        { Age: >= 13 and < 18 } => "Teenager",
        { Age: >= 18, Address.State: "OR" } => "Adult in Oregon",
        { Age: >= 18 } => "Adult",
        _ => "Unknown"
    };

    Console.WriteLine($"{category} - Age {person.Age}");

}

Get the first item as a Person
The if statement asserts the person's age is greater than 18 and the address/state is Oregon.
The switch first two and last branch evalute age only while the third branch item asserts age and state property of address of the Person.

Results

Declaration and type patterns

Use declaration and type patterns to check if the run-time type of an expression is compatible with a given type. By using a declaration pattern, you can also declare a new local variable. When a declaration pattern matches an expression, it assigns the variable to the converted expression result.

Example

Classes

public class Person : IPerson
{
    public int Id { get; set; }
    public string? FirstName { get; set; }
    public string? LastName { get; set; }
    public DateOnly BirthDate { get; set; }
    public int Age => BirthDate.GetAge();
    public Address? Address { get; set; }
}

public class Employee : IPerson
{
    public int Id { get; set; }
    public string? FirstName { get; set; }
    public string? LastName { get; set; }
    public DateOnly BirthDate { get; set; }
    public required string Badge { get; set; }
    public int Age => BirthDate.GetAge();
}

public class Address
{
    public string State { get; set; } = "";
    public string City { get; set; } = "";
}

Data

public static List<IPerson> PeopleList() =>
[
    new Person { Id = 1, FirstName = "Alice", LastName = "Smith",
        BirthDate = new DateOnly(1990, 5, 15) ,
        Address = new Address { State = "OR", City = "Salem" }},

    new Person { Id = 2, FirstName = "Bob", LastName = "Johnson", 
        BirthDate = new DateOnly(1985, 11, 23) },
    new Employee() { Id = 3, FirstName = "Bob", LastName = "Johnson", 
        BirthDate = new DateOnly(1985, 11, 23), Badge = "AA1234"},
    new Person { Id = 4, FirstName = "Charlie", LastName = "Williams", 
        BirthDate = new DateOnly(2001, 1, 1)
    }
];

The following code uses is pattern matching to distinguish between a Person and an Employee. In the if assertion below employee variable contains the Employee and its properties.

public static void DeclarationAndTypePatterns()
{

    SpectreConsoleHelpers.PrintPink();

    List<IPerson> list = MockData.PeopleList();

    foreach (var person in list)
    {
        AnsiConsole.MarkupLine($"[yellow]Person:[/][bold]{person.FirstName} {person.LastName}[/]");
        // Demonstrates the 'is' pattern matching
        if (person is Employee employee)
        {
            AnsiConsole.MarkupLine($"  [green]Is an Employee.[/]");
            AnsiConsole.MarkupLine($"  [green]Badge:[/]{employee.Badge}");
        }
        else
        {
            AnsiConsole.MarkupLine($"  [grey]Not an Employee.[/]");
        }

        // Demonstrates type pattern matching and property access
        AnsiConsole.MarkupLine($"  [cyan]Birth Date:[/]{person.BirthDate}");
    }
}

Results

Logical patterns

Use the not, and, and or pattern combinators to create in this case a check if an item is a Person or Employee.

public static void LogicalPattern()
{
    SpectreConsoleHelpers.PrintPink();

    List<IPerson> list = MockData.PeopleList();

    Console.WriteLine(list.FirstOrDefault() is not Employee ? "Not an employee" : "Is an employee");
}

Disjunctive or pattern that matches an expression when either pattern matches the expression, as the following examples shows:

public static string GetSeasonSouthernHemisphere(DateTime date) => date.Month switch
{
    >= 9 and <= 11 => "Spring",
    >= 6 and <= 8 => "Summer",
    >= 3 and <= 5 => "Autumn",
    12 or 1 or 2 => "Winter",
    _ => "Not a valid month"
};

public static string GetSeasonNorthernHemisphere(DateTime date) => date.Month switch
{
    >= 3 and <= 5 => "Spring",
    >= 6 and <= 8 => "Summer",
    >= 9 and <= 11 => "Autumn",
    12 or 1 or 2 => "Winter",
    _ => "Not a valid month"
};

Summary

Several useful patterns have been provided that can help write efficient code. When using these patterns in a team, ensure team members understand them.

C#10 The field keyword

Karen Payne — Sat, 06 Jun 2026 22:57:21 +0000

Introduction

The token field enables you to write a property accessor body without declaring an explicit backing field. The token field is replaced with a compiler-synthesized backing field.

For example, previously, if you wanted to ensure that a string property couldn't be set to null, you had to declare a backing field and implement both accessors:

private string _msg;
public string Message
{
    get => _msg;
    set => _msg = value ?? throw new ArgumentNullException(nameof(value));
}

You can now simplify your code to:

public string Message
{
    get;
    set => field = value ?? throw new ArgumentNullException(nameof(value));
}

You can declare a body for one or both accessors for a field-backed property.

There's a potential breaking change or confusion reading code in types that also include a symbol named field. You can use @field or this.field to disambiguate between the field keyword and the identifier, or you can rename the current field symbol to provide better distinction.

The above is from Microsoft docs.

💡 Rather than throw new ArgumentNullException consider using a library to validate this property like FluentValidation.

Example validator:

public class MessageValidator : AbstractValidator<INotification>
{
    public MessageValidator()
    {
        RuleFor(x => x.Message)
            .NotEmpty()
            .MinimumLength(3);
    }
}

Starter example 1

Here we have two string properties that should use validation rather than throw an exception.

value, which comes in calls, is a language extension to ensure the expected format.
CapitalizeFirstLetter handles empty strings gracefully.

public static partial class StringExtensions
{

    extension(string input)
    {

        public string CapitalizeFirstLetter()
            => string.IsNullOrWhiteSpace(input) ?
                input : char.ToUpper(input[0]) + input.AsSpan(1).ToString().ToLower();


    }
}

public class Person : IPerson
{

    public int Id { get; set; }

    public required string FirstName
    {
        get;
        set => field = value.CapitalizeFirstLetter();
    }

    public required string LastName
    {
        get;
        set => field = value.CapitalizeFirstLetter();
    }

}

Starter example 2

Similar to the first example, the string properties are trimmed here. The State property will throw an exception if a user attempts to circumvent validation.

public class Address : IAddress
{
    public int Id { get; set; }
    public required int CustomerId { get; set; }
    public required string Street { get; set => field = value.Trim(); }
    public required string City { get; set => field = value.Trim(); }

    public required string State
    {
        get;
        set
        {
            field = value.ToUpper().Trim();
            if (!GetStateAbbreviations().Contains(field))
            {
                throw new ArgumentException("Invalid state abbreviation.");
            }
        }
    }

    public required string ZipCode { get; set => field = value.Trim(); }
    public required string Country { get; set => field = value.Trim(); }
    public required string Phone { get; set => field = value.Trim(); }

}


internal class Helpers
{
    /// <summary>
    /// Retrieves a list of valid U.S. state abbreviations.
    /// </summary>
    /// <returns>
    /// A <see cref="List{T}"/> of strings containing two-letter state abbreviations.
    /// </returns>
    public static List<string> GetStateAbbreviations() =>
    [
        "AL", "AK", "AZ", "AR", "CA", "CO", "CT", "DE", "FL", "GA",
        "HI", "ID", "IL", "IN", "IA", "KS", "KY", "LA", "ME", "MD",
        "MA", "MI", "MN", "MS", "MO", "MT", "NE", "NV", "NH", "NJ",
        "NM", "NY", "NC", "ND", "OH", "OK", "OR", "PA", "RI", "SC",
        "SD", "TN", "TX", "UT", "VT", "VA", "WA", "WV", "WI", "WY"
    ];

}

Intermediate example

This example shows passing the field by ref, along with the user input.

Note the use of INotifyPropertyChanged and EqualityComparer.

/// <summary>
/// Represents a view model that implements the <see cref="INotifyPropertyChanged"/> interface.
/// </summary>
/// <remarks>
/// This class provides properties with change notification support, enabling data binding scenarios.
/// </remarks>
public sealed class SomeViewModel : INotifyPropertyChanged
{
    public string Name
    {
        get;
        set => SetValue(ref field, value);
    }

    public bool IsActive
    {
        get;
        set => SetValue(ref field, value);
    } = true;

    public event PropertyChangedEventHandler? PropertyChanged;

    private void OnPropertyChanged([CallerMemberName] string? propertyName = null) =>
        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));

    /// <summary>
    /// Sets the specified field to the provided value and raises the <see cref="PropertyChanged"/> event if the value changes.
    /// </summary>
    /// <typeparam name="T">The type of the field and value.</typeparam>
    /// <param name="field">A reference to the field to be updated.</param>
    /// <param name="value">The new value to assign to the field.</param>
    /// <param name="propertyName">
    /// The name of the property that changed. This parameter is optional and is automatically provided by the compiler.
    /// </param>
    /// <remarks>
    /// This method ensures that the field is only updated if the new value is different from the current value.
    /// It also triggers the <see cref="PropertyChanged"/> event to notify listeners of the change.
    /// </remarks>
    private void SetValue<T>(ref T field, T value, [CallerMemberName] string? propertyName = null)
    {
        if (EqualityComparer<T>.Default.Equals(field, value)) return;
        field = value;
        OnPropertyChanged(propertyName);
    }
}

Source code

Limitations and Gotchas

Accessor bodies only. You can't use field in regular method bodies, constructors, or anywhere outside a property accessor. It's scoped to get, set, and init.
One field per property. Each property gets its own synthesized backing field. You can't share a field between multiple properties.
Compiler-generated name. The backing field gets a compiler-generated name (similar to auto-properties today). You can't reference it by name in reflection or serialization attributes. If you need control over the field name, use an explicit backing field.

Summary

Basics have been covered for the field keyword, nothing fancy by design, for ease of learning. Also, emphasis on not throwing exceptions unless absolutely necessary, rather than using a validation library.

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

DEV Community: Karen Payne

EF Core UseIdentityColumns

Introduction

Used

Model for demonstrations

Start primary key at 100, increment by 1

Start primary key at 10, increment by 10

Sample code

Commitment to improvement

Introduction

Intent

Written using

ASP.NET Core: Show environment

Better evolution

Best solution

Summary

See also

ASP .NET Core/BS-5 badge

Introduction

What is a badge

Code walkthrough

Frontend

Backend

Support class

Model

Summary

C# Pattern matching

Introduction

Important

Positional pattern

Example

Property pattern

Example

Declaration and type patterns

Example

Logical patterns

Summary

C#10 The field keyword

Introduction

Starter example 1

Starter example 2

Intermediate example

Limitations and Gotchas

Summary

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