logboekregistratie van ASP.NET Core Blazor

In dit artikel wordt uitgelegd Blazor app-logboekregistratie, inclusief configuratie en het schrijven van logboekberichten van Razor onderdelen.

Configuratie

Configuratie voor logboekregistratie kan worden geladen vanuit app-instellingenbestanden. Zie ASP.NET Core Blazor-configuratievoor meer informatie.

Op standaardlogboekniveaus en zonder extra logboekproviders te configureren:

• Loggen gebeurt op de server alleen in de .NET-console aan de serverzijde in de Development-omgeving vanaf LogLevel.Information-niveau of hoger.
• Logboekregistratie vindt op de clientzijde alleen plaats hulpprogramma's voor browserontwikkelaars console op LogLevel.Information niveau of hoger.

Wanneer de app is geconfigureerd in het projectbestand voor het gebruik van impliciete naamruimten (<ImplicitUsings>enable</ImplicitUsings>), is een using-instructie voor Microsoft.Extensions.Logging of een API in de klasse LoggerExtensions niet vereist voor het ondersteunen van API-Visual Studio IntelliSense voltooiingen of het bouwen van apps. Als impliciete naamruimten niet zijn ingeschakeld, moeten Razor onderdelen expliciet @using instructies definiëren voor logboekregistratienaamruimten die niet via het _Imports.razor bestand worden geïmporteerd.

Logboekniveaus

Logboekniveaus voldoen aan ASP.NET Core-app-logboekniveaus, die worden vermeld in de API-documentatie op LogLevel.

Logregistratie van Razor-componenten

Het volgende voorbeeld:

• Injecteert een ILogger (ILogger<Counter1>) object om een logboekregistratie te maken. De categorie van het logboek is de volledig gekwalificeerde naam van het type onderdeel, Counter.
• Roept LogWarning aan om u aan te melden op Warning niveau.

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++;
    }
}

In het volgende voorbeeld wordt loggen met een ILoggerFactory in componenten gedemonstreerd.

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++;
    }
}

Logboekregistratie aan serverzijde

Zie voor algemene richtlijnen voor ASP.NET Core-logging Logging in .NET Core en ASP.NET Core.

Logboekregistratie aan de clientzijde

Niet elke functie van ASP.NET Core-logboekregistratie wordt ondersteund aan de clientzijde. Onderdelen aan de clientzijde hebben bijvoorbeeld geen toegang tot het bestandssysteem of netwerk van de client, dus het schrijven van logboeken naar de fysieke of netwerkopslag van de client is niet mogelijk. Wanneer u een logboekregistratieservice van derden gebruikt die is ontworpen voor gebruik met apps met één pagina (SPA's), volgt u de beveiligingsrichtlijnen van de service. Houd er rekening mee dat elk stukje gegevens, inclusief sleutels of geheimen opgeslagen clientzijde, onveilige zijn en eenvoudig kunnen worden gedetecteerd door kwaadwillende gebruikers.

Configureer logboekregistratie in client-side apps met de eigenschap WebAssemblyHostBuilder.Logging. De eigenschap Logging is van het type ILoggingBuilder, zodat de uitbreidingsmethoden van ILoggingBuilder worden ondersteund.

Als u het minimale logboekregistratieniveau wilt instellen, roept u LoggingBuilderExtensions.SetMinimumLevel aan op de host builder in het Program-bestand met de LogLevel. In het volgende voorbeeld wordt het minimale logboekniveau ingesteld op Warning:

builder.Logging.SetMinimumLevel(LogLevel.Warning);

Meld u aan bij het Program-bestand aan de clientzijde

Logboekregistratie wordt ondersteund in apps aan de clientzijde nadat de WebAssemblyHostBuilder is gebouwd met behulp van de interne consoleloggerprovider van het framework (WebAssemblyConsoleLoggerProvider (referentiebron)).

In het bestand Program:

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();

Console-uitvoer van ontwikkelhulpprogramma's:

info: Program[0]
Logged after the app is built in the Program file.

Notitie

Documentatiekoppelingen naar .NET-referentiebron laden meestal de standaardbranch van de opslagplaats, die de huidige ontwikkeling vertegenwoordigt voor de volgende release van .NET. Als u een tag voor een specifieke release wilt selecteren, gebruikt u de Switch-vertakkingen of tags vervolgkeuzelijst. Zie Een versietag selecteren van ASP.NET Core-broncode (dotnet/AspNetCore.Docs #26205)voor meer informatie.

Logboekcategorie aan clientzijde

logboekcategorieën worden ondersteund.

In het volgende voorbeeld ziet u hoe u logboekcategorieën gebruikt met het Counter onderdeel van een app die is gemaakt op basis van een Blazor projectsjabloon.

In de methode IncrementCount van het onderdeel Counter van de app (Counter.razor), waarmee een ILoggerFactory als LoggerFactorywordt geïnjecteerd:

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

Console-uitvoer van ontwikkelhulpprogramma's:

warn: CustomCategory[0]
Someone has clicked me!

Loggebeurtenis-id aan clientzijde

logboek gebeurtenis-id wordt ondersteund.

In het volgende voorbeeld ziet u hoe u logboekgebeurtenis-id's gebruikt met het Counter onderdeel van een app die is gemaakt op basis van een Blazor projectsjabloon.

LogEvent.cs:

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

In de IncrementCount-methode van het Counter-onderdeel van de app (Counter.razor):

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

Console-uitvoer van ontwikkelhulpprogramma's:

info: BlazorSample.Pages.Counter[1000]
Someone has clicked me!
warn: BlazorSample.Pages.Counter[1001]
Someone has clicked me!

Sjabloon voor logboekberichten aan clientzijde

sjablonen voor logboekberichten worden ondersteund:

In het volgende voorbeeld ziet u hoe u logboekberichtsjablonen gebruikt met het Counter onderdeel van een app die is gemaakt op basis van een Blazor projectsjabloon.

In de IncrementCount methode van het Counter-onderdeel van de app (Counter.razor):

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

Console-uitvoer van ontwikkelhulpprogramma's:

info: BlazorSample.Pages.Counter[0]
Someone clicked me at 04/21/2022 12:15:57!

Uitzonderingsparameters voor logboeken aan clientzijde

uitzonderingsparameters voor logboeken worden ondersteund.

In het volgende voorbeeld ziet u hoe u logboekuitzonderingsparameters gebruikt met het Counter onderdeel van een app die is gemaakt op basis van een Blazor projectsjabloon.

In de methode IncrementCount van het onderdeel Counter van de app (Counter.razor):

currentCount++;

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

Console-uitvoer van ontwikkelhulpprogramma's:

warn: BlazorSample.Pages.Counter[0]
Exception (currentCount: 4)!
System.OperationCanceledException: Skip 3
at BlazorSample.Pages.Counter.IncrementCount() in C:UsersAlabaDesktopBlazorSamplePagesCounter.razor:line 28

Filterfunctie aan clientzijde

filterfuncties worden ondersteund.

In het volgende voorbeeld ziet u hoe u een filter gebruikt met het Counter onderdeel van een app die is gemaakt op basis van een Blazor projectsjabloon.

In het bestand Program:

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

In de IncrementCount-methode van het Counter-onderdeel van de app (Counter.razor) dat een ILoggerFactory injecteert als LoggerFactory:

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!");

In de console-uitvoer van de ontwikkelaarshulpmiddelen staat het filter alleen toe dat er wordt gelogd voor de categorie CustomCategory2 en voor berichten op logniveau Information.

info: CustomCategory2[0]
Someone has clicked me!

De app kan ook logboekfiltering configureren voor specifieke naamruimten. Stel bijvoorbeeld het logboekniveau in op Trace in het Program-bestand:

builder.Logging.SetMinimumLevel(LogLevel.Trace);

Normaal gesproken bevat console-uitvoer van ontwikkelaarshulpprogramma's op het niveau van de TraceUitgebreideMicrosoft.AspNetCore.Components.RenderTree logboekregistratieberichten, zoals:

dbug: Microsoft.AspNetCore.Components.RenderTree.Renderer[3]
Rendering component 14 of type Microsoft.AspNetCore.Components.Web.HeadOutlet

In het Program-bestand kunnen de logboekregistratieberichten die specifiek zijn voor Microsoft.AspNetCore.Components.RenderTree worden uitgeschakeld met behulp van van de volgende methoden:

• builder.Logging.AddFilter("Microsoft.AspNetCore.Components.RenderTree.*", LogLevel.None);
  

• builder.Services.PostConfigure<LoggerFilterOptions>(options =>
      options.Rules.Add(
          new LoggerFilterRule(null, 
                               "Microsoft.AspNetCore.Components.RenderTree.*", 
                               LogLevel.None, 
                               null)
      ));
  

Nadat beide van de voorgaande filters aan de app zijn toegevoegd, worden in de console-uitvoer op het uitgebreid niveau geen logboekberichten van de Microsoft.AspNetCore.Components.RenderTree API weergegeven.

Aangepaste logboekprovider aan de kant van de cliënt

In het voorbeeld in deze sectie ziet u een aangepaste loggerprovider voor verdere aanpassing.

Voeg een pakketreferentie toe aan de app voor het Microsoft.Extensions.Logging.Configuration-pakket.

Notitie

Zie de artikelen onder Pakketten installeren en beheren bij Pakketconsumptieworkflow (NuGet-documentatie)voor hulp bij het toevoegen van pakketten aan .NET-apps. Bevestig de juiste pakketversies op NuGet.org.

Voeg de volgende aangepaste logboekregistratieconfiguratie toe. Met de configuratie wordt een LogLevels woordenlijst gemaakt waarmee een aangepaste logboekindeling wordt ingesteld voor drie logboekniveaus: Information, Warningen Error. Een LogFormatenum wordt gebruikt om korte (LogFormat.Short) en lange (LogFormat.Long) indelingen te beschrijven.

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
    }
}

Voeg de volgende aangepaste logger toe aan de app. De CustomLogger voert aangepaste logboekindelingen uit op basis van de logLevel waarden die zijn gedefinieerd in de voorgaande CustomLoggerConfiguration configuratie.

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;
            }
        }
    }
}

Voeg de volgende aangepaste loggerprovider toe aan de app. CustomLoggerProvider hanteert een op Optionsgebaseerde benadering om de logboekregistratie te configureren via ingebouwde configuratiefuncties voor logboekregistratie. De app kan bijvoorbeeld logboekindelingen instellen of wijzigen via een appsettings.json-bestand zonder dat codewijzigingen in de aangepaste logboekregistratie zijn vereist. Dit wordt aan het einde van deze sectie gedemonstreerd.

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();
    }
}

Voeg de volgende aangepaste loggerextensies toe.

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;
    }
}

Wis in het Program-bestand op de hostbuilder de bestaande provider door ClearProviders aan te roepen en voeg de aangepaste logboekregistratieprovider toe:

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

In het volgende CustomLoggerExample onderdeel:

• Het foutopsporingsbericht wordt niet vastgelegd.
• Het informatiebericht wordt vastgelegd in het korte formaat (LogFormat.Short).
• Het waarschuwingsbericht wordt vastgelegd in het korte formaat (LogFormat.Short).
• Het foutbericht wordt vastgelegd in de lange indeling (LogFormat.Long).
• Het traceringsbericht wordt niet geregistreerd.

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.");
    }
}

De volgende uitvoer wordt weergegeven in de console voor ontwikkelaarshulpprogramma's van de browser wanneer de knop Log Messages is geselecteerd. De logboekvermeldingen weerspiegelen de juiste indelingen die zijn toegepast door de aangepaste logger (de client-app is genaamd 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.

Bij een informele inspectie van het voorgaande voorbeeld is het duidelijk dat het instellen van de logboeklijnindelingen via de woordenlijst in CustomLoggerConfiguration niet strikt noodzakelijk is. De lijnindelingen die door de aangepaste logger (CustomLogger) zijn toegepast, hadden kunnen worden toegepast door eenvoudig de logLevel in de methode Log te controleren. Het doel van het toewijzen van de logboekindeling via configuratie is dat de ontwikkelaar de logboekindeling eenvoudig kan wijzigen via app-configuratie, zoals het volgende voorbeeld laat zien.

Voeg in de client-side app het appsettings.json-bestand toe of werk het bij voor logconfiguratie. Stel de logboekindeling in op Long voor alle drie de logboekniveaus:

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

In het voorgaande voorbeeld ziet u dat de invoer voor de configuratie van de aangepaste logger CustomLogis, die is toegepast op de aangepaste loggerprovider (CustomLoggerProvider) als alias met [ProviderAlias("CustomLog")]. De configuratie voor logboekregistratie kan zijn toegepast met de naam CustomLoggerProvider in plaats van CustomLog, maar het gebruik van de alias CustomLog is gebruiksvriendelijker.

Gebruik in het Program-bestand de configuratie voor logboekregistratie. Voeg de volgende code toe:

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

De aanroep naar LoggingBuilderConfigurationExtensions.AddConfiguration kan worden geplaatst voor of na het toevoegen van de aangepaste loggerprovider.

Voer de app opnieuw uit. Selecteer de knop Log Messages. U ziet dat de configuratie van logboekregistratie wordt toegepast op basis van het appsettings.json-bestand. Alle drie de logboekvermeldingen hebben de lange indeling (LogFormat.Long) (de client-app heeft de naam 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.

Logboekbereiken aan clientzijde

De consolelogger voor ontwikkelaarshulpprogramma's biedt geen ondersteuning voor logboekbereiken. Echter, een aangepaste logger kan logboekbereiken ondersteunen. Voor een niet-ondersteund voorbeeld dat u verder kunt ontwikkelen om aan uw behoeften te voldoen, zie de BlazorWebAssemblyScopesLogger voorbeeld-app in de GitHub-opslagplaats met Blazor voorbeelden (hoe te downloaden).

De voorbeeld-app gebruikt de standaardsyntaxis van ASP.NET Core BeginScope om scopes voor gelogde berichten aan te geven. De Logger-service in het volgende voorbeeld is een ILogger<CustomLoggerExample>, die wordt geïnjecteerd in het CustomLoggerExample-onderdeel van de app (CustomLoggerExample.razor).

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.");
        }
    }
}

Uitvoer:

[ 3: Informatie ] {CLASS} - INFO: Eén scope. => L1 blazor.webassembly.js:1:35542
[ 3: Informatie ] {CLASS} - INFO: TWEE gebieden. => L1 => L2 blazor.webassembly.js:1:35542
[ 3: Informatie ] {CLASS} - INFO: DRIE bereiken. => L1 => L2 => L3

De plaatsaanduiding {CLASS} in het vorige voorbeeld is BlazorWebAssemblyScopesLogger.Pages.CustomLoggerExample.

Logboekregistratie van vooraf gegenereerde onderdelen

Vooraf gegenereerde onderdelen voeren initialisatiecode voor onderdelen tweemaaluit. Logboekregistratie vindt plaats aan de serverzijde bij de eerste uitvoering van initialisatiecode en clientzijde bij de tweede uitvoering van initialisatiecode. Afhankelijk van het doel van logboekregistratie tijdens de initialisatie, controleert u de logboeken aan de serverzijde, de clientzijde of beide.

SignalR clientlogboekregistratie met de SignalR-clientbouwer

Deze sectie is van toepassing op apps aan de serverzijde.

In de Blazor scriptconfiguratie, geef het configureSignalR configuratieobject door dat configureLogging aanroept met het logniveau.

Geef voor de waarde van het configureLogging logboekniveau het argument door als het tekenreeks- of gehele logboekniveau dat in de volgende tabel wordt weergegeven.

LogLevel	Tekenreeksinstelling	Instelling voor geheel getal
Trace	trace	0
Debug	debug	1
Information	information	2
Warning	warning	3
Error	error	4
Critical	critical	5
None	none	6

Voorbeeld 1: Stel het Information logboekniveau in met een tekenreekswaarde.

Blazor Web App:

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

Blazor Server:

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

In het voorgaande voorbeeld is de tijdelijke aanduiding {BLAZOR SCRIPT} het scriptpad en de bestandsnaam van Blazor. Zie ASP.NET Core Blazor projectstructuurvoor de locatie van het script.

Voorbeeld 2: Stel het Information-logniveau in met een geheel getal.

Blazor Web App:

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

Blazor Server:

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

In het voorgaande voorbeeld is de tijdelijke aanduiding {BLAZOR SCRIPT} het Blazor scriptpad en de bestandsnaam. Zie ASP.NET Core Blazor projectstructuurvoor de locatie van het script.

Notitie

Het gebruik van een geheel getal om het logboekregistratieniveau in voorbeeld 2 op te geven, vaak een magic number of magic constant, wordt beschouwd als een slechte coderingspraktijk omdat het gehele getal het logboekregistratieniveau niet duidelijk identificeert bij het weergeven van de broncode. Als het minimaliseren van de bytes die naar de browser worden overgebracht een prioriteit is, kan het gebruik van een geheel getal gerechtvaardigd zijn (overweeg de opmerking in dergelijke gevallen te verwijderen).

Zie ASP.NET Core Blazor startupvoor meer informatie over Blazor opstarten (Blazor.start()).

SignalR clientlogboekregistratie met app-configuratie

Configuratie van app-instellingen instellen zoals beschreven in ASP.NET Core Blazor configuratie. Plaats app-instellingenbestanden in wwwroot die een Logging:LogLevel:HubConnection app-instelling bevatten.

Notitie

Als alternatief voor het gebruik van app-instellingen kunt u de LogLevel als argument doorgeven aan LoggingBuilderExtensions.SetMinimumLevel wanneer de hubverbinding wordt gemaakt in een Razor-onderdeel. Het per ongeluk implementeren van de app in een productiehostingomgeving met uitgebreide logboekregistratie kan echter leiden tot een prestatiestraf. U wordt aangeraden app-instellingen te gebruiken om het logboekniveau in te stellen.

Geef een Logging:LogLevel:HubConnection-app-instelling op in het standaardbestand appsettings.json en in het instellingenbestand van de Development-omgevingsapp. Gebruik een typisch minder uitgebreid logboekniveau voor de standaardinstelling, zoals LogLevel.Warning. De standaardwaarde voor app-instellingen is wat wordt gebruikt in Staging en Production omgevingen als er geen app-instellingenbestanden voor deze omgevingen aanwezig zijn. Gebruik een uitgebreid logniveau in het bestand met instellingen voor de Development omgevingstoepassing, zoals 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"
    }
  }
}

Belangrijk

Configuratie in de voorgaande app-instellingenbestanden wordt alleen door de app gebruikt als de richtlijnen in ASP.NET Core Blazor configuratie worden gevolgd.

Bovenaan het Razor-componentbestand (.razor):

• Injecteer een ILoggerProvider om een WebAssemblyConsoleLogger toe te voegen aan de loggingproviders die zijn doorgegeven aan HubConnectionBuilder. In tegenstelling tot een ConsoleLoggerProvideris WebAssemblyConsoleLogger een wrapper rond browserspecifieke logboekregistratie-API's (bijvoorbeeld console.log). Het gebruik van WebAssemblyConsoleLogger maakt logboekregistratie mogelijk in Mono binnen een browsercontext.
• Injecteer een IConfiguration om de instelling van de Logging:LogLevel:HubConnection-app te lezen.

Notitie

WebAssemblyConsoleLogger wordt interne en wordt niet ondersteund voor direct gebruik in ontwikkelaarscode.

@inject ILoggerProvider LoggerProvider
@inject IConfiguration Config

Notitie

Het volgende voorbeeld is gebaseerd op de demonstratie in de SignalR met Blazor zelfstudie. Raadpleeg de handleiding voor meer informatie.

Gebruik in de OnInitializedAsync methode van het onderdeelHubConnectionBuilderExtensions.ConfigureLogging om de logboekprovider toe te voegen en het minimale logboekniveau in te stellen vanuit de configuratie:

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();
}

Notitie

In het voorgaande voorbeeld is Navigation een geïnjecteerde NavigationManager.

Zie ASP.NET Core Blazor-omgevingenvoor meer informatie over het instellen van de omgeving van de app.

Logboekregistratie van verificatie aan de clientzijde

Log Blazor verificatieberichten op de LogLevel.Debug of LogLevel.Trace logniveaus met een logconfiguratie in de app-instellingen of met behulp van een logfilter voor Microsoft.AspNetCore.Components.WebAssembly.Authentication in het bestand Program.

Gebruik van de volgende methoden:

• In een app-instellingenbestand (bijvoorbeeld wwwroot/appsettings.Development.json):

  "Logging": {
    "LogLevel": {
      "Microsoft.AspNetCore.Components.WebAssembly.Authentication": "Debug"
    }
  }
  

  Zie ASP.NET Core Blazor-configuratievoor meer informatie over het configureren van een client-side app om instellingsbestanden te lezen.

• Met behulp van een logboekfilter, het volgende voorbeeld:

  • Activeert logboekregistratie voor de Debug buildconfiguratie met behulp van een C#-preprocessorrichtlijn.
  • Registreert Blazor verificatieberichten op Debug logboekniveau.

  #if DEBUG
      builder.Logging.AddFilter(
          "Microsoft.AspNetCore.Components.WebAssembly.Authentication", 
          LogLevel.Debug);
  #endif
  

Notitie

Razor onderdelen die op de client worden weergegeven, worden alleen aangemeld bij de clientzijde hulpprogramma's voor browserontwikkelaars console.

Aanvullende informatiebronnen

• Logboekregistratie in .NET Core en ASP.NET Core
• Loglevel Enum (API-documentatie)
• een aangepaste logboekregistratieprovider implementeren in .NET
• Documentatie voor hulpprogramma's voor browserontwikkelaars:
  • Chrome DevTools
  • Overzicht van Microsoft Edge Developer Tools
• Blazor GitHub-repository (dotnet/blazor-samples) (hoe je kunt downloaden van)