DEV Community: Karen Payne

C# record with expression

Karen Payne — Fri, 30 Oct 2026 22:25:15 +0000

Introduction

The with expression creates a new object with modified properties

Example 1

Add a new Product to a list, then use the CategoryId value when adding a second item to the list with the with expression.

Model

public record Product(int Id, string Name, int CategoryId)
{
    public int Id { get; set; } = Id;
    public string Name { get; set; } = Name;
    public int CategoryId { get; set; } = CategoryId;
}

List<Product> products = [];

Product product = new(1, "Football", 2);
products.Add(product);
products.Add(product with { Id = 2, Name = "Golf" });

foreach (var (id, name, categoryId) in products)
{
    Console.WriteLine($"{id,-3}: {name,-20}{categoryId}");
}

Example 2

An extension of Example 1 that uses a Dictionary to add data.

var (products, categories) = MockedData.GetProductsAndCategories();

Dictionary<int, string> dictionary = new()
{
    [2] = "Golf",
    [3] = "Formula 1 racing",
    [4] = "Soccer"
};

Product product = new(1, "Football", 2);
products.Add(product);

foreach (var (key, value) in dictionary)
{
    products.Add(product with { Id = key, Name = value });
}

var joined =
    products.Join(
        categories,
        p => p.CategoryId,
        c => c.Id,
        (p, c) => new
        {
            ProductId = p.Id,
            ProductName = p.Name,
            CategoryName = c.Name
        });

foreach (var item in joined)
{
    Console.WriteLine($"{item.ProductId,-3}: {item.ProductName,-20}{item.CategoryName}");
}

Real life

Imagine a file service that reads files by file name, which determines the product category. This would be a good case for the with expression.

Source code

Adding a Razor Page with Entity Framework Core to an ASP.NET Core Project

Karen Payne — Sun, 25 Oct 2026 02:23:11 +0000

Introduction

Learn how to add a Razor Page that reads and writes data using Entity Framework Core (EF Core), in this case from an existing SQL Server database reverse-engineered using the EF Power Tools Visual Studio extension.

Although Visual Studio does a decent job of adding these pages, several improvements are recommended and will be covered with code samples.

For displaying lists, developers not interested in meeting WCAG AA standards should make several improvements, while developers wanting to comply with WCAG AA should move from tables to divs.

Source code

Objective

To improve responsiveness of generated pages, replace CRUD links with Bootstrap icons and replace the delete page with a Bootstrap dialog. The main change is moving from a table-centric model to using a DIV model with Bootstrap styles.

Setup

Create a new ASP.NET Core project rather than a current project
Create a DbContext and models to access your data.
Make sure there is a decent amount of data in the database to work with
In addition to your EF Core data provider, add the following NuGet packages.
- Microsoft.EntityFrameworkCore.Tools
- Microsoft.VisualStudio.Web.CodeGeneration.Design

Add list page

From Solution Explorer, right-click on the Pages folder
Select Add, Razor page
From the dialog select option 2, click Add.

Next dialog: populate page name, select template index, select model, and DbContext.

Click Add
Code is then generated.
Add a link to the page in _Layout.cshtml
Run the project and something like shown below (links will not work until those pages are created as done with the current page)

List page modifications

Change links

The first modification changes the following links to Bootstrap-icon-styled links. This is because users tend to associate images better than text.

From Solution Explorer
Right-click, select Add
Client library, select Bootstrap icons and click Install

Add the following to the head section of _Layout.cshtml

<link href="~/lib/bootstrap-icons/font/bootstrap-icons.min.css" rel="stylesheet" />

In the list page replace

<td>
    <a asp-page="./Edit" asp-route-id="@item.Id">Edit</a> |
    <a asp-page="./Details" asp-route-id="@item.Id">Details</a> |
    <a asp-page="./Delete" asp-route-id="@item.Id">Delete</a>
</td>

With

<td>
    @* Added by Karen *@
    <a asp-page="./CustomerEditPage"
       asp-route-id="@item.Id"
       asp-route-returnUrl="@($"{Request.Path}{Request.QueryString}")"
       class="btn btn-sm btn-outline-primary"
       title="Edit">
        <i class="bi bi-pencil"></i>
    </a>
    <a asp-page="./Details" asp-route-id="@item.Id" class="btn btn-sm btn-outline-dark" title="Details">
        <i class="bi bi-eye"></i>
    </a>

    <button type="button"
            class="btn btn-sm btn-outline-danger"
            title="Delete"
            aria-label="Delete @item.Company"
            data-bs-toggle="modal"
            data-bs-target="#deleteModal"
            data-customer-id="@item.Id"
            data-customer-name="@item.Company">
        <i class="bi bi-trash"></i>
    </button>

</td>

Customize delete action

The standard method is to scaffold a delete page that, when clicked from the list page, asks to confirm removal of the current record.

A better option is to use a Bootstrap dialog. The following has the Cancel button as the default.

The trigger

Dialog

<div class="modal fade"
     id="deleteModal"
     tabindex="-1"
     aria-labelledby="deleteModalLabel"
     aria-hidden="true">

    <div class="modal-dialog modal-dialog-centered">
        <div class="modal-content">

            <div class="modal-header">
                <h5 class="modal-title" id="deleteModalLabel">
                    Confirm Delete
                </h5>
                <button type="button"
                        class="btn-close"
                        data-bs-dismiss="modal"
                        aria-label="Close">
                </button>
            </div>

            <div class="modal-body">
                <p>Are you sure you want to delete this customer?</p>
                <p class="fw-bold" id="customerName"></p>
                <p class="text-danger mb-0">
                    This action cannot be undone.
                </p>
            </div>

            <div class="modal-footer">
                <button type="button"
                        id="cancelDeleteButton"
                        class="btn btn-secondary"
                        data-bs-dismiss="modal">
                    Cancel
                </button>

                <form method="post" asp-page-handler="Delete">
                    <input type="hidden"
                           name="id"
                           id="deleteCustomerId" />

                    <button type="submit" class="btn btn-danger">
                        <i class="bi bi-trash me-1"></i>
                        Delete
                    </button>
                </form>
            </div>

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

<script type="text/javascript">

    const deleteModal = document.getElementById("deleteModal");

    deleteModal.addEventListener("show.bs.modal", function(event) {

        const button = event.relatedTarget;

        document.getElementById("deleteCustomerId").value =
            button.getAttribute("data-customer-id");

        document.getElementById("customerName").textContent =
            button.getAttribute("data-customer-name");

    });

    deleteModal.addEventListener("shown.bs.modal", function() {
        document.getElementById("cancelDeleteButton").focus();
    });
</script>

Backend database code

public async Task<IActionResult> OnPostDeleteAsync(int id)
{
    var customer = await context.Customers.FindAsync(id);

    if (customer is null)
    {
        return NotFound();
    }

    context.Customers.Remove(customer);
    await context.SaveChangesAsync();

    return RedirectToPage();
}

Edit/Create pages

Is created the same as the list page.

In the sample code FluentValidation is used to validate entries.

#nullable disable
using FluentValidation;
using TablesVsDivsSample1App.Models;

namespace TablesVsDivsSample1App.Validators;

/// <summary>
/// Provides validation rules for the <see cref="Customers"/> model.
/// </summary>
public class CustomersValidator : AbstractValidator<Customers>
{
    public CustomersValidator()
    {
        RuleFor(x => x.Company).NotEmpty();
        RuleFor(x => x.ContactType).NotEmpty();
        RuleFor(x => x.ContactName).NotEmpty();
        RuleFor(x => x.Country).NotEmpty();
        RuleFor(x => x.JoinDate)
            .GreaterThanOrEqualTo(new DateOnly(1900, 1, 1))
            .WithMessage("Join Date must be on or after 01/01/1900.")
            .LessThanOrEqualTo(DateOnly.FromDateTime(DateTime.Today))
            .WithMessage($"Join Date must be on or before {DateOnly.FromDateTime(DateTime.Today):MM/dd/yyyy}.");

    }
}

Tables to DIV responsive design

Using DIV elements with Bootstrap classes provides better responsiveness than using tables.

To move from tables to DIV elements with Bootstrap classes, easily attach the stock list page to a ChatGPT chat and tell it to use DIV elements with Bootstrap classes. Follow this up with the icon buttons and delete dialog.

Source code

Page	Description
StandardView	Standard scaffolded view
UsingTablesPage	Modified view using tables
UsingDivsPage	Modified view using divs

Spectre.Console Tree widget

Karen Payne — Mon, 19 Oct 2026 01:44:34 +0000

Introduction

Learn how to use Spectre.Console Tree widget.

The Tree widget visualizes hierarchical data structures with parent-child relationships using Unicode tree characters.

💡 Tree API

Code samples

Are fully documented.

Base example

public static void Example1()
{
    // Create a tree with a root node
    var tree = new Tree("[deeppink3 bold]root node[/]")
        .Guide(TreeGuide.Line);

    // Add child node to the root node
    TreeNode types = tree.AddNode("[yellow]Types[/] [dim]Child 1[/]");

    // Add grandchild nodes to the child node
    types.AddNode("[green]String[/] [dim]Grandchild 1.1[/]");
    types.AddNode("[green]Int32[/] [dim]Grandchild 1.2[/]");
    types.AddNode("[green]Boolean[/] [dim]Grandchild 1.3[/]");


    // Add child node to the root node
    TreeNode collection = tree.AddNode("[blue]Collections[/] [dim]Child 1[/]");

    // Add grandchild nodes to the child node
    collection.AddNode("[green]List<String>[/] [dim]Grandchild 1.1[/]");
    collection.AddNode("[green]Dictionary<String,Int32>[/] [dim]Grandchild 1.2[/]");

    AnsiConsole.Write(tree);
}

First create a new Tree with a colorized label (Initializes a new instance of the Tree class.) and specify line type via Guide (Gets or sets the tree guide lines).
Create child nodes off the tree
- Create child nodes (Grandchild)
Use AnsiConsole.Write(tree) to display the tree

Using a Dictionary

This example uses a Dictionary<string, string[]>

public static void Example2()
{
    var fileSystem = new Dictionary<string, string[]>
    {
        ["Configuration"] = ["appsettings.json", "secrets.json"],
        ["Source Code"] = ["Main.cs", "Helper.cs", "Utilities.cs"],
        ["Documentation"] = ["README.md", "CHANGELOG.md"],
    };

    var tree = new Tree("[green bold]Application[/]");

    foreach (var (folder, files) in fileSystem)
    {

        var folderNode = tree.AddNode($"[yellow]{folder}[/]");

        foreach (var file in files)
        {
            folderNode.AddNode($"[grey]{file}[/]");
        }

    }

    AnsiConsole.Write(tree);
}

Dictionary keys represent child nodes of the tree node
- Dictionary values represent Grandchild nodes

Using JSON and Grouping

The basics apply as per above, a tree is created followed by child nodes by IEnumerable<IGrouping<string, Book>>

Model

public class Book
{
    public int Id { get; set; }
    public string Title { get; set; }
    public decimal? Price { get; set; }
}

internal class BookOperations
{
    public static void BooksGroupings()
    {

        SpectreConsoleHelpers.PrintPink();

        List<Book> books = JsonSerializer.Deserialize<List<Book>>(Json())!;

        IEnumerable<IGrouping<string, Book>> grouped = GroupBooksByPriceRange(books);

        var tree = new Tree("[bold yellow]Books by Price Range[/]");

        foreach (var (price, booksGroup) in grouped.Select(group
                     => (group.Key, group)))
        {
            var priceNode = tree.AddNode($"[bold cyan]{Markup.Escape(price)}[/]");

            foreach (var book in booksGroup)
            {
                priceNode.AddNode(
                    $"[green]Id:[/] {book.Id}, " +
                    $"[green]Title:[/] {Markup.Escape(book.Title)}, " +
                    $"[green]Price:[/] {book.Price:C}");
            }
        }

        AnsiConsole.Write(tree);
    }


    private static string Json()
    {
        var json =
            /* lang=json*/
            """
            [
              {
                "Id": 1,
                "Title": "Learn EF Core",
                "Price": 19.0
              },
              {
                "Id": 2,
                "Title": "C# Basics",
                "Price": 18.0
              },
              {
                "Id": 3,
                "Title": "ASP.NET Core advance",
                "Price": 30.0
              },
              {
                "Id": 4,
                "Title": "VB.NET To C#",
                "Price": 9.0
              },
              {
                "Id": 5,
                "Title": "Basic Azure",
                "Price": 59.0
              }
            ]
            """;

        return json;

    }

   private static IEnumerable<IGrouping<string, Book>> GroupBooksByPriceRange(List<Book> books)
    => books.GroupBy(b => b switch
    {
        { Price: < 10 } => "Under $10",
        { Price: >= 10 and < 20 } => "$10 to $19",
        { Price: >= 20 and < 30 } => "$20 to $29",
        { Price: >= 30 } => "$30 and above",
        _ => "Unknown"
    });
}

EF Core example

This example uses one table to show relations for Employees and Managers.

internal class EmployeeOperations
{
    public static void ReportsToManager()
    {

        PrintPink();

        using var context = new Context();

        var table = CreateViewTable();

        List<Employees> employees = [.. context.Employees];

        List<IGrouping<int?, Employees>> groupedData = employees
            .Where(employee => employee.ReportsTo.HasValue)
            .OrderBy(employee => employee.LastName)
            .GroupBy(employee => employee.ReportsTo)
            .ToList();

        List<Manager> managers = [];

        foreach (var group in groupedData)
        {

            Manager manager = new()
            {
                Employee = employees.Find(employee => employee.EmployeeID == group.Key.Value)
            };

            foreach (Employees groupedItem in group)
            {
                manager.Workers.Add(groupedItem);
            }

            managers.Add(manager);

        }

        managers = managers
            .OrderBy(employee => employee.Employee.LastName)
            .ToList();

        var root = new Tree("[white][B]Employees[/][/]");

        foreach (Manager manager in managers)
        {
            var currentNode = root.AddNode($"[Chartreuse1]{manager.Employee.FullName}[/] [Gray37](Manager)[/]");

            foreach (var worker in manager.Workers)
            {
                /*
                 * Here a worker can also be a manager, so we check if the worker is also listed as a manager
                 * in our managers list. If they are, we format their name differently to indicate that
                 * they are both a worker and a manager.
                 */
                if (managers.Any(m => m.Employee.EmployeeID == worker.EmployeeID))
                {
                    currentNode.AddNode($"{worker.FullName} <a href="Manager">Gray37</a>[/]");
                }
                else
                {
                    currentNode.AddNode(worker.FullName);
                }

            }
        }

        AnsiConsole.Write(root);

        Console.WriteLine();

    }

    private static Table CreateViewTable() =>
        new Table()
            .Border(TableBorder.Square)
            .BorderColor(Color.Grey100)
            .Alignment(Justify.Center)
            .Title("~[white on blue][B]Employees[/][/]~")
            .AddColumn(new TableColumn("[u]Manager[/]"))
            .AddColumn(new TableColumn("[u]Workers[/]"));
}

Recursive directory tree with Collapse

Iterates a directory and collapses specific subfolders (obj and bin).

public static class DirectoryTree
{
    public static void Display(string path)
    {
        if (!Directory.Exists(path))
        {
            AnsiConsole.MarkupLine("[red]Directory does not exist.[/]");
            return;
        }

        DirectoryInfo root = new(path);

        Tree tree = new($"[bold yellow]{Markup.Escape(root.FullName)}[/]");

        AddDirectory(root, tree);

        AnsiConsole.Write(tree);
    }


    private static void AddDirectory(DirectoryInfo directory, IHasTreeNodes parent)
    {
        bool isBinObj = directory.Name.Equals("obj", StringComparison.OrdinalIgnoreCase) || 
                     directory.Name.Equals("bin", StringComparison.OrdinalIgnoreCase);
        try
        {
            foreach (DirectoryInfo subdirectory in directory.GetDirectories().OrderBy(d => d.Name))
            {
                TreeNode node = parent.AddNode($"[blue]📁 {Markup.Escape(subdirectory.Name)}[/]");

                AddDirectory(subdirectory, node);
                if (isBinObj)
                {
                    node.Collapse();
                }
            }

            if (!isBinObj)
            {
                foreach (FileInfo file in directory.GetFiles().OrderBy(f => f.Name))
                {
                    parent.AddNode($"[green]📄 {Markup.Escape(file.Name)}[/]");
                }

            }


        }
        catch (UnauthorizedAccessException uae)
        {
            parent.AddNode("[red]Access denied[/]");
            Log.Error(uae, "Access denied to directory: {Directory}", directory.FullName);
        }
        catch (IOException ex)
        {
            parent.AddNode($"[red]{Markup.Escape(ex.Message)}[/]");
            Log.Error(ex, "IO exception occurred while accessing directory: {Directory}", directory.FullName);
        }
    }
}

Main Source code EF Core Source code

Summary

The provided code samples make it easy to create trees.

C# IFormattable Interface

Karen Payne — Tue, 13 Oct 2026 22:24:48 +0000

Introduction

IFormattable Interface provides functionality to format the value of an object into a string representation. A simple example using a record demonstrates how to display different properties, along with formatting and calculations.

"A" or "Age" => $"{BirthDay.GetAge()}" does a calculation
"B" => $"{BirthDay:O}" does special date formatting

Source code

Usage

Output

Applies to

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	1.1, 2.0, 3.0, 3.5, 4.0, 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

Summary

To dive deeper, read Microsoft documentation

Note that the content is intentionally short to make it easier to learn.

Seasoned developer advice

Karen Payne — Wed, 07 Oct 2026 19:35:52 +0000

Introduction

Learn about developer tips from my thirty-plus years of developing enterprise solutions and various services and utilities.

Project managers

If they are in the budget, hire several. Every successful project I have worked on was managed by a project manager; without a project manager, there was more workload for the lead developer, who were not always the best in a project manager role.

Daily team meetings

Hold 30-minute meetings to review available resources, ongoing project status, and ticket status.

Daily project standup meetings

30-minute meetings with business Subject-Matter Expert (SME) and developers to review project progress. These are daily because after the SME reviews current progress, changes may be needed to business rules, the user interface, or databases. Best to capture changes sooner rather than later.

Core code

As a team of developers or a single developer matures code around similar business processes, consider breaking out common code into class projects coupled with test projects, then creating secure local NuGet packages.

Logging

If an application is being used by users in an organization, consider using a dedicated server for logging; for single-user applications, store logs under the executable folder.

Log all exceptions that reveal opportunities to change the code; in some cases, this can eliminate the need for try-catch statements by using assertions.

Code documentation

There can never be enough code documentation. Many developers are against documenting code; my advice to them is to write documentation and collapse it.

See also AI section

Code refactoring

For application and class projects, create tickets and assign a project manager. A ticket should point to a backlog of affected project(s). See code review section below.

Code reviews

Once a task is completed in a team environment, it should undergo a peer code review, then a senior developer review. For both reviews, all tests for the task must pass and not break existing code before committing changes. If even one test fails, a developer must fix the issue and repeat the reviews.

Modernization

In general, plan framework upgrades for production applications and core class projects.

Training

Without continual learning, from self-training to using paid services like Pluralsight, developers stagnate. Devs need to devote several hours a week to honing their skill set.

Chameleon

To succeed, be willing to learn other programming languages, CSS, and database syntax. For instance, to be hired for a C# position, I needed to be willing to code with ColdFusion.

AI

Don’t pick one tool and one model; invest in multiple tools. Recommend JetBrains AI Assistant for writing documentation.

Developer health

Taking 10-minute breaks can do wonders for your mind and eyes. Scheduled coffee breaks that involve walking with team members once a week are both healthy and great for keeping in touch with your team.

Tool set

The tools developers select range from VS Code and Visual Studio to Rider. My tool set has always been Visual Studio with ReSharper because they suit my needs an have always been able do 95 percent of my work in Visual Studio.

Code smarts

The longer a developer codes and matures they can see possibilities

Example (kept simple) which is limiting in regards to the output

public static class GenericIterators
{
    public static void Iterate<T>(this IEnumerable<T> values, Func<T, string> formatter)
    {
        foreach (var (index, item) in values.Index())
            Console.WriteLine($"{index,-5}{formatter(item)}");
    }
}

With experience

 public static class GenericIterators
{
    public static void Iterate<T>(this IEnumerable<T> values, Func<T, string> formatter, Action<int, string> action)
    {
        foreach (var (index, item) in values.Index())
            action(index, formatter(item));
    }
}

Allows

string[] names =
[
    "Karen",
    "mARY",
    "John"
];

names.Iterate(name => name.CapitalizeFirstLetter(), 
    (index, value) => Console.WriteLine($"{index,-5}{value}"));

Console.WriteLine();

names.Iterate(name => name.CapitalizeFirstLetter(),
    (index, value) => Debug.WriteLine($"{index,-5}{value}"));

names.Iterate(name => name.CapitalizeFirstLetter(), 
    (index, value) => AnsiConsole.MarkupLine($"[cyan]{index,-5}[/][hotpink2]{value}[/]"));

Source code

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.

DEV Community: Karen Payne

C# record with expression

Introduction

Example 1

Example 2

Real life

Adding a Razor Page with Entity Framework Core to an ASP.NET Core Project

Introduction

Objective

Setup

Add list page

List page modifications

Change links

Customize delete action

Edit/Create pages

Tables to DIV responsive design

Spectre.Console Tree widget

Introduction

Code samples

Base example

Using a Dictionary

Using JSON and Grouping

EF Core example

Recursive directory tree with Collapse

Summary

C# IFormattable Interface

Introduction

Applies to

Summary

Seasoned developer advice

Introduction

Project managers

Daily team meetings

Daily project standup meetings

Core code

Logging

Code documentation

Code refactoring

Code reviews

Modernization

Training

Chameleon

AI

Developer health

Tool set

Code smarts

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