DEV Community: Karen Payne

C# File globbing tip

Karen Payne — Wed, 30 Sep 2026 00:10:42 +0000

Introduction

File Globbing provides a great way to search for files recursively from a parent folder using patterns. In some cases, one or more folders have to be skipped because the user running the code has insufficient permissions, and the task does not need to scan those folders.

Use the language extension AddExcludePatterns to exclude those folders.

Source code

C# Singleton basics

Karen Payne — Mon, 28 Sep 2026 01:05:05 +0000

Introduction

The Singleton pattern ensures that a class has only one instance throughout an application and provides a single, globally accessible way to retrieve it.

Learn through examples of common use cases with several code samples.

All code was written in Microsoft Visual Studio 2026.

Advantages: A Singleton provides controlled access to a shared resource, avoids the overhead and inconsistency of creating multiple instances, and can centralize application-wide services such as configuration, logging, or caching. When implemented carefully, it also supports lazy initialization, so the instance is created only when first requested.

Key Implementation Rules

To successfully build a singleton, you need to enforce two core rules:

sealed class modifier: Prevents subclassing, which could otherwise result in multiple unique instances of the derived classes.
private parameterless constructor: Prevents external code from creating new instances using the new keyword.

Main Source code Library Source code Test Source code

Example 1

Source code

Provides a list of month names and indices useful in a web project dropdown element for add and edit pages.

using SingletonsApp.Models;
using static System.Globalization.DateTimeFormatInfo;

namespace SingletonsApp.Classes.SingletonSamples;

public sealed class Basic1
{
    private static readonly Lazy<Basic1> Lazy = new(() => new Basic1());
    public static Basic1 Instance => Lazy.Value;

    public List<MonthItem> MonthList =>
    [
        .. CurrentInfo.MonthNames[..^1]
            .Select((monthName, index) => 
                new MonthItem(index + 1, monthName))
    ];
}

💡 Using Lazy handles thread safety and lazy initialization automatically behind the scenes

ASP.NET Core example

Source code

Creates a dropdown using Helpers.Instance.MonthList same as above with a different class name.

@page
@model IndexModel

@{
    ViewData["Title"] = "Month Selection";
}

<div class="container mt-5">
    <div class="d-flex justify-content-center">
        <form method="post">

            <div class="mb-3">
                <label asp-for="SelectedMonth" class="form-label">
                    Select month
                </label>

                <select asp-for="SelectedMonth"
                        class="form-select"
                        style="width: 250px;">

                    <option value="">Select a month</option>

                    @foreach (var month in Model.MonthItems)
                    {
                        <option value="@month.Index">
                            @month.Name
                        </option>
                    }

                </select>
            </div>

            <button type="submit"
                    class="btn btn-primary">
                Get Month
            </button>

            @if (Model.SelectedMonthItem is not null)
            {
                <div class="alert alert-success mt-3">
                    Selected month:
                    <strong>@Model.SelectedMonthItem.Name</strong>
                    (@Model.SelectedMonthItem.Index)
                </div>
            }

        </form>
    </div>
</div>

Backend

using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Mvc.RazorPages;
using SingletonWebApp.Classes;
using SingletonWebApp.Models;

namespace SingletonWebApp.Pages;

public class IndexModel : PageModel
{
    public List<MonthItem> MonthItems { get; set; } = [];

    [BindProperty]
    public int? SelectedMonth { get; set; }

    public MonthItem? SelectedMonthItem { get; set; }

    public void OnGet()
    {
        MonthItems = Helpers.Instance.MonthList;
    }

    public void OnPost()
    {
        MonthItems = Helpers.Instance.MonthList;

        SelectedMonthItem = MonthItems
            .FirstOrDefault(month => month.Index == SelectedMonth);
    }
}

Do the same for Helpers.Instance.MonthList in other pages.

Dependency Injection version

using static System.Globalization.DateTimeFormatInfo;
using SingletonWebApp.Models;

namespace SingletonWebApp.Classes;

public sealed class Helpers
{
    //private static readonly Lazy<Helpers> Lazy = new(() => new Helpers());
    //public static Helpers Instance => Lazy.Value;

    public List<MonthItem> MonthList { get; init; }

    public Helpers()
    {
        MonthList = CurrentInfo.MonthNames[..^1]
            .Select((monthName, index) =>
                new MonthItem(index + 1, monthName)).ToList();
    }
}

💡 Here we need a public constructor

Program.cs register Helpers class.

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

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

        // Register Helpers as a singleton
        builder.Services.AddSingleton<Helpers>();

Index.cshtml.cs

💡 note use of primary constructor

public class IndexModel(Helpers helpers) : PageModel
{
    public List<MonthItem> MonthItems { get; set; } = [];

    [BindProperty]
    public int? SelectedMonth { get; set; }

    public MonthItem? SelectedMonthItem { get; set; }

    private readonly Helpers _helpers = helpers;

    public void OnGet()
    {
        MonthItems = _helpers.MonthList;
    }

    public void OnPost()
    {
        MonthItems = _helpers.MonthList;

        SelectedMonthItem = MonthItems
            .FirstOrDefault(month => month.Index == SelectedMonth);
    }
}

Example 2

This example was originally done with a database and no singleton.

"TransactionInformation": {
"CurrentValue": "MW00001"
}

Each time a waiter takes a order for a table CurrentValue is incremented by 1 and updates the value in appsettings.json

public sealed class Basic2
{
    private static readonly Lazy<Basic2> Lazy = new(() => new Basic2());
    public static Basic2 Instance => Lazy.Value;

    public TransactionInformation Transaction { get; set; }


    public void UpdateTransactionIdentifier()
    {
        TransactionInformationReader.Save(Transaction);
    }

    private Basic2()
    {
        TransactionInformation? x = TransactionInformationReader.Load();

        Transaction = new TransactionInformation()
        {
            CurrentValue = x.CurrentValue
        };  
    }
}

Example 3

Uses IHostEnvironment Interface to determine if the current application is in development, staging or production environment and sets the application database connection.

using Microsoft.Extensions.Hosting;
using SingletonsApp.Models;

namespace SingletonsApp.Classes.Configuration;

public static class HostEnvironmentExtensions
{
    extension(IHostEnvironment environment)
    {

        public bool CheckIsDevelopmentEnvironment() => environment.IsDevelopment();
        public bool CheckIsStagingEnvironment() => environment.IsStaging();
        public bool CheckIsProductionEnvironment() => environment.IsProduction();

        public void DebugPrint(string databaseConnectionString, HelpDesk helpDesk)
        {

            if (environment.IsProduction()) return;

            Console.WriteLine($"       Current Environment: {environment.EnvironmentName}");
            Console.WriteLine($"          Application Name: {environment.ApplicationName}");
            Console.WriteLine($"         Content Root Path: {environment.ContentRootPath}");
            Console.WriteLine($"Database Connection String: {databaseConnectionString}");
            Console.WriteLine($"           Help Desk Phone: {helpDesk.Phone}");
            Console.WriteLine($"           Help Desk Email: {helpDesk.Email}");
        }
    }
}

Singleton

using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using SingletonsApp.Classes.Configuration;
using SingletonsApp.Models;

namespace SingletonsApp.Singletons;

public sealed class EnvironmentSettings
{
    private static readonly Lazy<EnvironmentSettings> Lazy = new(() => new EnvironmentSettings());
    public static EnvironmentSettings Instance => Lazy.Value;

    public AppEnvironment Environment { get; init; }


    public HelpDesk HelpDesk { get; init; }


    public string DatabaseConnectionString { get; init; } = null!;


    private EnvironmentSettings()
    {

        DataConnections connections = AppSettingsReader.LoadConnectionStringsConnections();
        HelpDesk = AppSettingsReader.LoadHelpDesk();

        using IHost host = Host.CreateDefaultBuilder().Build();

        IHostEnvironment environment = host.Services.GetRequiredService<IHostEnvironment>();

        if (environment.CheckIsDevelopmentEnvironment())
        {
            Environment = AppEnvironment.Development;
            DatabaseConnectionString = connections.ConnectionStrings.DevelopmentConnection;
        }

        if (environment.CheckIsStagingEnvironment())
        {
            Environment = AppEnvironment.Staging;
            DatabaseConnectionString = connections.ConnectionStrings.StagingConnection;
        }

        if (environment.CheckIsProductionEnvironment())
        {
            Environment = AppEnvironment.Production;
            DatabaseConnectionString = connections.ConnectionStrings.ProductionConnection;
        }
    }
}

Example 4

This example uses a singleton to get NuGet local packages and related information on a developer's computer.

Main Source code Frontend Source code

Required packages

NuGet.Configuration
NuGet.Protocol

using NuGet.Configuration;
using NuGetLibrary.Models;
#pragma warning disable CS8619 // Nullability of reference types in value doesn't match target type.

namespace NuGetLibrary;

/// <summary>
/// Represents the settings for managing NuGet packages, including configuration
/// and the global packages folder path.
/// </summary>
public sealed class PackageSettings
{
    private static readonly Lazy<PackageSettings> Lazy = new(() => new PackageSettings());
    public static PackageSettings Instance => Lazy.Value;

    public ISettings NuGetSettings { get; set; }

    /// <summary>
    /// Gets the path to the global NuGet packages folder.
    /// </summary>
    /// <value>
    /// A string representing the path to the global NuGet packages folder.
    /// </value>
    public string Path { get; init; }

    public List<string> DisabledSources { get; init; } = null!;

    /// <summary>
    /// Gets the list of NuGet packages
    /// </summary>
    public List<NuGetPackage> NuGetPackages { get; set; }

    private PackageSettings()
    {
        NuGetSettings = Settings.LoadDefaultSettings(null);
        Path = SettingsUtility.GetGlobalPackagesFolder(NuGetSettings);

        NuGetPackages = PackageWork.Packages();

        /*
         * Get the list of disabled package sources from the NuGet configuration.
         * The real purpose of this code is to show that from exploring the codebase, that there
         * is a class NuGet.Configuration.ConfigurationConstants that contains constant node names
         * to reference in the NuGet configuration file rather than hard coding them and by hard coding these
         * may cause issues in the future if the node name changes.
         */
        SettingSection? disableSources = NuGetSettings.GetSection(ConfigurationConstants.DisabledPackageSources);

        if (disableSources is not null)
        {
            DisabledSources = disableSources!.Items.Select(x => x.GetAttributes().Values.FirstOrDefault()).ToList();
        }

    }

}

Combined Serilog and EF Core Logging to the Same File in ASP .NET Core

Karen Payne — Wed, 23 Sep 2026 20:33:26 +0000

Introduction

Learn how to use a single daily file to log regular log messages and EF Core commands with the Serilog packages.

Source code

Required NuGet packages

Serilog.AspNetCore
Serilog.Extensions.Logging.File
Serilog.Sinks.Console
Serilog.Sinks.File
Microsoft.EntityFrameworkCore.SqlServer (for demo code)

Serilog configurations

Add the following Serilog settings to the appsettings.json file, and change the path to where you want to create and write log information.

"Serilog": {
  "Using": [
    "Serilog.Sinks.File"
  ],
  "MinimumLevel": {
    "Default": "Information",
    "Override": {
      "Microsoft": "Warning",
      "Microsoft.EntityFrameworkCore.Database.Command": "Information"
    }
  },
  "WriteTo": [
    {
      "Name": "File",
      "Args": {
        "path": "C:\\Logs\\ef-.log",
        "rollingInterval": "Day",
        "retainedFileCountLimit": 7,
        "outputTemplate": "{Timestamp:yyyy-MM-dd HH:mm:ss.fff zzz} [{Level:u3}] {SourceContext}{NewLine}{Message:lj}{NewLine}{Exception}"
      }
    }
  ]
}

💡 See also: configuration basics

Add the following configuration code to Program.cs (see provided code).

builder.Host.UseSerilog((context, services, configuration) =>
    configuration
        .ReadFrom.Configuration(context.Configuration)
        .ReadFrom.Services(services)
        .Enrich.FromLogContext());

💡 If logging fails for any reason, see Debugging and Diagnostics.

Start writing code

Once the above and EF Core have been configured in Program.cs, start writing code and logging as shown below.

using Microsoft.EntityFrameworkCore;
using Serilog;

namespace EF_Core3.Pages;

public class IndexModel(Context context) : PageModel
{
    public void OnGet()
    {
        var contactsList = context.Contacts.ToList();          
        var customersList = context.Customers
            .Include(c => c.CountryIdentifierNavigation)
            .ToList();

        Log.Information("Retrieved {ContactsCount} " +
                        "contacts and {CustomersCount} " +
                        "customers from the database.", 
            contactsList.Count, 
            customersList.Count);

    }
}

Log file for above

2026-09-23 10:26:35.775 -07:00 [WRN] Microsoft.EntityFrameworkCore.Model.Validation
Sensitive data logging is enabled. Log entries and exception messages may include sensitive application data; this mode should only be enabled during development.
2026-09-23 10:26:37.089 -07:00 [INF] Microsoft.EntityFrameworkCore.Database.Command
Executed DbCommand (53ms) [Parameters=[], CommandType='"Text"', CommandTimeout='30']
SELECT [c].[ContactId], [c].[ContactTypeIdentifier], [c].[FirstName], [c].[FullName], [c].[LastName]
FROM [Contacts] AS [c]
2026-09-23 10:26:37.450 -07:00 [INF] Microsoft.EntityFrameworkCore.Database.Command
Executed DbCommand (10ms) [Parameters=[], CommandType='"Text"', CommandTimeout='30']
SELECT [c].[CustomerIdentifier], [c].[City], [c].[CompanyName], [c].[ContactId], [c].[ContactTypeIdentifier], [c].[CountryIdentifier], [c].[Fax], [c].[ModifiedDate], [c].[Phone], [c].[PostalCode], [c].[Region], [c].[Street], [c0].[CountryIdentifier], [c0].[Name]
FROM [Customers] AS [c]
LEFT JOIN [Countries] AS [c0] ON [c].[CountryIdentifier] = [c0].[CountryIdentifier]
2026-09-23 10:26:37.545 -07:00 [INF] 
Retrieved 91 contacts and 91 customers from the database.

Provided sample code

Create the NorthWind2024 database under localdb (best done in SSMS)
Under Scripts folder run populate.sql under localdb\NorthWind2024 database

In Program.cs COMBINED_LOGS which is defined under project properties. Uncheck to write two log files, one for regular logging and one for EF Core.

Summary'

Following the instructions and using the code sample will create a single daily combined log file.

C# basic JsonConverter tip

Karen Payne — Mon, 21 Sep 2026 00:35:28 +0000

Introduction

Learn how to properly use a JsonConverter, along with property and global setup for converters.

Before getting started, the converter is intentionally simple. The focus here is proper planning for the data for a specific task, like importing data from a JSON file into a database, in this case, properly formatted.

Sample converter

Reads and converts the JSON string value to ensure the first character to uppercase.

public class UpperCaseFirstCharConverter : JsonConverter<string>
{
    public override bool CanConvert(Type typeToConvert)
        => typeToConvert == typeof(string);

    public override string Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        => (reader.GetString() ?? string.Empty).CapitalizeFirstLetter();

    public override void Write(Utf8JsonWriter writer, string value, JsonSerializerOptions options)
    {
        writer.WriteStringValue(value ?? "Null");
    }
}

Example usage

Proper-case FirstName and LastName from a JSON file.

Sample data

[
  {
    "Id": 1,
    "FirstName": "jose",
    "LastName": "fernandez",
    "BirthDate": "1985-01-01"
  },
  {
    "Id": 2,
    "FirstName": "Miguel",
    "LastName": "loPez",
    "BirthDate": "1970-12-04"
  },
  {
    "Id": 3,
    "FirstName": "angel",
    "LastName": "PEREZ",
    "BirthDate": "1980-09-11"
  }
]

Modal/class

public class Person
{
    public int Id { get; set; }
    public required string FirstName { get; set; }
    public required string LastName { get; set; }
    public DateOnly BirthDate { get; set; }
}

Code

public static void GlobalExample()
{

    SpectreConsoleHelpers.PrintPink();

    string json =
        /*lang=json*/
        """
        [
          {
            "Id": 1,
            "FirstName": "jose",
            "LastName": "fernandez",
            "BirthDate": "1985-01-01"
          },
          {
            "Id": 2,
            "FirstName": "Miguel",
            "LastName": "loPez",
            "BirthDate": "1970-12-04"
          },
          {
            "Id": 3,
            "FirstName": "angel",
            "LastName": "PEREZ",
            "BirthDate": "1980-09-11"
          }
        ]
        """;

    AnsiConsole.MarkupLine("[bold yellow]Original JSON:[/]");
    SpectreConsoleHelpers.PresentJson(json);

    Console.WriteLine("\n");

    AnsiConsole.MarkupLine("[bold blue]Deserialized and Serialized JSON (with capitalized names):[/]");
    var people = JsonSerializer.Deserialize<List<Person>>(json, GlobalJsonOptions);
    var json1 = JsonSerializer.Serialize(people, GlobalJsonOptions);

    SpectreConsoleHelpers.PresentJson(json1);
}

private static readonly JsonSerializerOptions GlobalJsonOptions = new()
{
    Converters = { new UpperCaseFirstCharConverter() },
    WriteIndented = true
};

For ASP.NET Core in Program.cs

/*
 * Register the custom JSON converter globally for all Razor Pages.
 * This ensures that the converter is applied to all JSON serialization
 * and deserialization operations.
 */
builder.Services
    .AddRazorPages()
    .AddJsonOptions(options =>    
    {
        options.JsonSerializerOptions.Converters.Add(
            new UpperCaseFirstCharConverter());
    });

Results from a console project

Suppose the following data was used, the State property will be changed.

[
  {
    "Id": 1,
    "FirstName": "jose",
    "LastName": "fernandez",
    "State": "CA",
    "BirthDate": "1985-01-01"
  },
  {
    "Id": 2,
    "FirstName": "Miguel",
    "LastName": "loPez",
    "State": "NY",
    "BirthDate": "1970-12-04"
  },
  {
    "Id": 3,
    "FirstName": "angel",
    "LastName": "PEREZ",
    "State": "TX",
    "BirthDate": "1980-09-11"
  }
]

The fix is to annotate only the FirstName and LastName properties with [JsonConverter] attribute, followed by using the code below, which does not add the converter in the options.

public class Customer
{
    public int Id { get; set; }
    [JsonConverter(typeof(UpperCaseFirstCharConverter))]
    public required string FirstName { get; set; }
    [JsonConverter(typeof(UpperCaseFirstCharConverter))]    
    public required string LastName { get; set; }
    public required string State { get; set; }
    public DateOnly BirthDate { get; set; }
}

Code

public static void PropertiesExample()
{

    SpectreConsoleHelpers.PrintPink();

    string json =
        /*lang=json*/
        """
        [
          {
            "Id": 1,
            "FirstName": "jose",
            "LastName": "fernandez",
            "State": "CA",
            "BirthDate": "1985-01-01"
          },
          {
            "Id": 2,
            "FirstName": "Miguel",
            "LastName": "loPez",
            "State": "NY",
            "BirthDate": "1970-12-04"
          },
          {
            "Id": 3,
            "FirstName": "angel",
            "LastName": "PEREZ",
            "State": "TX",
            "BirthDate": "1980-09-11"
          }
        ]
        """;

    AnsiConsole.MarkupLine("[bold yellow]Original JSON:[/]");
    SpectreConsoleHelpers.PresentJson(json);

    Console.WriteLine("\n");

    AnsiConsole.MarkupLine("[bold blue]Deserialized and Serialized JSON (with capitalized names):[/]");
    var people = JsonSerializer.Deserialize<List<Customer>>(json, Options);
    var json1 = JsonSerializer.Serialize(people, Options);

    SpectreConsoleHelpers.PresentJson(json1);
}

private static JsonSerializerOptions Options => new() { WriteIndented = true };

Results

Console Source code ASP.NET Core Source code

Summary

The takeaway is that a developer plans properly before starting a task like the converter used here.

C# System.Text.Json

Visual Studio make it your own

Karen Payne — Thu, 17 Sep 2026 18:02:55 +0000

Introduction

Many developers will spend hours every day in Microsoft Visual Studio. Learn how to customize the Visual Studio environment and use features that make developers more productive.

💡 Customizing Visual Studio is like decorating a room with trinkets, lights, and paint.

Below is an exploration of known and off-the-beaten-path features for Microsoft Visual Studio 2026.

Visual Studio color themes

Visual Studio offers a variety of color themes to personalize your development environment for developers were light or dark themes are to restrictive. There are also the ability to create own theme or use a third party theme.

📘 Microsoft documentation

Under Tools ➡️ Theme

Cascadia Code font

Using this font changes how operators appear, as shown below.

See the following article for more details.

Window layouts

Visual Studio enables you to save as many as 10 custom window layouts and quickly switch among them.

Save/restore window layout is a fantastic feature where you can, for instance, have one layout for a laptop with no tool windows or collapsed tool windows and another layout for multiple or one large screen monitors were the tool windows are fully open.

📹 YouTube video

Arrange and Dock windows

This feature allows a developer to move a window like Solution Explorer from a floating window to a fixed/docked window.

📘 Microsoft documentation

Ultra-wide monitors

Benefits: not having to switch between several monitors, along with the ability to expand the Visual Studio window layout.

Microsoft blog post on Ultra-wide monitors

Developers with poor eyesight

The default font size can make it challenging to read details in menus and tool windows on these monitors.

💡 The fix

Under the Tools menu select Options
All Settings > Environment > Fonts and Color
Select Show setting for Environment
Select a font and font size

Standard

Changed example

Customize keyboard shortcuts

The keyboard shortcuts are listed here for default installation which a developer can change an entire set of shortcuts and individual shortcuts.

Available schemas (ReSharper appears only if installed)

To change a keyboard shortcut, find the command in the list and copy the command id and paste into "show commands containing" input. Assign a new shortcut, click the Assign button followed by click the OK button

Commands	Keyboard shortcuts	Command ID
Build selection	Ctrl+B (Visual Studio 2019)	Build.BuildSelection
Build solution	Ctrl+Shift+B	Build.BuildSolution
Cancel	Ctrl+Break	Build.Cancel
Compile	Ctrl+F7	Build.Compile
Run code analysis on solution	Alt+F11	Build.RunCodeAnalysisOnSolution

External Tools

You can call external tools from inside Visual Studio by using the Tools menu. A few default tools are available from the Tools menu, and you can customize it by adding your own commands.

Add your own external tools to the menu bar, see the following article.

Example

There is a need to examine a view files being altered or created in the application executable folder and perhaps reset or read a log file.

Open VS Code in the current project executable folder.

Command
C:\Users<username>\AppData\Local\Programs\Microsoft VS Code\Code.exe

Arguments

Optimizing toolbars for your workflow

Depending on a developer's needs, toolbar menu items can be added/removed. For instance, in the screenshot below two external commands have been added.

📹 Demonstration from Microsoft

📘 Microsoft documentation

Synchronize Visual Studio settings across multiple computers

When you sign in to Visual Studio on multiple computers using the same personalization account, your settings can be synchronized across the computers.

📘 Microsoft documentation

Environment settings

Visual Studio lets you export and import environment settings. Consider backing up the exported settings file to OneDrive or a private GitHub repository so that if the developer computer crashes, the setting files are available.

Visual Studio Extensions

Extensions are add-ons that allow you to customize and enhance your experience in Visual Studio by adding new features or integrating existing tools.

Several examples

Markdown Editor allows developers to create and modify Markdown files.
VSColorOutput64 can change the color of a line emitted to the output window based on specified rules. The rules consist of regular expressions. Rules map to classifications which in turn map to colors.

💡 Build your own extensions

Accessibility tips and tricks

Visual Studio has built-in accessibility features that are compatible with screen readers and other assistive technologies.

Optimize Visual Studio performance

Visual Studio may run slowly due to insufficient RAM; consider using at least 32 GB. Antivirus software can also slow it down; you can fix this by excluding Visual Studio.

Another reason is a newly installed Visual extension, which can cause performance issues. If this is the case, a developer can learn by viewing Performance Manager from the Help menu.

📘 Performance tips and tricks (Microsoft)

Summary

The information provided can help many developers feel comfortable working with Visual Studio for extended periods.

Visual Studio tips 1
Visual Studio tips 2
Visual Studio tip 3
Essential Visual Studio Extensions
Visual Studio unknown keyboard shortcuts
Customize startup

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

DEV Community: Karen Payne

C# File globbing tip

Introduction

C# Singleton basics

Introduction

Key Implementation Rules

Example 1

Dependency Injection version

Example 2

Example 3

Example 4

Combined Serilog and EF Core Logging to the Same File in ASP .NET Core

Introduction

Required NuGet packages

Serilog configurations

Start writing code

Log file for above

Provided sample code

See also

Summary'

C# basic JsonConverter tip

Introduction

Sample converter

Example usage

Summary

Related

Visual Studio make it your own

Introduction

Visual Studio color themes

Cascadia Code font

Window layouts

Arrange and Dock windows

Ultra-wide monitors

Developers with poor eyesight

Customize keyboard shortcuts

External Tools

Optimizing toolbars for your workflow

Synchronize Visual Studio settings across multiple computers

Environment settings

Visual Studio Extensions

Several examples

Accessibility tips and tricks

Optimize Visual Studio performance

Summary

Related articles

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