DEV Community: Karen Payne

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.

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

DEV Community: Karen Payne

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

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