DEV Community: Karen Payne

MSBuild warning NU1510

Karen Payne — Sat, 29 Aug 2026 22:33:48 +0000

Introduction

Learn about PackageReference warnings when a NuGet package is added to a Microsoft project targeting .NET 9, for instance, Microsoft.AspNetCore.Mvc.Core without a warning until upgrading to .NET10, at which time a yellow yield icon appears on the package, in this case, Microsoft.AspNetCore.Mvc.Core under dependencies in the Visual Studio project.

Actions

First action, from the developer PowerShell window, change to the root of the project and execute the following.

dotnet list package --vulnerable

We get:

warning NU1510: PackageReference Microsoft.AspNetCore.Mvc.Core will not be pruned. This package is automatically available and does not need to be referenced explicitly. Remove the PackageReference item.

A novice solution seeing NU1510 is shown below because they do not see the entire message where the solution is Remove the PackageReference item as it is part of the framework.

Our project file now as the NuGet package is not required with .NET10 Core.

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

Postmortem

When in Visual Studio, and you see a yield icon, run dotnet list package –vulnerable and read the entire output, whether the warning is NU1510 or another. If the recommendation is unclear, do a web search; in most cases, it will return to the Microsoft page for that warning.

Project file

Resources

C# Copy files done right

Karen Payne — Mon, 24 Aug 2026 15:11:05 +0000

Introduction

When copying a file using File.Copy the source date and time attributes, which are not retained.

Teaches

Shows how to copy a folder using a wildcard pattern, followed by setting the date/time and setting file attributes. Also, do the same for a single file, excluding file copying.

The above operations are part of a class project, and an exception in both methods use Serilog to write runtime exceptions to a log file.

Both methods set date, time, and file attributes done within a try/catch which logs exceptions to a log file in the executable folder under a folder named Logs.

public static bool SetFileDateTime(string sourceFile, string destinationFile)
{
    ArgumentException.ThrowIfNullOrWhiteSpace(sourceFile);
    ArgumentException.ThrowIfNullOrWhiteSpace(destinationFile);

    if (!File.Exists(sourceFile))
    {
        throw new FileNotFoundException("Source file does not exist.", sourceFile);
    }

    if (!File.Exists(destinationFile))
    {
        throw new FileNotFoundException("Destination file does not exist.", destinationFile);
    }

    var sourceInfo = new FileInfo(sourceFile);

    try
    {
        File.SetCreationTimeUtc(destinationFile, sourceInfo.CreationTimeUtc);
        File.SetLastWriteTimeUtc(destinationFile, sourceInfo.LastWriteTimeUtc);
        File.SetLastAccessTimeUtc(destinationFile, sourceInfo.LastAccessTimeUtc);

        File.SetAttributes(destinationFile, File.GetAttributes(sourceFile));

        return true;
    }
    catch (Exception e)
    {
        Log.Error(e, "An error occurred while setting file timestamps for {DestinationFile}", destinationFile);
        return false;
    }

}

Source code Demo code

Summary

Setting file attributes is the proper way to copy files, and catching any runtime exceptions in a log file.

WinForm Resource extensions

Karen Payne — Sun, 23 Aug 2026 00:01:14 +0000

Introduction

Learn how to retrieve a project resource by name for either an icon or a bitmap, size a PictureBox to properly display the image, and change a form's icon at runtime.

Project names reflect the original Microsoft Technet article written for NET7 and have been updated to NET10. The Microsoft Technet site has been retired.

By using the presented code, a developer

Has common code so no need to copy code from project to project
A good deal of code will be a learning opportunity.

Class project

ImageHelper class provides code to retrieve Icon and BitMap resources by passing a Windows Form ResourceManager.

ResourceItemList extension method is responsible for remembering Icon and BitMap resources.
ResourceImageNames extension method returns names of all resources

public static class ImageHelper
{
    public static List<string> ResourceImageNames(this ResourceManager manager)
    {

        var names = new List<string>();
        var resourceSet = manager.GetResourceSet(CultureInfo.CurrentUICulture, true, true);

        names.AddRange(resourceSet!.Cast<DictionaryEntry>()
            .Where(dictionaryEntry => dictionaryEntry.Value is Image or Icon)
            .Select(dictionaryEntry => dictionaryEntry.Key.ToString()));

        return names;
    }


    public static List<ResourceItem> ResourceItemList(this ResourceManager manager)
    {
        var items = new List<ResourceItem>();

        foreach (var name in manager.ResourceImageNames())
        {

            var item = new ResourceItem()
            {
                Name = name,
                IsIcon = false
            };

            if (manager!.GetObject(name) is Icon)
            {
                item.Image = ((Icon)manager.GetObject(name)!)?.ToBitmap();
                item.IsIcon = true;
            }
            else
            {
                item.Image = (Bitmap)manager.GetObject(name)!;
            }

            items.Add(item);


        }

        return items;

    }
}

// model for above

public class ResourceItem
{
    /// <summary>
    /// Resource name
    /// </summary>
    public string Name { get; set; }
    /// <summary>
    /// Image which is either an <see cref="Icon"/> or <see cref="Bitmap"/>
    /// </summary>
    public Bitmap Image { get; set; }
    /// <summary>
    /// Indicates if dealing with an icon so when displaying the
    /// control used to display can adjust it's size or Size mode
    /// </summary>
    public bool IsIcon { get; set; }
    public override string ToString() => Name;
}

Usage

Assign all resource images first to a BindingSource, which becomes the DataSource for a ListBox

_allBindingSource.DataSource = ResourceImages.Instance
    .Images()
    .OrderBy(x => x.Name)
    .ToList();

AllImagesListBox.DataSource = _allBindingSource;

On position change

private void ChangeFromAllImage()
{
    if (AllImagesListBox.SelectedIndex <= -1) return;

    var item = (ResourceItem)_allBindingSource.Current;
    AllImagesPictureBox.SizeMode = item!.IsIcon ? PictureBoxSizeMode.Normal : PictureBoxSizeMode.Zoom;
    AllImagesPictureBox.Image = item.Image;
}

To get Icon and BitMap image to ListBoxes.

_iconBindingSource.DataSource = ResourceImages.Instance
    .Images()
    .Icons()
    .OrderBy(x => x.Name)
    .ToList();

IconListBox.DataSource = _iconBindingSource;
_iconBindingSource.PositionChanged += IconBindingSource_PositionChanged;

ChangeFromIconImage();

_bindingList = new BindingList<ResourceItem>(ResourceImages.Instance
    .Images()
    .BitMaps()
    .OrderBy(x => x.Name)
    .ToList());

_bitmapBindingSource.DataSource = _bindingList;
BitmapImagesListBox.DataSource = _bitmapBindingSource;
_bitmapBindingSource.PositionChanged += BitmapBindingSource_PositionChanged;

Get a single Icon

This code retrieves an icon by name (case-insensitive) and sets the form's icon.

Icon = ResourceImages.Instance.Images().GetIconByName("csharp");

Use GetBitmapByName, which returns a single BitMap.

Source code

C# ExceptionDispatchInfo Class

Karen Payne — Sun, 16 Aug 2026 17:57:12 +0000

Introduction

Learn about the ExceptionDispatchInfo object, which stores the stack trace information and Watson information that an exception contains at the point where it's captured. The exception can then be thrown later, possibly on another thread, by calling ExceptionDispatchInfo.Throw method.

Examples

💡 In these examples, the task is simple: read a file that does not exist here.

Conventional example

The following example does not use an ExceptionDispatchInfo object; instead, it checks whether the file exists before attempting to read it.

Results are returned by deconstructing a tuple.

private static void ReadFile()
{

    var fileName = "nonexistentfile.txt";

    if (File.Exists(fileName))
    {
        var (success, lines, exception) = FileOperations.ReadFile();
    }
    else
    {
        SpectreConsoleHelpers.ErrorPill(Justify.Left, $"File '{fileName}' does not exist.");
        Log.Information("File '{FileName}' does not exist. Called from {Method} method.", 
            fileName, 
            nameof(ReadFile));
    }
}

public class FileOperations
{

   public static (bool success, string[] lines, Exception exception) ReadFile()
{
    try
    {
        var lines = File.ReadAllLines("NonExistingFile.txt");
        return (true, lines, null);
    }
    catch (Exception e)
    {
        Log.Error(e, "An error occurred while reading the file.");
        return (false, Array.Empty<string>(), e);
    }

}

Uses a try/catch as the user may not have permissions for read access
Logs the exception to a daily log file
Returns a tuple
- Success/failure
- Contents of the file on successful read operation
- If an exception is raised, the root exception

ExceptionDispatchInfo example

Here, if a runtime exception is raised ExceptionDispatchInfo.Capture method stores the exception and is return as part of the returning tuple.

public class FileOperations
{
    public static (string[] lines, ExceptionDispatchInfo exceptionDispatchInfo) ReadAllLines()
    {
        string[] lines = null;
        ExceptionDispatchInfo exceptionDispatchInfo = null;
        try
        {
            lines = File.ReadAllLines("NonExistingFile.txt");
        }
        catch (Exception localException)
        {
            exceptionDispatchInfo = ExceptionDispatchInfo.Capture(localException);
        }
        return (lines, exceptionDispatchInfo);
    }

}

Calling code:

private static void HandleFileReadOperation1()
{
    var (lines, exceptionDispatchInfo) = FileOperations.ReadAllLines(); // file does not exist
    if (exceptionDispatchInfo is not null)
    {

        SpectreConsoleHelpers.ErrorPill(Justify.Left, "An error occurred while reading the file:");
        ExceptionHelpers.ColorStandard(exceptionDispatchInfo.SourceException);
        Log.Error(exceptionDispatchInfo.SourceException, "An error occurred while reading the file.");

        if (AnsiConsole.Confirm("Continue with throw?"))
        {
            exceptionDispatchInfo!.Throw();
        }

    }
    else
    {
        foreach (var line in lines)
        {
            Console.WriteLine(line);
        }
    }
}

Return results in a tuple
- Lines read if the read operation was successful
  - Display lines
- ExceptionDispatchInfo instance on a failed read operation
  - Display and log error
  - Ask to throw the captured exception

Source code

Written in Microsoft Visual Studio 2026
.NET Core 10

Source code

Summary

💡 ExceptionDispatchInfo is to be considered to be simply another tool in a developer's toolbox.

Choosing the right path to follow should never be determined by a class or language feature, but by business requirements.

ExceptionDispatchInfo has been available for a long time, but most developers don't know about it, which is why they're more likely to use it because it's new to them. As stated above, do not force the use of ExceptionDispatchInfo.

Applies

Product	Versions
.NET	Core 1.0, Core 1.1, Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7, 8, 9, 10, 11
.NET Framework	4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1
.NET Standard	1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 2.0, 2.1
UWP	10.0

Libraries

All operations use SeriLog NuGet package to log runtime issues.
Spectre.Console library is used to enhance console output

C# ModuleInitializerAttribute

Karen Payne — Sun, 02 Aug 2026 20:35:54 +0000

Introduction

The ModuleInitializerAttribute in C# NET Core marks a method to run automatically when a module (assembly) loads, before any other code runs.

Module initializers are intended to be used by application code to ensure an application's components are initialized before the application code begins executing.

Applies to

Product	Versions
.NET	5, 6, 7, 8, 9, 10, 11

Key Rules

A module cannot be deployed independently; instead, it is always part of an assembly.
Must be static and return void (or async void).
Must take no parameters.
Must not be generic or inside a generic class.
Must be internal or public.

Key Execution Rules

No explicit ordering: The ModuleInitializerAttribute does not take a parameter, priority number, or sequence value to sort execution order.
Compiler-dependent: The compiler decides the exact sequence, which can change between different project builds, updates, or toolchains.
Module isolation: Best practices dictate that module initializers must be completely agnostic of one another and avoid dependencies on execution sequence.

Common Uses/Task

Registering services or plugins.
Setting up global configurations.

Console project example

In this example, there are two methods marked with [ModuleInitializer] whose code executes prior to the Program.Main.

Sets the console window title
Configure Serilog
Reads settings from appsettings
Validates that the expected connection string exists in appsettings.json

Source code

internal partial class Program
{
    [ModuleInitializer]
    public static void MainSetup()
    {
        var assembly = Assembly.GetEntryAssembly();
        var product = assembly?.GetCustomAttribute<AssemblyProductAttribute>()?.Product;

        Console.Title = product!;

        WindowUtility.SetConsoleWindowPosition(WindowUtility.AnchorWindow.Center);

        Setup();

    }
    private static void Setup()
    {

        SetupLogging.Development();

        var services = ConfigureServices();
        using var provider = services.BuildServiceProvider();
        var setup = provider.GetService<SetupServices>();
        setup!.GetConnectionStrings();
        setup.GetEntitySettings();

        SpectreConsoleHelpers.SetEncoding();
    }

    [ModuleInitializer]
    public static void AppsettingsCheck()
    {
        if (!JsonHelpers.MainConnectionExists())
        {
            throw new MissingMainConnectionException();
        }
    }
}

ASP.NET Core project example

This example displays the current environment.

Source code

public class Helpers
{
    [ModuleInitializer]
    public static void Initialize()
    {

        SpectreConsoleHelpers.SetEncoding();

        AnsiConsole.MarkupLine(":collision: [DeepPink1]Application is starting...[/]");
        SpectreConsoleHelpers.PinkPill(Justify.Left,
            Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT") == "Development"
                ? "Application is running in Development mode."
                : "Application is running in Production mode.");
    }
}

C# null-conditional assignment

Karen Payne — Sun, 26 Jul 2026 22:25:17 +0000

Introduction

C# 14 introduces null-conditional assignment, allowing the ?. and ?[] operators to appear on the left side of an assignment. The assignment occurs only when the target object is not null; otherwise, it is safely skipped.

For example, customer?.Name = "Karen"; replaces an explicit null check and can also be used with compound assignment operators such as += and -=.

Before C# 14, you needed to null-check a variable before assigning to a property:

if (customer is not null)
{
    customer.Order = GetCurrentOrder();
}

You can simplify the preceding code using the ?. operator:

customer?.Order = GetCurrentOrder();

All of the above came from Microsoft documentation

💡 Before implementing in code make sure it meets all business requirements.

Example 1

Models

public class Customer
{
    public Order Order { get; set; }
}

public class Order
{
    public int Id { get; set; }
    public List<OrderItem> OrderItems { get; set; }
}

public class OrderItem
{
    public int OrderItemId { get; set; }
    public int OrderId { get; set; }
    public Order Order { get; set; }
    public int ProductId { get; set; }
    public Product? Product { get; set; }
    public int Quantity { get; set; }
    public decimal UnitPrice { get; set; }
}

public class Product
{
    public int Id { get; set; }
    public string Name { get; set; }
}

Executing code

First time GetCurrentOrder is assigned to customer.Order the order is assigned as we have a valid Customer while on the second attempt there is no assignment as there is no valid Customer.

private static void HandleCustomerOrderAssignment()
{

    SpectreConsoleHelpers.PrintPink();

    Customer customer = new();

    customer?.Order = GetCurrentOrder();  // order is assigned to customer.Order 
    AnsiConsole.MarkupLine($"[DeepPink1]customer!.Order.Id[/] {customer!.Order.Id}");

    customer = null;

    // Null-conditional assignment, no exception is thrown, and the assignment is skipped
    customer?.Order = GetCurrentOrder(); 
    AnsiConsole.MarkupLine("[DeepPink1]No exceptions[/]");
}

private static Order GetCurrentOrder() => new() { Id = 111 };

Example 2

Uses the same models as above. In this example goes down to OrderItem of an Order.

Executing code

private static void HandleOrderItems()
{
    SpectreConsoleHelpers.PrintPink();

    var order = new Order
    {
        Id = 123,
        OrderItems =
        [
            new OrderItem { OrderItemId = 1, Quantity = 2, UnitPrice = 10.50m },
            new OrderItem { OrderItemId = 2, Quantity = 1, UnitPrice = 25.00m }
        ]
    };

    // Display order with null-conditional access to OrderItems
    AnsiConsole.MarkupLine($"[DeepPink1]Order ID:[/] {order.Id}");
    AnsiConsole.MarkupLine("[DeepPink1]Order Items:[/]");
    order.OrderItems?.ToList()
        .ForEach(item =>
            AnsiConsole.MarkupLine($"     [DeepPink1]Item ID: " +
                                   $"{item.OrderItemId}, Quantity: " +
                                   $"{item.Quantity}, Unit Price: " +
                                   $"{item.UnitPrice:C}[/]"));

    Console.WriteLine();

    AnsiConsole.MarkupLine("[green bold]Order? anotherOrder = null[/]");
    // Null-conditional assignment for OrderItems
    Order? anotherOrder = null;
    anotherOrder?.OrderItems ??= []; // This will not execute as anotherOrder is null

    Console.WriteLine($"Another Order Items count: {anotherOrder?.OrderItems?.Count ?? 0}"); // Output: 0

    // Now assign an order to anotherOrder
    anotherOrder = new Order { Id = 456 };
    anotherOrder.OrderItems ??= new List<OrderItem>(); // This will assign a new list
    anotherOrder.OrderItems.Add(new OrderItem { OrderItemId = 3, Quantity = 5, UnitPrice = 5.00m });

    Console.WriteLine($"Another Order ID: {anotherOrder.Id}");
    AnsiConsole.WriteLine("Another Order Items:");
    anotherOrder.OrderItems.ForEach(item =>
        AnsiConsole.MarkupLine($" - Item ID: {item.OrderItemId}, " +
                               $"Quantity: {item.Quantity}, Unit Price: {item.UnitPrice:C}"));

    Console.WriteLine();

    // Example with a null order and null-conditional member access
    Order? nullableOrder = null;
    Console.WriteLine($"Nullable Order Items count: " +
                      $"{nullableOrder?.OrderItems?.Count ?? 0}"); // Output: 0

    // Null-conditional assignment on a null object, does nothing
    nullableOrder?.OrderItems ??=
        [
            new OrderItem { OrderItemId = 4, Quantity = 1, UnitPrice = 99.99m }
        ];
    Console.WriteLine($"Nullable Order Items count after assignment attempt: " +
                      $"{nullableOrder?.OrderItems?.Count ?? 0}"); // Output: 0
}

Example 3

Model

public sealed class Account
{
    public int Id { get; set; }
    public decimal Balance { get; set; }
    public int RewardPoints { get; set; }
    public int Flags { get; set; }
    public string? DisplayName { get; set; }

    public override string ToString() =>
        $"""
         [DeepPink1]Id:[/] {Id}, 
         [DeepPink1]Balance:[/] '{Balance:C}', 
         [DeepPink1]RewardPoints:[/] '{RewardPoints}', 
         [DeepPink1]Flags:[/] '{Flags}', 
         [DeepPink1]DisplayName:[/] '{DisplayName}'
         """;
}

Executing code

Shows setting property values using the null-coalescing operator.

private static void HandleAccountAssignment()
{

    SpectreConsoleHelpers.PrintPink();

    Account? account = new()
    {
        Id = 1,
        Balance = 1_000.00m,
        RewardPoints = 100,
        Flags = 0b_0011,
        DisplayName = null
    };

    account?.Balance += 100m;
    account?.Balance -= 50m;
    account?.RewardPoints %= 10;
    account?.Flags >>= 1;

    Console.WriteLine();
    AnsiConsole.MarkupLine(account?.ToString() ?? "No account");
    Console.WriteLine();

    // Null-conditional assignment
    account?.DisplayName ??= "Unknown display name";
    Console.WriteLine($"Name: {account?.DisplayName}");

    // null out the account reference
    account = null;
    // Null-conditional assignment, no exception is thrown, and the assignment is skipped
    account?.DisplayName ??= "Default display name"; 
    Console.WriteLine("No exceptions");

    account?.Balance += 100m;
    account?.Balance -= 50m;
    account?.Flags >>= 1 ;

    Console.WriteLine();
    AnsiConsole.MarkupLine(account?.ToString() ?? "No account");

}

Feature specification

Details

Source code

Bypass Windows lock screen

Karen Payne — Sat, 25 Jul 2026 20:47:51 +0000

Introduction

Learn a minimalistic approach to bypassing the Windows lock screen when a client has set a timeout rule that the client has disabled, altering the timeout value.

All work is done in a console project rather than in the system tray, as the user may not have permission to run it as a Windows startup application.

Code flow

Minimize application to Windows taskbar
Disable the screen saver and monitor sleep see the following code.
Stops with a Console.ReadLine
Restore window, press ENTER to restore normal lock timeout, see the following code.

Source code

Written with Microsoft Visual Studio 2026, NET 10 Framework.

Source code

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# 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.

DEV Community: Karen Payne

MSBuild warning NU1510

Introduction

Actions

Postmortem

Resources

C# Copy files done right

Introduction

Teaches

Summary

WinForm Resource extensions

Introduction

Class project

Usage

Get a single Icon

C# ExceptionDispatchInfo Class

Introduction

Examples

Conventional example

ExceptionDispatchInfo example

Source code

Summary

Applies

See also

Libraries

C# ModuleInitializerAttribute

Introduction

Applies to

Key Rules

Key Execution Rules

Common Uses/Task

Console project example

ASP.NET Core project example

See also

C# null-conditional assignment

Introduction

Example 1

Executing code

Example 2

Executing code

Example 3

Executing code

Feature specification

Source code

Bypass Windows lock screen

Introduction

Code flow

Source code

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