Consolelogboekopmaak

In .NET 5 is ondersteuning voor aangepaste opmaak toegevoegd aan consolelogboeken in de Microsoft.Extensions.Logging.Console naamruimte. Er zijn drie vooraf gedefinieerde opmaakopties beschikbaar: Simple, Systemden Json.

Belangrijk

Voorheen was de ConsoleLoggerFormat opsomming toegestaan voor het selecteren van de gewenste logboekindeling, die door mensen kan worden gelezen, of Defaultéén regel die ook wel bekend staat als Systemd. Deze zijn echter niet aanpasbaar en zijn nu afgeschaft.

In dit artikel leert u meer over consolelogboekindelingen. De voorbeeldbroncode laat zien hoe u het volgende kunt doen:

• Een nieuwe formatter registreren
• Selecteer een geregistreerde formatter die u wilt gebruiken
  • Via code of configuratie
• Een aangepaste formatter implementeren
  • Configuratie bijwerken via IOptionsMonitor<TOptions>
  • Aangepaste kleuropmaak inschakelen

Tip

Alle voorbeeldbroncode voor logboekregistratie is beschikbaar in de voorbeeldenbrowser om te downloaden. Zie Bladeren in codevoorbeelden: Logboekregistratie in .NET voor meer informatie.

Formatter registreren

De Console logboekregistratieprovider heeft verschillende vooraf gedefinieerde formatters en biedt de mogelijkheid om uw eigen aangepaste indeling te maken. Als u een van de beschikbare formatters wilt registreren, gebruikt u de bijbehorende Add{Type}Console extensiemethode:

Beschikbare typen	Methode voor het registreren van type
ConsoleFormatterNames.Json	ConsoleLoggerExtensions.AddJsonConsole
ConsoleFormatterNames.Simple	ConsoleLoggerExtensions.AddSimpleConsole
ConsoleFormatterNames.Systemd	ConsoleLoggerExtensions.AddSystemdConsole

Eenvoudig

Als u de Simple console formatter wilt gebruiken, moet u deze registreren bij AddSimpleConsole:

using Microsoft.Extensions.Logging;

using ILoggerFactory loggerFactory =
    LoggerFactory.Create(builder =>
        builder.AddSimpleConsole(options =>
        {
            options.IncludeScopes = true;
            options.SingleLine = true;
            options.TimestampFormat = "HH:mm:ss ";
        }));

ILogger<Program> logger = loggerFactory.CreateLogger<Program>();
using (logger.BeginScope("[scope is enabled]"))
{
    logger.LogInformation("Hello World!");
    logger.LogInformation("Logs contain timestamp and log level.");
    logger.LogInformation("Each log message is fit in a single line.");
}

In de voorgaande voorbeeldbroncode is de ConsoleFormatterNames.Simple formatter geregistreerd. Het biedt logboeken de mogelijkheid om niet alleen informatie in te pakken, zoals tijd en logboekniveau in elk logboekbericht, maar biedt ook ansi-kleuren insluiten en inspringen van berichten.

Wanneer deze voorbeeld-app wordt uitgevoerd, worden de logboekberichten opgemaakt zoals hieronder wordt weergegeven:

Systemd

De ConsoleFormatterNames.Systemd consolelogger:

• Maakt gebruik van de indeling en ernst van het logboekniveau Syslog
• Berichten met kleuren worden niet opgemaakt
• Berichten altijd op één regel logboeken

Dit is meestal handig voor containers, die vaak gebruikmaken van Systemd consolelogboekregistratie. Met .NET 5 maakt de Simple consolelogger ook een compacte versie mogelijk die zich op één regel aanmeldt en maakt het ook mogelijk om kleuren uit te schakelen, zoals wordt weergegeven in een eerder voorbeeld.

using Microsoft.Extensions.Logging;

using ILoggerFactory loggerFactory =
    LoggerFactory.Create(builder =>
        builder.AddSystemdConsole(options =>
        {
            options.IncludeScopes = true;
            options.TimestampFormat = "HH:mm:ss ";
        }));

ILogger<Program> logger = loggerFactory.CreateLogger<Program>();
using (logger.BeginScope("[scope is enabled]"))
{
    logger.LogInformation("Hello World!");
    logger.LogInformation("Logs contain timestamp and log level.");
    logger.LogInformation("Systemd console logs never provide color options.");
    logger.LogInformation("Systemd console logs always appear in a single line.");
}

In het voorbeeld wordt uitvoer geproduceerd die vergelijkbaar is met de volgende logboekberichten:

JSON

Als u logboeken in een JSON-indeling wilt schrijven, wordt de Json consoleopmaak gebruikt. De voorbeeldbroncode laat zien hoe een ASP.NET Core-app deze kan registreren. Maak met behulp van de webapp sjabloon een nieuwe ASP.NET Core-app met de nieuwe dotnet-opdracht:

dotnet new webapp -o Console.ExampleFormatters.Json

Wanneer u de app uitvoert met behulp van de sjablooncode, krijgt u de standaardlogboekindeling hieronder:

info: Console.ExampleFormatters.Json.Startup[0]
      Hello .NET friends!
info: Microsoft.Hosting.Lifetime[14]
      Now listening on: https://localhost:5001
info: Microsoft.Hosting.Lifetime[14]
      Now listening on: http://localhost:5000
info: Microsoft.Hosting.Lifetime[0]
      Application started. Press Ctrl+C to shut down.
info: Microsoft.Hosting.Lifetime[0]
      Hosting environment: Development
info: Microsoft.Hosting.Lifetime[0]
      Content root path: .\snippets\logging\console-formatter-json

Standaard is de indeling van het Simple consolelogboek geselecteerd met de standaardconfiguratie. U wijzigt dit door in de Program.cs aan te roepenAddJsonConsole:

using System.Text.Json;

HostApplicationBuilder builder = Host.CreateApplicationBuilder(args);

builder.Logging.AddJsonConsole(options =>
{
    options.IncludeScopes = false;
    options.TimestampFormat = "HH:mm:ss ";
    options.JsonWriterOptions = new JsonWriterOptions
    {
        Indented = true
    };
});

using IHost host = builder.Build();

var logger =
    host.Services
        .GetRequiredService<ILoggerFactory>()
        .CreateLogger<Program>();

logger.LogInformation("Hello .NET friends!");

await host.RunAsync();

U kunt dit ook configureren met behulp van logboekregistratieconfiguratie, zoals die in het appsettings.json-bestand :

{
    "Logging": {
        "LogLevel": {
            "Default": "Information",
            "Microsoft": "Warning",
            "Microsoft.Hosting.Lifetime": "Information"
        },
        "Console": {
            "LogLevel": {
                "Default": "Information",
                "Microsoft": "Warning",
                "Microsoft.Hosting.Lifetime": "Information"
            },
            "FormatterName": "json",
            "FormatterOptions": {
                "SingleLine": true,
                "IncludeScopes": true,
                "TimestampFormat": "HH:mm:ss ",
                "UseUtcTimestamp": true,
                "JsonWriterOptions": {
                    "Indented": true
                }
            }
        }
    },
    "AllowedHosts": "*"
}

Voer de app opnieuw uit, met de bovenstaande wijziging wordt het logboekbericht nu opgemaakt als JSON:

{
  "Timestamp": "02:28:19 ",
  "EventId": 0,
  "LogLevel": "Information",
  "Category": "Console.ExampleFormatters.Json.Startup",
  "Message": "Hello .NET friends!",
  "State": {
    "Message": "Hello .NET friends!",
    "{OriginalFormat}": "Hello .NET friends!"
  }
}
{
  "Timestamp": "02:28:21 ",
  "EventId": 14,
  "LogLevel": "Information",
  "Category": "Microsoft.Hosting.Lifetime",
  "Message": "Now listening on: https://localhost:5001",
  "State": {
    "Message": "Now listening on: https://localhost:5001",
    "address": "https://localhost:5001",
    "{OriginalFormat}": "Now listening on: {address}"
  }
}
{
  "Timestamp": "02:28:21 ",
  "EventId": 14,
  "LogLevel": "Information",
  "Category": "Microsoft.Hosting.Lifetime",
  "Message": "Now listening on: http://localhost:5000",
  "State": {
    "Message": "Now listening on: http://localhost:5000",
    "address": "http://localhost:5000",
    "{OriginalFormat}": "Now listening on: {address}"
  }
}
{
  "Timestamp": "02:28:21 ",
  "EventId": 0,
  "LogLevel": "Information",
  "Category": "Microsoft.Hosting.Lifetime",
  "Message": "Application started. Press Ctrl\u002BC to shut down.",
  "State": {
    "Message": "Application started. Press Ctrl\u002BC to shut down.",
    "{OriginalFormat}": "Application started. Press Ctrl\u002BC to shut down."
  }
}
{
  "Timestamp": "02:28:21 ",
  "EventId": 0,
  "LogLevel": "Information",
  "Category": "Microsoft.Hosting.Lifetime",
  "Message": "Hosting environment: Development",
  "State": {
    "Message": "Hosting environment: Development",
    "envName": "Development",
    "{OriginalFormat}": "Hosting environment: {envName}"
  }
}
{
  "Timestamp": "02:28:21 ",
  "EventId": 0,
  "LogLevel": "Information",
  "Category": "Microsoft.Hosting.Lifetime",
  "Message": "Content root path: .\\snippets\\logging\\console-formatter-json",
  "State": {
    "Message": "Content root path: .\\snippets\\logging\\console-formatter-json",
    "contentRoot": ".\\snippets\\logging\\console-formatter-json",
    "{OriginalFormat}": "Content root path: {contentRoot}"
  }
}

Tip

De Json console-formatter registreert standaard elk bericht op één regel. Om deze beter leesbaar te maken tijdens het configureren van de formatter, ingesteld JsonWriterOptions.Indented op true.

Let op

Wanneer u de Json-console formatter gebruikt, geeft u geen logboekberichten door die al zijn geserialiseerd als JSON. De infrastructuur voor logboekregistratie zelf beheert de serialisatie van logboekberichten, dus als u een logboekbericht doorgeeft dat al is geserialiseerd, wordt deze dubbel geserialiseerd, waardoor onjuiste uitvoer wordt veroorzaakt.

Formatter instellen met configuratie

De vorige voorbeelden hebben laten zien hoe u programmatisch een formatter registreert. U kunt dit ook doen met configuratie. Als u het appsettings.json-bestand bijwerkt in plaats van in het Program.cs-bestand aan te roepenConfigureLogging, kunt u hetzelfde resultaat krijgen. Het bijgewerkte appsettings.json bestand configureert de formatter als volgt:

{
    "Logging": {
        "LogLevel": {
            "Default": "Information",
            "Microsoft": "Warning",
            "Microsoft.Hosting.Lifetime": "Information"
        },
        "Console": {
            "LogLevel": {
                "Default": "Information",
                "Microsoft": "Warning",
                "Microsoft.Hosting.Lifetime": "Information"
            },
            "FormatterName": "json",
            "FormatterOptions": {
                "SingleLine": true,
                "IncludeScopes": true,
                "TimestampFormat": "HH:mm:ss ",
                "UseUtcTimestamp": true,
                "JsonWriterOptions": {
                    "Indented": true
                }
            }
        }
    },
    "AllowedHosts": "*"
}

De twee sleutelwaarden die moeten worden ingesteld, zijn "FormatterName" en "FormatterOptions". Als een formatter met de waarde die is ingesteld "FormatterName" al is geregistreerd, wordt die formatter geselecteerd en kunnen de eigenschappen ervan worden geconfigureerd zolang ze als sleutel in het "FormatterOptions" knooppunt worden opgegeven. De vooraf gedefinieerde formatternamen zijn gereserveerd onder ConsoleFormatterNames:

• ConsoleFormatterNames.Json
• ConsoleFormatterNames.Simple
• ConsoleFormatterNames.Systemd

Een aangepaste formatter implementeren

Als u een aangepaste indeling wilt implementeren, moet u het volgende doen:

• Maak een subklasse van ConsoleFormatter, dit vertegenwoordigt uw aangepaste formatter
• Uw aangepaste notatie registreren bij
  • ConsoleLoggerExtensions.AddConsole
  • ConsoleLoggerExtensions.AddConsoleFormatter<TFormatter,TOptions>(ILoggingBuilder, Action<TOptions>)

Maak een extensiemethode om dit voor u af te handelen:

using Microsoft.Extensions.Logging;

namespace Console.ExampleFormatters.Custom;

public static class ConsoleLoggerExtensions
{
    public static ILoggingBuilder AddCustomFormatter(
        this ILoggingBuilder builder,
        Action<CustomOptions> configure) =>
        builder.AddConsole(options => options.FormatterName = "customName")
            .AddConsoleFormatter<CustomFormatter, CustomOptions>(configure);
}

De CustomOptions waarden zijn als volgt gedefinieerd:

using Microsoft.Extensions.Logging.Console;

namespace Console.ExampleFormatters.Custom;

public sealed class CustomOptions : ConsoleFormatterOptions
{
    public string? CustomPrefix { get; set; }
}

In de voorgaande code zijn de opties een subklasse van ConsoleFormatterOptions.

De AddConsoleFormatter API:

• Registreert een subklasse van ConsoleFormatter
• Hiermee wordt de configuratie verwerkt:
  • Gebruikt een wijzigingstoken om updates te synchroniseren, op basis van het optiespatroon en de IOptionsMonitor-interface

using Console.ExampleFormatters.Custom;
using Microsoft.Extensions.Logging;

using ILoggerFactory loggerFactory =
    LoggerFactory.Create(builder =>
        builder.AddCustomFormatter(options =>
            options.CustomPrefix = " ~~~~~ "));

ILogger<Program> logger = loggerFactory.CreateLogger<Program>();
using (logger.BeginScope("TODO: Add logic to enable scopes"))
{
    logger.LogInformation("Hello World!");
    logger.LogInformation("TODO: Add logic to enable timestamp and log level info.");
}

Definieer een CustomFormatter subklasse van ConsoleFormatter:

using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Logging.Abstractions;
using Microsoft.Extensions.Logging.Console;
using Microsoft.Extensions.Options;

namespace Console.ExampleFormatters.Custom;

public sealed class CustomFormatter : ConsoleFormatter, IDisposable
{
    private readonly IDisposable? _optionsReloadToken;
    private CustomOptions _formatterOptions;

    public CustomFormatter(IOptionsMonitor<CustomOptions> options)
        // Case insensitive
        : base("customName") =>
        (_optionsReloadToken, _formatterOptions) =
            (options.OnChange(ReloadLoggerOptions), options.CurrentValue);

    private void ReloadLoggerOptions(CustomOptions options) =>
        _formatterOptions = options;

    public override void Write<TState>(
        in LogEntry<TState> logEntry,
        IExternalScopeProvider? scopeProvider,
        TextWriter textWriter)
    {
        string? message =
            logEntry.Formatter?.Invoke(
                logEntry.State, logEntry.Exception);

        if (message is null)
        {
            return;
        }

        CustomLogicGoesHere(textWriter);
        textWriter.WriteLine(message);
    }

    private void CustomLogicGoesHere(TextWriter textWriter)
    {
        textWriter.Write(_formatterOptions.CustomPrefix);
    }

    public void Dispose() => _optionsReloadToken?.Dispose();
}

De voorgaande CustomFormatter.Write<TState> API bepaalt welke tekst rond elk logboekbericht wordt verpakt. Een standaard ConsoleFormatter moet ten minste een bereik, tijdstempels en ernstniveau van logboeken kunnen verpakken. Daarnaast kunt u ANSI-kleuren in de logboekberichten coderen en ook gewenste inspringingen opgeven. De implementatie van deze CustomFormatter.Write<TState> mogelijkheden ontbreekt.

Zie de bestaande implementaties in de Microsoft.Extensions.Logging.Console naamruimte voor inspiratie voor het verder aanpassen van de opmaak:

• SimpleConsoleFormatter.
• SystemdConsoleFormatter
• JsonConsoleFormatter

Aangepaste configuratieopties

Als u de uitbreidbaarheid van logboekregistratie verder wilt aanpassen, kan uw afgeleide ConsoleFormatterOptions klasse worden geconfigureerd vanuit elke configuratieprovider. U kunt bijvoorbeeld de JSON-configuratieprovider gebruiken om uw aangepaste opties te definiëren. Definieer eerst uw ConsoleFormatterOptions subklasse.

using Microsoft.Extensions.Logging.Console;

namespace Console.ExampleFormatters.CustomWithConfig;

public sealed class CustomWrappingConsoleFormatterOptions : ConsoleFormatterOptions
{
    public string? CustomPrefix { get; set; }

    public string? CustomSuffix { get; set; }
}

De voorgaande klasse indelingsopties van de console definieert twee aangepaste eigenschappen, die een voorvoegsel en achtervoegsel vertegenwoordigen. Definieer vervolgens het appsettings.json-bestand waarmee de indelingsopties voor de console worden geconfigureerd.

{
    "Logging": {
        "LogLevel": {
            "Default": "Information",
            "Microsoft": "Warning",
            "Microsoft.Hosting.Lifetime": "Information"
        },
        "Console": {
            "LogLevel": {
                "Default": "Information",
                "Microsoft": "Warning",
                "Microsoft.Hosting.Lifetime": "Information"
            },
            "FormatterName": "CustomTimePrefixingFormatter",
            "FormatterOptions": {
                "CustomPrefix": "|-<[",
                "CustomSuffix": "]>-|",
                "SingleLine": true,
                "IncludeScopes": true,
                "TimestampFormat": "HH:mm:ss.ffff ",
                "UseUtcTimestamp": true,
                "JsonWriterOptions": {
                    "Indented": true
                }
            }
        }
    },
    "AllowedHosts": "*"
}

In het voorgaande JSON-configuratiebestand:

• Het "Logging" knooppunt definieert een "Console".
• Het "Console" knooppunt geeft een "FormatterName" van "CustomTimePrefixingFormatter", die wordt toegewezen aan een aangepaste formatter.
• Het "FormatterOptions" knooppunt definieert een "CustomPrefix"en, en "CustomSuffix"een paar andere afgeleide opties.

Tip

Het $.Logging.Console.FormatterOptions JSON-pad is gereserveerd en wordt toegewezen aan een aangepaste ConsoleFormatterOptions wanneer het wordt toegevoegd met behulp van de AddConsoleFormatter extensiemethode. Dit biedt de mogelijkheid om aangepaste eigenschappen te definiëren, naast de eigenschappen die beschikbaar zijn.

Houd rekening met het volgende CustomDatePrefixingFormatter:

using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Logging.Abstractions;
using Microsoft.Extensions.Logging.Console;
using Microsoft.Extensions.Options;

namespace Console.ExampleFormatters.CustomWithConfig;

public sealed class CustomTimePrefixingFormatter : ConsoleFormatter, IDisposable
{
    private readonly IDisposable? _optionsReloadToken;
    private CustomWrappingConsoleFormatterOptions _formatterOptions;

    public CustomTimePrefixingFormatter(
        IOptionsMonitor<CustomWrappingConsoleFormatterOptions> options)
        // Case insensitive
        : base(nameof(CustomTimePrefixingFormatter))
    {
        _optionsReloadToken = options.OnChange(ReloadLoggerOptions);
        _formatterOptions = options.CurrentValue;
    }

    private void ReloadLoggerOptions(CustomWrappingConsoleFormatterOptions options) =>
        _formatterOptions = options;

    public override void Write<TState>(
        in LogEntry<TState> logEntry,
        IExternalScopeProvider? scopeProvider,
        TextWriter textWriter)
    {
        string message =
            logEntry.Formatter(
                logEntry.State, logEntry.Exception);

        if (message == null)
        {
            return;
        }

        WritePrefix(textWriter);
        textWriter.Write(message);
        WriteSuffix(textWriter);
    }

    private void WritePrefix(TextWriter textWriter)
    {
        DateTime now = _formatterOptions.UseUtcTimestamp
            ? DateTime.UtcNow
            : DateTime.Now;

        textWriter.Write($"""
            {_formatterOptions.CustomPrefix} {now.ToString(_formatterOptions.TimestampFormat)}
            """);
    }

    private void WriteSuffix(TextWriter textWriter) =>
        textWriter.WriteLine($" {_formatterOptions.CustomSuffix}");

    public void Dispose() => _optionsReloadToken?.Dispose();
}

In de voorgaande formatter-implementatie:

• De CustomWrappingConsoleFormatterOptions wijzigingen worden gecontroleerd en dienovereenkomstig bijgewerkt.
• Berichten die zijn geschreven, worden verpakt met het geconfigureerde voorvoegsel en achtervoegsel.
• Er wordt een tijdstempel toegevoegd na het voorvoegsel, maar voordat het bericht de geconfigureerde ConsoleFormatterOptions.UseUtcTimestamp waarden gebruikt ConsoleFormatterOptions.TimestampFormat .

Als u aangepaste configuratieopties wilt gebruiken, voegt u bij het aanroepen ConfigureLogging(IHostBuilder, Action<HostBuilderContext,ILoggingBuilder>)toe met aangepaste formatter-implementaties.

using Console.ExampleFormatters.CustomWithConfig;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;

HostApplicationBuilder builder = Host.CreateApplicationBuilder(args);

builder.Logging.AddConsole()
    .AddConsoleFormatter<
        CustomTimePrefixingFormatter, CustomWrappingConsoleFormatterOptions>();

using IHost host = builder.Build();

ILoggerFactory loggerFactory = host.Services.GetRequiredService<ILoggerFactory>();
ILogger<Program> logger = loggerFactory.CreateLogger<Program>();

using (logger.BeginScope("Logging scope"))
{
    logger.LogInformation("Hello World!");
    logger.LogInformation("The .NET developer community happily welcomes you.");
}

De volgende console-uitvoer is vergelijkbaar met wat u kunt verwachten van het CustomTimePrefixingFormattergebruik hiervan.

|-<[ 15:03:15.6179 Hello World! ]>-|
|-<[ 15:03:15.6347 The .NET developer community happily welcomes you. ]>-|

Aangepaste kleuropmaak implementeren

Als u de kleurmogelijkheden in uw aangepaste logboekindeling op de juiste manier wilt inschakelen, kunt u deze SimpleConsoleFormatterOptions uitbreiden omdat deze een SimpleConsoleFormatterOptions.ColorBehavior eigenschap heeft die handig kan zijn voor het inschakelen van kleuren in logboeken.

Maak een CustomColorOptions die is afgeleid van SimpleConsoleFormatterOptions:

using Microsoft.Extensions.Logging.Console;

namespace Console.ExampleFormatters.Custom;

public class CustomColorOptions : SimpleConsoleFormatterOptions
{
    public string? CustomPrefix { get; set; }
}

Schrijf vervolgens enkele uitbreidingsmethoden in een TextWriterExtensions klasse waarmee u eenvoudig ANSI-gecodeerde kleuren kunt insluiten in opgemaakte logboekberichten:

namespace Console.ExampleFormatters.Custom;

public static class TextWriterExtensions
{
    const string DefaultForegroundColor = "\x1B[39m\x1B[22m";
    const string DefaultBackgroundColor = "\x1B[49m";

    public static void WriteWithColor(
        this TextWriter textWriter,
        string message,
        ConsoleColor? background,
        ConsoleColor? foreground)
    {
        // Order:
        //   1. background color
        //   2. foreground color
        //   3. message
        //   4. reset foreground color
        //   5. reset background color

        var backgroundColor = background.HasValue ? GetBackgroundColorEscapeCode(background.Value) : null;
        var foregroundColor = foreground.HasValue ? GetForegroundColorEscapeCode(foreground.Value) : null;

        if (backgroundColor != null)
        {
            textWriter.Write(backgroundColor);
        }
        if (foregroundColor != null)
        {
            textWriter.Write(foregroundColor);
        }

        textWriter.WriteLine(message);

        if (foregroundColor != null)
        {
            textWriter.Write(DefaultForegroundColor);
        }
        if (backgroundColor != null)
        {
            textWriter.Write(DefaultBackgroundColor);
        }
    }

    static string GetForegroundColorEscapeCode(ConsoleColor color) =>
        color switch
        {
            ConsoleColor.Black => "\x1B[30m",
            ConsoleColor.DarkRed => "\x1B[31m",
            ConsoleColor.DarkGreen => "\x1B[32m",
            ConsoleColor.DarkYellow => "\x1B[33m",
            ConsoleColor.DarkBlue => "\x1B[34m",
            ConsoleColor.DarkMagenta => "\x1B[35m",
            ConsoleColor.DarkCyan => "\x1B[36m",
            ConsoleColor.Gray => "\x1B[37m",
            ConsoleColor.Red => "\x1B[1m\x1B[31m",
            ConsoleColor.Green => "\x1B[1m\x1B[32m",
            ConsoleColor.Yellow => "\x1B[1m\x1B[33m",
            ConsoleColor.Blue => "\x1B[1m\x1B[34m",
            ConsoleColor.Magenta => "\x1B[1m\x1B[35m",
            ConsoleColor.Cyan => "\x1B[1m\x1B[36m",
            ConsoleColor.White => "\x1B[1m\x1B[37m",

            _ => DefaultForegroundColor
        };

    static string GetBackgroundColorEscapeCode(ConsoleColor color) =>
        color switch
        {
            ConsoleColor.Black => "\x1B[40m",
            ConsoleColor.DarkRed => "\x1B[41m",
            ConsoleColor.DarkGreen => "\x1B[42m",
            ConsoleColor.DarkYellow => "\x1B[43m",
            ConsoleColor.DarkBlue => "\x1B[44m",
            ConsoleColor.DarkMagenta => "\x1B[45m",
            ConsoleColor.DarkCyan => "\x1B[46m",
            ConsoleColor.Gray => "\x1B[47m",

            _ => DefaultBackgroundColor
        };
}

Een aangepaste kleurenopmaakfunctie die het toepassen van aangepaste kleuren afhandelt, kan als volgt worden gedefinieerd:

using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Logging.Abstractions;
using Microsoft.Extensions.Logging.Console;
using Microsoft.Extensions.Options;

namespace Console.ExampleFormatters.Custom;

public sealed class CustomColorFormatter : ConsoleFormatter, IDisposable
{
    private readonly IDisposable? _optionsReloadToken;
    private CustomColorOptions _formatterOptions;

    private bool ConsoleColorFormattingEnabled =>
        _formatterOptions.ColorBehavior == LoggerColorBehavior.Enabled ||
        _formatterOptions.ColorBehavior == LoggerColorBehavior.Default &&
        System.Console.IsOutputRedirected == false;

    public CustomColorFormatter(IOptionsMonitor<CustomColorOptions> options)
        // Case insensitive
        : base("customName") =>
        (_optionsReloadToken, _formatterOptions) =
            (options.OnChange(ReloadLoggerOptions), options.CurrentValue);

    private void ReloadLoggerOptions(CustomColorOptions options) =>
        _formatterOptions = options;

    public override void Write<TState>(
        in LogEntry<TState> logEntry,
        IExternalScopeProvider? scopeProvider,
        TextWriter textWriter)
    {
        if (logEntry.Exception is null)
        {
            return;
        }

        string? message =
            logEntry.Formatter?.Invoke(
                logEntry.State, logEntry.Exception);

        if (message is null)
        {
            return;
        }

        CustomLogicGoesHere(textWriter);
        textWriter.WriteLine(message);
    }

    private void CustomLogicGoesHere(TextWriter textWriter)
    {
        if (ConsoleColorFormattingEnabled)
        {
            textWriter.WriteWithColor(
                _formatterOptions.CustomPrefix ?? string.Empty,
                ConsoleColor.Black,
                ConsoleColor.Green);
        }
        else
        {
            textWriter.Write(_formatterOptions.CustomPrefix);
        }
    }

    public void Dispose() => _optionsReloadToken?.Dispose();
}

Wanneer u de toepassing uitvoert, worden in de logboeken het CustomPrefix bericht in de kleur groen weergegeven wanneer FormatterOptions.ColorBehavior dit is Enabled.

Notitie

Wanneer LoggerColorBehavior dat het is Disabled, interpreteren logboekberichten geen ingesloten ANSI-kleurcodes in logboekberichten. In plaats daarvan voeren ze het onbewerkte bericht uit. Denk bijvoorbeeld aan het volgende:

logger.LogInformation("Random log \x1B[42mwith green background\x1B[49m message");

Hiermee wordt de exacte tekenreeks uitgevoerd en wordt deze niet gekleurd.

Random log \x1B[42mwith green background\x1B[49m message

Zie ook

• Logboekregistratie in .NET
• Een aangepaste logboekregistratieprovider implementeren in .NET
• Logboekregistratie met hoge prestaties in .NET