ASP.NET Core Blazor-Protokollierung

In diesem Artikel wird die Protokollierung in Blazor-Apps erläutert, einschließlich der Konfiguration und des Schreibens von Protokollmeldungen aus Razor-Komponenten.

Konfiguration

Die Protokollierungskonfiguration kann aus App-Einstellungsdateien geladen werden. Weitere Informationen finden Sie unter Konfiguration von Blazor in ASP.NET Core.

Auf standardmäßigen Protokollebenen und ohne Konfiguration zusätzlicher Protokollierungsanbieter gilt Folgendes:

• Auf dem Server erfolgt die Protokollierung nur an die serverseitigen .NET-Konsole in der Development-Umgebung, auf der Ebene LogLevel.Information oder höher.
• Auf dem Client erfolgt die Protokollierung nur an die clientseitige Konsole mit Browserentwicklertools (auf Ebene LogLevel.Information oder höher).

Protokolliergrade

Die Protokolliergrade entsprechen den ASP.NET Core-App-Protokolliergraden, die in der API-Dokumentation unter LogLevel aufgeführt sind.

Protokollierung von Razor-Komponenten

Im Beispiel unten geschieht Folgendes:

• Es wird ein ILogger-Objekt (ILogger<Counter1>) injiziert, um eine Protokollierung zu erstellen. Die Kategorie des Protokolls ist der vollqualifizierte Name des Komponententyps, also Counter.
• Es wird LogWarning aufgerufen, um Protokollierung mit dem Protokolliergrad Warning auszuführen.

Counter1.razor:

@page "/counter-1"
@inject ILogger<Counter1> Logger

<PageTitle>Counter 1</PageTitle>

<h1>Counter 1</h1>

<p>Current count: @currentCount</p>

<button class="btn btn-primary" @onclick="IncrementCount">Click me</button>

@code {
    private int currentCount = 0;

    private void IncrementCount()
    {
        Logger.LogWarning("Someone has clicked me!");

        currentCount++;
    }
}

@page "/counter-1"
@inject ILogger<Counter1> Logger

<PageTitle>Counter 1</PageTitle>

<h1>Counter 1</h1>

<p>Current count: @currentCount</p>

<button class="btn btn-primary" @onclick="IncrementCount">Click me</button>

@code {
    private int currentCount = 0;

    private void IncrementCount()
    {
        Logger.LogWarning("Someone has clicked me!");

        currentCount++;
    }
}

@page "/counter-1"
@inject ILogger<Counter1> Logger

<h1>Counter</h1>

<p>Current count: @currentCount</p>

<button class="btn btn-primary" @onclick="IncrementCount">Click me</button>

@code {
    private int currentCount = 0;

    private void IncrementCount()
    {
        Logger.LogWarning("Someone has clicked me!");

        currentCount++;
    }
}

@page "/counter-1"
@inject ILogger<Counter1> Logger

<h1>Counter</h1>

<p>Current count: @currentCount</p>

<button class="btn btn-primary" @onclick="IncrementCount">Click me</button>

@code {
    private int currentCount = 0;

    private void IncrementCount()
    {
        Logger.LogWarning("Someone has clicked me!");

        currentCount++;
    }
}

@page "/counter-1"
@using Microsoft.Extensions.Logging
@inject ILogger<Counter1> Logger

<h1>Counter</h1>

<p>Current count: @currentCount</p>

<button class="btn btn-primary" @onclick="IncrementCount">Click me</button>

@code {
    private int currentCount = 0;

    private void IncrementCount()
    {
        Logger.LogWarning("Someone has clicked me!");

        currentCount++;
    }
}

@page "/counter-1"
@using Microsoft.Extensions.Logging
@inject ILogger<Counter1> Logger

<h1>Counter</h1>

<p>Current count: @currentCount</p>

<button class="btn btn-primary" @onclick="IncrementCount">Click me</button>

@code {
    private int currentCount = 0;

    private void IncrementCount()
    {
        Logger.LogWarning("Someone has clicked me!");

        currentCount++;
    }
}

Im folgenden Beispiel wird die Protokollierung mit ILoggerFactory in Komponenten veranschaulicht.

Counter2.razor:

@page "/counter-2"
@inject ILoggerFactory LoggerFactory

<PageTitle>Counter 2</PageTitle>

<h1>Counter 2</h1>

<p>Current count: @currentCount</p>

<button class="btn btn-primary" @onclick="IncrementCount">Click me</button>

@code {
    private int currentCount = 0;

    private void IncrementCount()
    {
        var logger = LoggerFactory.CreateLogger<Counter2>();
        logger.LogWarning("Someone has clicked me!");

        currentCount++;
    }
}

@page "/counter-2"
@inject ILoggerFactory LoggerFactory

<PageTitle>Counter 2</PageTitle>

<h1>Counter 2</h1>

<p>Current count: @currentCount</p>

<button class="btn btn-primary" @onclick="IncrementCount">Click me</button>

@code {
    private int currentCount = 0;

    private void IncrementCount()
    {
        var logger = LoggerFactory.CreateLogger<Counter2>();
        logger.LogWarning("Someone has clicked me!");

        currentCount++;
    }
}

@page "/counter-2"
@inject ILoggerFactory LoggerFactory

<h1>Counter</h1>

<p>Current count: @currentCount</p>

<button class="btn btn-primary" @onclick="IncrementCount">Click me</button>

@code {
    private int currentCount = 0;

    private void IncrementCount()
    {
        var logger = LoggerFactory.CreateLogger<Counter2>();
        logger.LogWarning("Someone has clicked me!");

        currentCount++;
    }
}

@page "/counter-2"
@inject ILoggerFactory LoggerFactory

<h1>Counter</h1>

<p>Current count: @currentCount</p>

<button class="btn btn-primary" @onclick="IncrementCount">Click me</button>

@code {
    private int currentCount = 0;

    private void IncrementCount()
    {
        var logger = LoggerFactory.CreateLogger<Counter2>();
        logger.LogWarning("Someone has clicked me!");

        currentCount++;
    }
}

@page "/counter-2"
@using Microsoft.Extensions.Logging
@inject ILoggerFactory LoggerFactory

<h1>Counter</h1>

<p>Current count: @currentCount</p>

<button class="btn btn-primary" @onclick="IncrementCount">Click me</button>

@code {
    private int currentCount = 0;

    private void IncrementCount()
    {
        var logger = LoggerFactory.CreateLogger<Counter2>();
        logger.LogWarning("Someone has clicked me!");

        currentCount++;
    }
}

@page "/counter-2"
@using Microsoft.Extensions.Logging
@inject ILoggerFactory LoggerFactory

<h1>Counter</h1>

<p>Current count: @currentCount</p>

<button class="btn btn-primary" @onclick="IncrementCount">Click me</button>

@code {
    private int currentCount = 0;

    private void IncrementCount()
    {
        var logger = LoggerFactory.CreateLogger<Counter2>();
        logger.LogWarning("Someone has clicked me!");

        currentCount++;
    }
}

Serverseitige Protokollierung

Einen allgemeinen Leitfaden zur Protokollierung in ASP.NET Core finden Sie unter Protokollierung in .NET Core und ASP.NET Core.

Clientseitige Protokollierung

Nicht jedes Feature der ASP.NET Core-Protokollierung wird clientseitig unterstützt. Beispielsweise haben clientseitige Komponenten keinen Zugriff auf das Dateisystem oder das Netzwerk des Clients, so dass es nicht möglich ist, Protokolle in den physischen oder Netzwerkspeicher des Clients zu schreiben. Wenn Sie einen Protokollierungsdienst eines Drittanbieters verwenden, der für die Verwendung mit Single-Page-Webanwendungen (SPAs) entwickelt wurde, befolgen Sie die Sicherheitsempfehlungen des Diensts. Beachten Sie, dass alle Daten, einschließlich clientseitig gespeicherter Schlüssel oder Geheimnisse, unsicher sind und von böswilligen Benutzern leicht entdeckt werden können.

using Microsoft.Extensions.Logging;

Konfigurieren Sie die Protokollierung in clientseitigen-Apps mit der WebAssemblyHostBuilder.Logging-Eigenschaft. Die Logging-Eigenschaft hat den Typ ILoggingBuilder, daher werden die Erweiterungsmethoden von ILoggingBuilder unterstützt.

Um den Mindestprotokolliergrad festzulegen, rufen Sie im Hostbuilder in der Datei Program mit dem LogLevel die Methode LoggingBuilderExtensions.SetMinimumLevel auf. Im folgenden Beispiel wird der Mindestprotokollgrad auf Warning festgelegt:

builder.Logging.SetMinimumLevel(LogLevel.Warning);

var host = builder.Build();

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

logger.LogInformation("Logged after the app is built in the Program file.");

await host.RunAsync();

var logger = LoggerFactory.CreateLogger("CustomCategory");
logger.LogWarning("Someone has clicked me!");

public class LogEvent
{
    public const int Event1 = 1000;
    public const int Event2 = 1001;
}

logger.LogInformation(LogEvent.Event1, "Someone has clicked me!");
logger.LogWarning(LogEvent.Event2, "Someone has clicked me!");

logger.LogInformation("Someone clicked me at {CurrentDT}!", DateTime.UtcNow);

currentCount++;

try
{
    if (currentCount == 3)
    {
        currentCount = 4;
        throw new OperationCanceledException("Skip 3");
    }
}
catch (Exception ex)
{
    logger.LogWarning(ex, "Exception (currentCount: {Count})!", currentCount);
}

builder.Logging.AddFilter((provider, category, logLevel) =>
    category.Equals("CustomCategory2") && logLevel == LogLevel.Information);

var logger1 = LoggerFactory.CreateLogger("CustomCategory1");
logger1.LogInformation("Someone has clicked me!");

var logger2 = LoggerFactory.CreateLogger("CustomCategory1");
logger2.LogWarning("Someone has clicked me!");

var logger3 = LoggerFactory.CreateLogger("CustomCategory2");
logger3.LogInformation("Someone has clicked me!");

var logger4 = LoggerFactory.CreateLogger("CustomCategory2");
logger4.LogWarning("Someone has clicked me!");

builder.Logging.SetMinimumLevel(LogLevel.Trace);

Clientseitiger benutzerdefinierter Protokollierungsanbieter

Das Beispiel in diesem Abschnitt veranschaulicht einen benutzerdefinierten Protokollierungsanbieter zur weiteren Anpassung.

Fügen Sie der App einen Paketverweis für das Paket Microsoft.Extensions.Logging.Configuration hinzu.

Fügen Sie die folgende benutzerdefinierte Protokollierungskonfiguration hinzu. Die Konfiguration richtet ein Wörterbuch LogLevels ein, das ein benutzerdefiniertes Protokollformat für drei Protokolliergrade festlegt: Information, Warning und Error. Mit LogFormat enum werden kurze (LogFormat.Short) und lange (LogFormat.Long) Formate beschrieben.

CustomLoggerConfiguration.cs:

using Microsoft.Extensions.Logging;

public class CustomLoggerConfiguration
{
    public int EventId { get; set; }

    public Dictionary<LogLevel, LogFormat> LogLevels { get; set; } = 
        new()
        {
            [LogLevel.Information] = LogFormat.Short,
            [LogLevel.Warning] = LogFormat.Short,
            [LogLevel.Error] = LogFormat.Long
        };

    public enum LogFormat
    {
        Short,
        Long
    }
}

Fügen Sie der App die folgende benutzerdefinierte Protokollierung hinzu. Mit CustomLogger werden benutzerdefinierte Protokollformate basierend auf den logLevel-Werten ausgegeben, die in der vorherigen CustomLoggerConfiguration-Konfiguration definiert wurden.

using Microsoft.Extensions.Logging;
using static CustomLoggerConfiguration;

public sealed class CustomLogger : ILogger
{
    private readonly string name;
    private readonly Func<CustomLoggerConfiguration> getCurrentConfig;

    public CustomLogger(
        string name,
        Func<CustomLoggerConfiguration> getCurrentConfig) =>
        (this.name, this.getCurrentConfig) = (name, getCurrentConfig);

    public IDisposable BeginScope<TState>(TState state) => default!;

    public bool IsEnabled(LogLevel logLevel) =>
        getCurrentConfig().LogLevels.ContainsKey(logLevel);

    public void Log<TState>(
        LogLevel logLevel,
        EventId eventId,
        TState state,
        Exception? exception,
        Func<TState, Exception?, string> formatter)
    {
        if (!IsEnabled(logLevel))
        {
            return;
        }

        CustomLoggerConfiguration config = getCurrentConfig();

        if (config.EventId == 0 || config.EventId == eventId.Id)
        {
            switch (config.LogLevels[logLevel])
            {
                case LogFormat.Short:
                    Console.WriteLine($"{name}: {formatter(state, exception)}");
                    break;
                case LogFormat.Long:
                    Console.WriteLine($"[{eventId.Id, 2}: {logLevel, -12}] {name} - {formatter(state, exception)}");
                    break;
                default:
                    // No-op
                    break;
            }
        }
    }
}

Fügen Sie der App den folgenden benutzerdefinierten Protokollierungsanbieter hinzu. CustomLoggerProvider verwendet einen Options-basierten Ansatz, um die Protokollierung über integrierte Konfigurationsfeatures zu konfigurieren. Beispielsweise kann die App Protokollformate über eine appsettings.json-Datei festlegen oder ändern, ohne dass Codeänderungen an der benutzerdefinierten Protokollierung erforderlich sind. Dies wird am Ende dieses Abschnitts veranschaulicht.

CustomLoggerProvider.cs:

using System.Collections.Concurrent;
using Microsoft.Extensions.Options;

[ProviderAlias("CustomLog")]
public sealed class CustomLoggerProvider : ILoggerProvider
{
    private readonly IDisposable onChangeToken;
    private CustomLoggerConfiguration config;
    private readonly ConcurrentDictionary<string, CustomLogger> loggers =
        new(StringComparer.OrdinalIgnoreCase);

    public CustomLoggerProvider(
        IOptionsMonitor<CustomLoggerConfiguration> config)
    {
        this.config = config.CurrentValue;
        onChangeToken = config.OnChange(updatedConfig => this.config = updatedConfig);
    }

    public ILogger CreateLogger(string categoryName) =>
        loggers.GetOrAdd(categoryName, name => new CustomLogger(name, GetCurrentConfig));

    private CustomLoggerConfiguration GetCurrentConfig() => config;

    public void Dispose()
    {
        loggers.Clear();
        onChangeToken.Dispose();
    }
}

Fügen Sie die folgenden benutzerdefinierten Protokollierungserweiterungen hinzu.

CustomLoggerExtensions.cs:

using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.DependencyInjection.Extensions;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Logging.Configuration;

public static class CustomLoggerExtensions
{
    public static ILoggingBuilder AddCustomLogger(
        this ILoggingBuilder builder)
    {
        builder.AddConfiguration();

        builder.Services.TryAddEnumerable(
            ServiceDescriptor.Singleton<ILoggerProvider, CustomLoggerProvider>());

        LoggerProviderOptions.RegisterProviderOptions
            <CustomLoggerConfiguration, CustomLoggerProvider>(builder.Services);

        return builder;
    }
}

Löschen Sie in der Program-Datei im Hostbuilder den vorhandenen Anbieter durch einen Aufruf von ClearProviders, und fügen Sie den benutzerdefinierten Protokollierungsanbieter hinzu:

builder.Logging.ClearProviders().AddCustomLogger();

In der folgenden CustomLoggerExample-Komponente:

• Die Debugmeldung wird nicht protokolliert.
• Die Informationsmeldung wird im Kurzformat (LogFormat.Short) protokolliert.
• Die Warnmeldung wird im Kurzformat (LogFormat.Short) protokolliert.
• Die Fehlermeldung wird im Langformat (LogFormat.Long) protokolliert.
• Die Ablaufverfolgungsmeldung wird nicht protokolliert.

CustomLoggerExample.razor:

@page "/custom-logger-example"
@inject ILogger<CustomLoggerExample> Logger

<p>
    <button @onclick="LogMessages">Log Messages</button>
</p>

@code{
    private void LogMessages()
    {
        Logger.LogDebug(1, "This is a debug message.");
        Logger.LogInformation(3, "This is an information message.");
        Logger.LogWarning(5, "This is a warning message.");
        Logger.LogError(7, "This is an error message.");
        Logger.LogTrace(5!, "This is a trace message.");
    }
}

@page "/custom-logger-example"
@using Microsoft.Extensions.Logging
@inject ILogger<CustomLoggerExample> Logger

<p>
    <button @onclick="LogMessages">Log Messages</button>
</p>

@code{
    private void LogMessages()
    {
        Logger.LogDebug(1, "This is a debug message.");
        Logger.LogInformation(3, "This is an information message.");
        Logger.LogWarning(5, "This is a warning message.");
        Logger.LogError(7, "This is an error message.");
        Logger.LogTrace(5!, "This is a trace message.");
    }
}

Die folgende Ausgabe wird in der Entwicklungstoolkonsole des Browsers angezeigt, wenn die Log Messages-Schaltfläche ausgewählt ist. Die Protokolleinträge entsprechen den für die benutzerdefinierte Protokollierung verwendeten Formaten (die Client-App hat den Namen LoggingTest):

LoggingTest.Pages.CustomLoggerExample: This is an information message.
LoggingTest.Pages.CustomLoggerExample: This is a warning message.
[ 7: Error ] LoggingTest.Pages.CustomLoggerExample - This is an error message.

Schon bei einer kurzen Untersuchung des vorherigen Beispiels wird klar, dass es nicht unbedingt erforderlich ist, die Protokollzeilenformate über das Wörterbuch in CustomLoggerConfiguration festzulegen. Die von der benutzerdefinierten Protokollierung (CustomLogger) angewendeten Zeilenformate hätten durch einfaches Überprüfen von logLevel in der Log-Methode angewendet werden können. Der Zweck der Zuweisung des Protokollformats über die Konfiguration besteht darin, dass Entwickler*innen das Protokollformat einfach über die App-Konfiguration ändern können. Dies wird im folgenden Beispiel veranschaulicht.

Fügen Sie in der clientseitigen App die Datei appsettings.json hinzu, oder aktualisieren Sie sie, um die Protokollierungskonfiguration einzuschließen. Legen Sie das Protokollformat für alle drei Protokolliergrade auf Long fest:

{
  "Logging": {
    "CustomLog": {
      "LogLevels": {
        "Information": "Long",
        "Warning": "Long",
        "Error": "Long"
      }
    }
  }
}

Beachten Sie im vorherigen Beispiel, dass der Eintrag für die benutzerdefinierte Protokollierungskonfiguration CustomLog lautet, der auf den benutzerdefinierten Protokollierungsanbieter (CustomLoggerProvider) als Alias mit [ProviderAlias("CustomLog")] angewendet wurde. Die Protokollierungskonfiguration hätte mit dem Namen CustomLoggerProvider anstelle von CustomLog angewendet werden können, aber die Verwendung des Alias CustomLog ist benutzerfreundlicher.

Nutzen Sie in der Program-Datei die Protokollierungskonfiguration. Fügen Sie den folgenden Code hinzu:

builder.Logging.AddConfiguration(
    builder.Configuration.GetSection("Logging"));

Der Aufruf von LoggingBuilderConfigurationExtensions.AddConfiguration kann entweder vor oder nach dem Hinzufügen des benutzerdefinierten Protokollierungsanbieters eingefügt werden.

Führen Sie die App erneut aus. Wählen Sie die Schaltfläche Log Messages aus. Beachten Sie, dass die Protokollierungskonfiguration von der Datei appsettings.json angewendet wird. Alle drei Protokolleinträge sind im langen (LogFormat.Long) Format angegeben (die Client-App hat den Namen LoggingTest):

[ 3: Information ] LoggingTest.Pages.CustomLoggerExample - This is an information message.
[ 5: Warning ] LoggingTest.Pages.CustomLoggerExample - This is a warning message.
[ 7: Error ] LoggingTest.Pages.CustomLoggerExample - This is an error message.

using (Logger.BeginScope("L1"))
{
    Logger.LogInformation(3, "INFO: ONE scope.");
}

using (Logger.BeginScope("L1"))
{
    using (Logger.BeginScope("L2"))
    {
        Logger.LogInformation(3, "INFO: TWO scopes.");
    }
}

using (Logger.BeginScope("L1"))
{
    using (Logger.BeginScope("L2"))
    {
        using (Logger.BeginScope("L3"))
        {
            Logger.LogInformation(3, "INFO: THREE scopes.");
        }
    }
}

Protokollierung für vorab gerenderte Komponenten

Vorab gerenderte Komponenten führen Code zur Komponenteninitialisierung zweimal aus. Die Protokollierung erfolgt serverseitig bei der ersten Ausführung des Initialisierungscodes und clientseitig bei der zweiten Ausführung des Initialisierungscodes. Überprüfen Sie je nach Ziel der Protokollierung während der Initialisierung serverseitige, clientseitige oder beide Protokolle.

SignalR-Clientprotokollierung mit dem SignalR-Clientbuilder

Dieser Abschnitt gilt für serverseitige Apps.

Übergeben Sie in der Konfiguration des Blazor-Startskripts das Konfigurationsobjekt configureSignalR, das configureLogging mit dem Protokolliergrad aufruft.

Übergeben Sie für den configureLogging-Wert auf Protokollebene das Argument entweder als Zeichenfolge oder Integerwert auf Protokollebene, wie in der folgenden Tabelle dargestellt.

Beispiel 1: Festlegen der Information-Protokollebene mit einem Zeichenfolgenwert.

<script src="{BLAZOR SCRIPT}" autostart="false"></script>
<script>
  Blazor.start({
    circuit: {
      configureSignalR: function (builder) {
        builder.configureLogging("information");
      }
    }
  });
</script>

<script src="{BLAZOR SCRIPT}" autostart="false"></script>
<script>
  Blazor.start({
    configureSignalR: function (builder) {
      builder.configureLogging("information");
    }
  });
</script>

Im vorangegangenen Beispiel entspricht der {BLAZOR SCRIPT}-Platzhalter dem Pfad und dem Dateinamen des Blazor-Skripts. Informationen zum Speicherort des Skripts finden Sie unter Projektstruktur für ASP.NET Core Blazor.

Beispiel 2: Festlegen der Information-Protokollebene mit einem Integerwert.

<script src="{BLAZOR SCRIPT}" autostart="false"></script>
<script>
  Blazor.start({
    circuit: {
      configureSignalR: function (builder) {
        builder.configureLogging(2); // LogLevel.Information
      }
    }
  });
</script>

<script src="{BLAZOR SCRIPT}" autostart="false"></script>
<script>
  Blazor.start({
    configureSignalR: function (builder) {
      builder.configureLogging(2); // LogLevel.Information
    }
  });
</script>

Im vorangegangenen Beispiel entspricht der {BLAZOR SCRIPT}-Platzhalter dem Pfad und dem Dateinamen des Blazor-Skripts. Informationen zum Speicherort des Skripts finden Sie unter Projektstruktur für ASP.NET Core Blazor.

Weitere Informationen zum Start von Blazor (Blazor.start()) finden Sie unter ASP.NET Core Blazor-Start.

SignalR-Clientprotokollierung mit App-Konfiguration

Konfigurieren Sie die App-Einstellungen wie in ASP.NET Core Blazor-Konfiguration beschrieben. Platzieren Sie App-Einstellungsdateien in wwwroot, die eine Logging:LogLevel:HubConnection-App-Einstellung enthalten.

Geben Sie eine Logging:LogLevel:HubConnection-App-Einstellung in der Standarddatei appsettings.json und in der Development-Umgebungs-App-Einstellungsdatei an. Verwenden Sie eine typische, weniger ausführliche Protokollebene als Standard, z. B. LogLevel.Warning. Der Standardwert für App-Einstellungen wird in Staging- und Production-Umgebungen verwendet, wenn keine App-Einstellungsdateien für diese Umgebungen vorhanden sind. Verwenden Sie eine ausführliche Protokollebene in der Development-Umgebungs-App-Einstellungsdatei, z. B. LogLevel.Trace.

wwwroot/appsettings.json:

{
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft.AspNetCore": "Warning",
      "HubConnection": "Warning"
    }
  }
}

wwwroot/appsettings.Development.json:

{
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft.AspNetCore": "Warning",
      "HubConnection": "Trace"
    }
  }
}

Oben in der Razor Komponentendatei (.razor):

• Fügen Sie eine ILoggerProvider-Instanz ein, um WebAssemblyConsoleLogger zu den an HubConnectionBuilder weitergegebenen Protokollierungsanbietern hinzuzufügen. Anders als bei einem ConsoleLoggerProvider handelt es sich bei WebAssemblyConsoleLogger um einen Wrapper um browserspezifische Protokollierungs-APIs (z. B. console.log). Die Verwendung von WebAssemblyConsoleLogger ermöglicht die Protokollierung in Mono in einem Browserkontext.
• Fügen Sie IConfiguration zum Lesen der Logging:LogLevel:HubConnection-App-Einstellung ein.

@inject ILoggerProvider LoggerProvider
@inject IConfiguration Config

Verwenden Sie in der OnInitializedAsync-Methode der Komponente HubConnectionBuilderExtensions.ConfigureLogging, um den Protokollierungsanbieter hinzuzufügen und den Mindestprotokolliergrad aus der Konfiguration festzulegen:

protected override async Task OnInitializedAsync()
{
    hubConnection = new HubConnectionBuilder()
        .WithUrl(Navigation.ToAbsoluteUri("/chathub"))
        .ConfigureLogging(builder => 
        {
            builder.AddProvider(LoggerProvider);
            builder.SetMinimumLevel(
                Config.GetValue<LogLevel>("Logging:LogLevel:HubConnection"));
        })
        .Build();

    hubConnection.On<string, string>("ReceiveMessage", (user, message) => ...

    await hubConnection.StartAsync();
}

Weitere Informationen zum Festlegen der App-Umgebung finden Sie unter ASP.NET Core Blazor-Umgebungen.

Zusätzliche Ressourcen

• Protokollierung in .NET Core und ASP.NET Core
• Loglevel Enum (API-Dokumentation)
• Implementieren eines benutzerdefinierten Protokollierungsanbieters in .NET
• Dokumentation zu Entwicklertools in Browsern:
  • Chrome DevTools
  • Übersicht über Microsoft Edge-Entwicklertools
• GitHub-Repository mit Blazor-Beispielen (dotnet/blazor-samples) (Downloadanleitung)