Consolelogboekopmaak

De Microsoft.Extensions.Logging.Console naamruimte biedt ondersteuning voor aangepaste opmaak in consolelogboeken. Er zijn drie vooraf gedefinieerde opmaakopties beschikbaar: Simple, Systemden Json.

Belangrijk

Vóór .NET 5 stond de ConsoleLoggerFormat enum toe om het gewenste logboekformaat te selecteren, hetzij het menselijk leesbare formaat als Default, of het éénregelige formaat, dat ook wel bekend is 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:

Registreer een nieuwe formatter.
Selecteer een geregistreerde formatter die u wilt gebruiken, via code of configuratie.
Implementeer een aangepaste formatter. U werkt de configuratie bij via IOptionsMonitor<TOptions> en schakelt aangepaste kleuropmaak in.

Aanbeveling

Alle voorbeeldbroncode voor logboekregistratie is beschikbaar in de voorbeeldenbrowser om te downloaden. Zie Blader door 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

Simple

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 werd de ConsoleFormatterNames.Simple-formatter geregistreerd. Het biedt logs de mogelijkheid om niet alleen informatie te verpakken, zoals tijd en logniveau in elk logbericht, maar biedt ook de mogelijkheid tot het insluiten van ANSI-kleuren en het 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.
Registreert altijd berichten op één regel.

Dit is meestal nuttig voor containers, die vaak gebruikmaken van Systemd console-logging. De Simple consolelogger maakt 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 Simple consolelogformatter geselecteerd met standaardconfiguratie. U wijzigt dit door in de AddJsonConsole aan te roepen:

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 logboekconfiguratie, 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}"
  }
}

Aanbeveling

De Json console-formatter registreert standaard elk bericht op één regel. Als u het beter leesbaar wilt maken, stelt u tijdens het configureren de formatter in op JsonWriterOptions.Indented naar true.

Waarschuwing

Wanneer u de JSON-consoleindeling gebruikt, geeft u geen logboekberichten door die al als JSON zijn geserialiseerd. De logboekinfrastructuur zelf beheert de serialisatie van logboekberichten. Dus als u een logboekbericht doorgeeft dat al is geserialiseerd, wordt het dubbel geserialiseerd, waardoor een onjuiste uitvoer wordt veroorzaakt.

Een formatter instellen met configuratie

De vorige voorbeelden laten zien hoe u een formatter programmatisch registreert. U kunt dit ook doen met configuratie. Als u het appsettings.json-bestand bijwerkt in plaats van de Program.cs-aanroep te maken, 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 ingestelde waarde voor "FormatterName" al is geregistreerd, wordt die formatter geselecteerd en kunnen de eigenschappen ervan worden geconfigureerd zolang ze als sleutel in het "FormatterOptions" knooppunt verstrekt zijn. De vooraf gedefinieerde formatternamen zijn gereserveerd onder ConsoleFormatterNames:

Een aangepaste formatter implementeren

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

Maak een subklasse van ConsoleFormatter die uw aangepaste formatter vertegenwoordigt.
Registreer uw aangepaste formatter 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.
Beheert de configuratie. Er wordt een wijzigingstoken gebruikt 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 scope, een tijdstempel en een ernstniveau van logboeken kunnen omvatten. 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:

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 opties voor consoleopmaak 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 specificeert een "FormatterName" van "CustomTimePrefixingFormatter", dat wordt geassocieerd met een aangepaste formatter.
Het "FormatterOptions" knooppunt definieert een "CustomPrefix", "CustomSuffix" en een paar andere afgeleide opties.

Aanbeveling

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 worden gecontroleerd op wijzigingen 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, met gebruik van de geconfigureerde ConsoleFormatterOptions.UseUtcTimestamp en ConsoleFormatterOptions.TimestampFormat waarden.

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 wanneer u hiervan CustomTimePrefixingFormatter gebruikmaakt.

|-<[ 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, wordt het CustomPrefix bericht in de logbestanden in de kleur groen weergegeven wanneer FormatterOptions.ColorBehaviorEnabled is.

Opmerking

Wanneer LoggerColorBehaviorDisabled is, interpreteren logboekberichten geen ingesloten ANSI-kleurcodes. 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

Feedback

Is deze pagina nuttig?

Last updated on 2026-02-05

Delen via

Consolelogboekopmaak

Formatter registreren

Simple

Systemd

Json

Een formatter instellen met configuratie

Een aangepaste formatter implementeren

Aangepaste configuratieopties

Aangepaste kleuropmaak implementeren

Zie ook

Feedback

Aanvullende resources