ASP.NET Core-loggning Blazor

2025-07-30

Note

Det här är inte den senaste versionen av den här artikeln. För den nuvarande utgåvan, se .NET 9-versionen av den här artikeln .

Warning

Den här versionen av ASP.NET Core stöds inte längre. Mer information finns i supportpolicyn för .NET och .NET Core. För den nuvarande utgåvan, se .NET 9-versionen av den här artikeln .

Important

Den här informationen gäller en förhandsversionsprodukt som kan ändras avsevärt innan den släpps kommersiellt. Microsoft lämnar inga garantier, uttryckliga eller underförstådda, med avseende på den information som tillhandahålls här.

För den nuvarande utgåvan, se .NET 9-versionen av den här artikeln .

Den här artikeln beskriver Blazor apploggning, inklusive konfiguration och hur du skriver loggmeddelanden från Razor komponenter.

Configuration

Loggningskonfigurationen kan läsas in från appinställningarsfiler. Mer information finns i ASP.NET Core Blazor configuration.

På standardloggnivåer och utan att konfigurera ytterligare loggningsproviders:

På servern sker loggning endast till .NET-konsolen på serversidan i Development miljön på nivån LogLevel.Information eller högre.
På klienten sker loggning endast till konsolen för webbläsarutvecklare på klientsidan på nivån LogLevel.Information eller högre.

När appen har konfigurerats i projektfilen för att använda implicita namnområden (<ImplicitUsings>enable</ImplicitUsings>) krävs inte ett using direktiv för eller något API i LoggerExtensions klassen för Microsoft.Extensions.Logging att stödja API Visual Studio IntelliSense-slutföranden eller skapa appar. Om implicita namnområden inte är aktiverade Razor måste komponenter uttryckligen definiera @using direktiv för loggning av namnområden som inte importeras via _Imports.razor filen.

Log levels

Loggnivåerna överensstämmer med ASP.NET Core-apploggnivåer, som visas i API-dokumentationen på LogLevel.

Razor komponentloggning

Direktivet using för krävs för Microsoft.Extensions.Logging att stödja IntelliSense-slutföranden för API:er, till exempel LogWarning och LogError.

Följande exempel:

Matar in ett ILogger (ILogger<Counter1>) objekt för att skapa en logger. Loggens kategori är det fullständigt kvalificerade namnet på komponentens typ, Counter.
Anrop LogWarning för att logga på Warning nivån.

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

I följande exempel visas loggning med en ILoggerFactory i-komponenter.

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

Server-side logging

Allmän vägledning för ASP.NET Core-loggning finns i Loggning i .NET och ASP.NET Core.

Client-side logging

Alla funktioner i ASP.NET Core-loggning stöds inte på klientsidan. Komponenter på klientsidan har till exempel inte åtkomst till klientens filsystem eller nätverk, så det går inte att skriva loggar till klientens fysiska lagring eller nätverkslagring. När du använder en loggningstjänst från tredje part som är utformad för att fungera med ensidesappar (SPA) följer du tjänstens säkerhetsvägledning. Tänk på att alla data, inklusive nycklar eller hemligheter som lagras på klientsidan, är osäkra och lätt kan identifieras av skadliga användare.

Beroende på ramverkets version och loggningsfunktioner kan loggningsimplementeringar kräva att namnområdet läggs Microsoft.Extensions.Logging till i Program filen:

using Microsoft.Extensions.Logging;

Konfigurera loggning i appar på klientsidan med egenskapen WebAssemblyHostBuilder.Logging . Egenskapen Logging är av typen ILoggingBuilder, så tilläggsmetoderna ILoggingBuilder för stöds.

Om du vill ange lägsta loggningsnivå anropar LoggingBuilderExtensions.SetMinimumLevel du värdverktyget i Program filen med LogLevel. I följande exempel anges den lägsta loggnivån till Warning:

builder.Logging.SetMinimumLevel(LogLevel.Warning);

Logga in filen på klientsidan `Program`

Loggning stöds i appar på klientsidan när den WebAssemblyHostBuilder har skapats med ramverkets interna konsolloggningsprovider (WebAssemblyConsoleLoggerProvider (referenskälla)).

Program I filen:

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

Konsolutdata för utvecklarverktyg:

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

Note

Dokumentationslänkar till .NET-referenskällan läser vanligtvis in lagringsplatsens standardgren, vilket representerar den aktuella utvecklingen för nästa version av .NET. Om du vill välja en tagg för en specifik version använder du listrutan Välj bland grenar eller taggar. Mer information finns i Så här väljer du en versionstagg för ASP.NET Core-källkod (dotnet/AspNetCore.Docs #26205).

Loggkategori på klientsidan

Loggkategorier stöds.

I följande exempel visas hur du använder loggkategorier med komponenten i Counter en app som skapats från en Blazor projektmall.

IncrementCount I metoden för appens Counter komponent (Counter.razor) som matar in en ILoggerFactory som LoggerFactory:

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

Konsolutdata för utvecklarverktyg:

warn: CustomCategory[0]
Someone has clicked me!

Händelse-ID för logg på klientsidan

Logghändelse-ID stöds.

I följande exempel visas hur du använder logghändelse-ID:t med komponenten i Counter en app som skapats från en Blazor projektmall.

LogEvent.cs:

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

IncrementCount I metoden för appens Counter komponent (Counter.razor):

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

Konsolutdata för utvecklarverktyg:

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

Mall för loggmeddelande på klientsidan

Loggmeddelandemallar stöds:

I följande exempel visas hur du använder loggmeddelandemallar med komponenten i Counter en app som skapats från en Blazor projektmall.

IncrementCount I metoden för appens Counter komponent (Counter.razor):

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

Konsolutdata för utvecklarverktyg:

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

Undantagsparametrar för logg på klientsidan

Loggfelparametrar stöds.

I följande exempel visas hur du använder logg undantagsparametrar med komponenten i Counter en app som skapats från en Blazor projektmall.

IncrementCount I metoden för appens Counter komponent (Counter.razor):

currentCount++;

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

Konsolutdata för utvecklarverktyg:

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

Filterfunktion på klientsidan

Filterfunktioner stöds.

I följande exempel visas hur du använder ett filter med komponenten i Counter en app som skapats från en Blazor projektmall.

Program I filen:

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

IncrementCount I metoden för appens Counter komponent (Counter.razor) som matar in en ILoggerFactory som 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!");

I utvecklarverktygskonsolens utdata tillåter filtret endast loggning för CustomCategory2 kategori- och Information loggnivåmeddelandet:

info: CustomCategory2[0]
Someone has clicked me!

Appen kan också konfigurera loggfiltrering för specifika namnområden. Ange till exempel loggnivån till Trace i Program filen:

builder.Logging.SetMinimumLevel(LogLevel.Trace);

Normalt på Trace loggnivå innehåller Microsoft.AspNetCore.Components.RenderTree utvecklarverktygskonsolens utdata på utförlig nivå loggningsmeddelanden, till exempel följande:

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

Program I filen kan loggningsmeddelanden som är specifika för Microsoft.AspNetCore.Components.RenderTree inaktiveras med någon av följande metoder:

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

När något av de föregående filtren har lagts till i appen visas inte loggningsmeddelanden från API:et Microsoft.AspNetCore.Components.RenderTree i konsolens utdata på utförlig nivå.

Anpassad loggningsprovider på klientsidan

Exemplet i det här avsnittet visar en anpassad loggningsprovider för ytterligare anpassning.

Lägg till en paketreferens till appen för Microsoft.Extensions.Logging.Configuration paketet.

Note

Vägledning om hur du lägger till paket i .NET-appar finns i artiklarna under Installera och hantera paket i arbetsflödet för paketförbrukning (NuGet-dokumentation). Bekräfta rätt paketversioner på NuGet.org.

Lägg till följande anpassade loggningskonfiguration. Konfigurationen upprättar en LogLevels ordlista som anger ett anpassat loggformat för tre loggnivåer: Information, Warningoch Error. A LogFormatenum används för att beskriva korta (LogFormat.Short) och långa (LogFormat.Long) format.

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

Lägg till följande anpassade loggning i appen. Utdata CustomLogger för anpassade loggformat baserat på de logLevel värden som definierats i föregående CustomLoggerConfiguration konfiguration.

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

Lägg till följande anpassade loggningsprovider i appen. CustomLoggerProvider använder en Options-baserad metod för att konfigurera loggaren via inbyggda konfigurationsfunktioner för loggning. Appen kan till exempel ange eller ändra loggformat via en appsettings.json fil utan att kräva kodändringar i den anpassade loggaren, vilket visas i slutet av det här avsnittet.

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

Lägg till följande anpassade loggningstillägg.

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

Program I filen på värdverktyget rensar du den befintliga providern genom att anropa ClearProviders och lägga till den anpassade loggningsprovidern:

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

I den följande CustomLoggerExample-komponenten:

Felsökningsmeddelandet loggas inte.
Informationsmeddelandet loggas i kort format (LogFormat.Short).
Varningsmeddelandet loggas i kort format (LogFormat.Short).
Felmeddelandet loggas i långt format (LogFormat.Long).
Spårningsmeddelandet loggas inte.

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

Följande utdata visas i webbläsarens utvecklarverktygskonsol när Log Messages knappen väljs. Loggposterna återspeglar lämpliga format som tillämpas av den anpassade loggaren (klientappen heter 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.

Från en tillfällig inspektion av föregående exempel är det uppenbart att det inte är absolut nödvändigt att ange logglinjeformaten via ordlistan i CustomLoggerConfiguration . De linjeformat som tillämpas av den anpassade loggaren (CustomLogger) kunde ha tillämpats genom att bara kontrollera logLevel i Log -metoden. Syftet med att tilldela loggformatet via konfiguration är att utvecklaren enkelt kan ändra loggformatet via appkonfigurationen, vilket visas i följande exempel.

I appen på klientsidan lägger du till eller uppdaterar filen så att den appsettings.json innehåller loggningskonfiguration. Ange loggformatet till Long för alla tre loggnivåerna:

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

I föregående exempel ser du att posten för den anpassade loggningskonfigurationen är CustomLog, som tillämpades på den anpassade loggningsprovidern (CustomLoggerProvider) som ett alias med [ProviderAlias("CustomLog")]. Loggningskonfigurationen kunde ha tillämpats med namnet CustomLoggerProvider i stället för CustomLog, men användningen av aliaset CustomLog är mer användarvänlig.

Program I filen använder du loggningskonfigurationen. Lägg till följande kod:

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

Anropet till LoggingBuilderConfigurationExtensions.AddConfiguration kan göras antingen före eller efter att du har lagt till den anpassade loggningsprovidern.

Kör appen igen. Välj knappen Log Messages. Observera att loggningskonfigurationen tillämpas från appsettings.json filen. Alla tre loggposterna är i långt (LogFormat.Long) format (klientappen heter 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.

Loggomfattningar på klientsidan

Konsolloggaren för utvecklarverktyg stöder inte loggomfattningar. En anpassad loggare kan dock ha stöd för loggomfattningar. Ett exempel som inte stöds som du kan utveckla ytterligare för att passa dina behov finns i exempelappen BlazorWebAssemblyScopesLoggerBlazor på GitHub-lagringsplatsen exempel (så här laddar du ned).

Exempelappen använder standardsyntaxen för ASP.NET Core-loggning BeginScope för att ange omfång för loggade meddelanden. Tjänsten Logger i följande exempel är en ILogger<CustomLoggerExample>, som matas in i appens CustomLoggerExample komponent (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.");
        }
    }
}

Output:

[ 3: Information ] {CLASS} – INFO: ETT omfång. => L1 blazor.webassembly.js:1:35542
[ 3: Information ] {CLASS} – INFO: TVÅ omfång. => L1 => L2 blazor.webassembly.js:1:35542
[ 3: Information ] {CLASS} – INFO: TRE omfång. => L1 => L2 => L3

Platshållaren {CLASS} i föregående exempel är BlazorWebAssemblyScopesLogger.Pages.CustomLoggerExample.

Fördefinierad komponentloggning

Förrendererade komponenter kör komponentinitieringskod två gånger. Loggning sker på serversidan vid den första körningen av initieringskoden och klientsidan vid den andra körningen av initieringskoden. Beroende på målet med loggning under initieringen kontrollerar du loggarna på serversidan, klientsidan eller båda.

SignalR klientloggning med SignalR klientverktyget

Det här avsnittet gäller för appar på serversidan.

I Blazor konfigurationen för skriptstart skickar du in konfigurationsobjektet configureSignalR som anropar configureLogging med loggnivån.

configureLogging För loggnivåvärdet skickar du argumentet som antingen sträng- eller heltalsloggnivån som visas i följande tabell.

LogLevel	String setting	Integer setting
Trace	`trace`	0
Debug	`debug`	1
Information	`information`	2
Warning	`warning`	3
Error	`error`	4
Critical	`critical`	5
None	`none`	6

Exempel 1: Ange Information loggnivån med ett strängvärde.

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>

I det föregående exemplet representerar platshållaren {BLAZOR SCRIPT} skriptsökvägen och filnamnet för Blazor. Platsen för skriptet finns i ASP.NET Core Blazor projektstruktur.

Exempel 2: Ange Information loggnivån med ett heltalsvärde.

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>

I det föregående exemplet representerar platshållaren {BLAZOR SCRIPT} skriptsökvägen och filnamnet för Blazor. Platsen för skriptet finns i ASP.NET Core Blazor projektstruktur.

Note

Att använda ett heltal för att ange loggningsnivån i exempel 2, som ofta kallas ett magiskt tal eller en magisk konstant, anses vara en dålig kodningspraxis eftersom heltalet inte tydligt identifierar loggningsnivån när källkoden visas. Om det är en prioritet att minimera de byte som överförs till webbläsaren kan det vara motiverat att använda ett heltal (överväg att ta bort kommentaren i sådana fall).

Mer information om Blazor start (Blazor.start()) finns i ASP.NET Core-startBlazor.

SignalR klientloggning med appkonfiguration

Konfigurera konfiguration av appinställningar enligt beskrivningen i ASP.NET Core-konfigurationBlazor. Placera appinställningar i wwwroot som innehåller en Logging:LogLevel:HubConnection appinställning.

Note

Som ett alternativ till att använda appinställningar kan du skicka LogLevel som argument till LoggingBuilderExtensions.SetMinimumLevel när hubbanslutningen skapas i en Razor komponent. Om du av misstag distribuerar appen till en produktionsvärdmiljö med utförlig loggning kan det dock leda till prestandastraff. Vi rekommenderar att du använder appinställningar för att ange loggnivån.

Ange en Logging:LogLevel:HubConnection appinställning i standardfilen appsettings.json och i miljöappens inställningsfil Development . Använd en typisk mindre utförlig loggnivå för standardvärdet, till exempel LogLevel.Warning. Standardvärdet för appinställningar är det som används i Staging och Production miljöer om det inte finns några appinställningar för dessa miljöer. Använd en utförlig loggnivå i miljöappens Development inställningsfil, till exempel 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"
    }
  }
}

Important

Konfigurationen i de föregående appinställningsfilerna används endast av appen om vägledningen i ASP.NET Core-konfigurationen Blazor följs.

Överst i Razor komponentfilen (.razor):

Mata in en ILoggerProvider för att lägga till en WebAssemblyConsoleLogger till loggningsprovidrar som skickas till HubConnectionBuilder. Till skillnad från en ConsoleLoggerProvider, WebAssemblyConsoleLogger är en omslutning kring webbläsarspecifika loggnings-API:er (till exempel console.log). Användning av WebAssemblyConsoleLogger gör loggning möjlig i Mono i en webbläsarkontext.
Mata in en IConfiguration för att läsa appinställningen Logging:LogLevel:HubConnection .

Note

WebAssemblyConsoleLogger är internt och stöds inte för direkt användning i utvecklarkod.

@inject ILoggerProvider LoggerProvider
@inject IConfiguration Config

Note

Följande exempel baseras på demonstrationen i självstudiekursenSignalRBlazor. Mer information finns i självstudien.

I komponentens metod använder du HubConnectionBuilderExtensions.ConfigureLogging för att lägga till loggningsprovidern OnInitializedAsyncoch ange den lägsta loggnivån från konfigurationen:

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

Note

I föregående exempel Navigation är en inmatad NavigationManager.

Mer information om hur du ställer in appens miljö finns i ASP.NET Core-miljöerBlazor.

Autentiseringsloggning på klientsidan

Logga Blazor autentiseringsmeddelanden på LogLevel.Debug loggningsnivåer eller LogLevel.Trace med en loggningskonfiguration i appinställningarna eller med hjälp av ett loggfilter för Microsoft.AspNetCore.Components.WebAssembly.Authentication i Program filen.

Använd någon av följande metoder:

I en appinställningsfil (till exempel wwwroot/appsettings.Development.json):
```
"Logging": {
  "LogLevel": {
    "Microsoft.AspNetCore.Components.WebAssembly.Authentication": "Debug"
  }
}
```
Mer information om hur du konfigurerar en app på klientsidan för att läsa appinställningarsfiler finns i ASP.NET Core-konfigurationBlazor.
Med hjälp av ett loggfilter, följande exempel:
- Aktiverar loggning för byggkonfigurationen Debug med hjälp av ett C#-förprocessordirektiv.
- Loggar autentiseringsmeddelanden Blazor på Debug loggnivå.
```
#if DEBUG
    builder.Logging.AddFilter(
        "Microsoft.AspNetCore.Components.WebAssembly.Authentication", 
        LogLevel.Debug);
#endif
```

Note

Razor komponenter som återges i klientloggen endast till konsolen för webbläsarutvecklare på klientsidan.

Additional resources

Loggning i .NET och ASP.NET Core
Loglevel Uppräkning (API-dokumentation)
Implementera en anpassad loggningsprovider i .NET
Dokumentation om utvecklarverktyg för webbläsare:
- Chrome DevTools
- översikt över Microsoft Edge Developer Tools
Blazor exempel på GitHub-lagringsplats (dotnet/blazor-samples) (hur du laddar ned)

Feedback

Var den här sidan till hjälp?

Dela via

ASP.NET Core-loggning Blazor

Configuration

Log levels

Razor komponentloggning

Server-side logging

Client-side logging

Logga in filen på klientsidan Program

Loggkategori på klientsidan

Händelse-ID för logg på klientsidan

Mall för loggmeddelande på klientsidan

Undantagsparametrar för logg på klientsidan

Filterfunktion på klientsidan

Anpassad loggningsprovider på klientsidan

Loggomfattningar på klientsidan

Fördefinierad komponentloggning

SignalR klientloggning med SignalR klientverktyget

SignalR klientloggning med appkonfiguration

Autentiseringsloggning på klientsidan

Additional resources

Feedback

Ytterligare resurser

Logga in filen på klientsidan `Program`