ASP.NET Alapszintű Blazor naplózás

Ez a cikk az alkalmazás naplózását ismerteti Blazor, beleértve a konfigurációt és a naplóüzenetek írását az összetevőkből Razor.

Configuration

A naplózási konfiguráció betölthető az alkalmazásbeállítások fájljaiból. További információ: ASP.NET Core-konfigurációBlazor.

Alapértelmezett naplózási szinteken és további naplózási szolgáltatók konfigurálása nélkül:

• A kiszolgálón a naplózás csak a kiszolgálóoldali .NET-konzolra történik a Development környezetben a LogLevel.Information szinten vagy annál magasabb szinten.
• Az ügyfélen a naplózás csak az ügyféloldali böngésző fejlesztői eszközeinek konzolján történik, LogLevel.Information vagy annál magasabb szinten.

Ha az alkalmazás implicit névterek (<ImplicitUsings>enable</ImplicitUsings>) használatára van konfigurálva a projektfájlban, using akkor az osztály egyik API-jának Microsoft.Extensions.Logging irányelve sem szükséges az LoggerExtensions API Visual Studio IntelliSense-befejezésének támogatásához vagy az alkalmazások létrehozásához. Ha az implicit névterek nincsenek engedélyezve, Razor az összetevőknek explicit módon meg kell határozniuk @using a _Imports.razor fájlon keresztül nem importált naplózási névterekre vonatkozó irányelveket.

Naplózási szintek

A naplószintek megfelelnek ASP.NET Core-alkalmazásnapló-szinteknek, amelyek a következő LogLevelAPI-dokumentációban találhatók: .

Razor komponens naplózása

A következő példa:

• Beszúr egy ILogger (ILogger<Counter1>) objektumot egy naplózó létrehozásához. A napló kategóriája az összetevő típusának teljes neve. Counter
• Meghívja LogWarning, hogy Warning szinten jelentkezzen be.

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

Az alábbi példa egy ILoggerFactory naplózását mutatja be komponensekben.

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

Kiszolgálóoldali naplózás

Az általános ASP.NET Core-naplózási útmutatót a .NET-ben és a ASP.NET Core-ban történő naplózással kapcsolatban talál.

Ügyféloldali naplózás

A ASP.NET Core naplózás nem minden funkciója támogatott ügyféloldali. Az ügyféloldali összetevők például nem férnek hozzá az ügyfél fájlrendszeréhez vagy hálózatához, ezért nem lehet naplókat írni az ügyfél fizikai vagy hálózati tárolójába. Ha egy harmadik fél naplózási szolgáltatását használja egyoldalas alkalmazásokhoz (SPA-k), kövesse a szolgáltatás biztonsági útmutatóját. Ne feledje, hogy minden adat, beleértve az ügyféloldalon tárolt kulcsokat vagy titkos kulcsokat is, nem biztonságosak , és a rosszindulatú felhasználók könnyen felfedezhetik őket.

Konfigurálja a naplózást az ügyféloldali alkalmazásokban a WebAssemblyHostBuilder.Logging tulajdonsággal. A Logging tulajdonság típusa ILoggingBuilder, ezért a bővítménymódszerek ILoggingBuilder támogatottak.

A minimális naplózási szint beállításához hívja meg a "LoggingBuilderExtensions.SetMinimumLevel"-t a host builderen a "Program" fájlban a "LogLevel"-vel. Az alábbi példa a minimális naplószintet a következő értékre állítja Warning:

builder.Logging.SetMinimumLevel(LogLevel.Warning);

Jelentkezzen be az ügyféloldali Program fájlba

A naplózás az ügyféloldali alkalmazásokban támogatott, miután a WebAssemblyHostBuilder keretrendszer belső konzolnapló-szolgáltatójával (WebAssemblyConsoleLoggerProvider referenciaforrás)) készült.

A Program fájlban:

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

Fejlesztői eszközök konzolkimenete:

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

Note

A .NET referenciaforrásra mutató dokumentációs hivatkozások általában betöltik az adattár alapértelmezett ágát, amely a .NET következő kiadásának aktuális fejlesztését jelöli. Egy adott kiadás címkéjének kiválasztásához használja az Ágak vagy címkék közötti váltás legördülő listát. További információ: A ASP.NET Core-forráskód (dotnet/AspNetCore.Docs #26205) verziócímkéjének kiválasztása.

Ügyféloldali naplókategória

A naplókategóriák támogatottak.

Az alábbi példa bemutatja, hogyan használhat naplókategóriákat egy Counter projektsablonból Blazor létrehozott alkalmazás összetevőjével.

IncrementCount Az alkalmazás Counter összetevőjének (Counter.razor) azon metódusában, amely ILoggerFactory-t LoggerFactory néven injektál:

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

Fejlesztői eszközök konzolkimenete:

warn: CustomCategory[0]
Someone has clicked me!

Ügyféloldali napló eseményazonosítója

A naplóesemény-azonosító támogatott.

Az alábbi példa bemutatja, hogyan használhat naplóesemény-azonosítókat egy Counter projektsablonból Blazor létrehozott alkalmazás összetevőjével.

LogEvent.cs:

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

Az alkalmazás IncrementCount összetevőjének Counter metódusában (Counter.razor):

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

Fejlesztői eszközök konzolkimenete:

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

Ügyféloldali naplóüzenetsablon

A naplóüzenet-sablonok támogatottak:

Az alábbi példa bemutatja, hogyan használhat naplóüzenetsablonokat egy Counter projektsablonból Blazor létrehozott alkalmazás összetevőjével.

Az alkalmazás IncrementCount összetevőjének Counter metódusában (Counter.razor):

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

Fejlesztői eszközök konzolkimenete:

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

Ügyféloldali naplókivételi paraméterek

A naplókivételi paraméterek támogatottak.

Az alábbi példa bemutatja, hogyan használhat naplókivételi paramétereket egy Counter projektsablonból Blazor létrehozott alkalmazás összetevőjével.

Az alkalmazás IncrementCount összetevőjének Counter metódusában (Counter.razor):

currentCount++;

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

Fejlesztői eszközök konzolkimenete:

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

Ügyféloldali szűrőfüggvény

A szűrőfüggvények támogatottak.

Az alábbi példa bemutatja, hogyan használhat szűrőt egy Counter projektsablonból Blazor létrehozott alkalmazás összetevőjével.

A Program fájlban:

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

IncrementCount Az alkalmazás Counter összetevőjének (Counter.razor) azon metódusában, amely ILoggerFactory-t LoggerFactory néven injektál:

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

A fejlesztői eszközök konzoljának kimenetében a szűrő csak azoknak az üzeneteknek a naplózását engedélyezi, amelyek a CustomCategory2 kategóriához és a Information naplószinthez tartoznak.

info: CustomCategory2[0]
Someone has clicked me!

Az alkalmazás adott névterek naplószűrését is konfigurálhatja. Például állítsa be a naplószintet Trace a Program fájlban:

builder.Logging.SetMinimumLevel(LogLevel.Trace);

A Trace naplószinten a fejlesztői eszközök konzoljának kimenete általában a Részletes szinten a következő naplózási üzeneteket tartalmazza, példáulMicrosoft.AspNetCore.Components.RenderTree:

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

A Program fájlban a Microsoft.AspNetCore.Components.RenderTree-hez tartozó naplózási üzenetek az alábbi módszerek egyikével letilthatók:

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

Miután az előző szűrők egyikét hozzáadja az alkalmazáshoz, a konzol kimenet részletes szinten nem jeleníti meg az API naplózási Microsoft.AspNetCore.Components.RenderTree üzeneteit.

Ügyféloldali egyéni naplózó szolgáltató

Az ebben a szakaszban szereplő példa egy egyéni naplózó szolgáltatót mutat be a további testreszabáshoz.

Adjon hozzá egy csomaghivatkozást a Microsoft.Extensions.Logging.Configuration csomag alkalmazásához.

Note

A csomagok .NET-alkalmazásokhoz való hozzáadásáról a Csomagok telepítése és kezelésea csomaghasználati munkafolyamatban (NuGet-dokumentáció) című cikkben talál útmutatást. Ellenőrizze a megfelelő csomagverziókat a NuGet.org.

Adja hozzá az alábbi egyéni naplózó-konfigurációt. A konfiguráció létrehoz egy LogLevels szótárat, amely egyéni naplóformátumot állít be három naplószinthez: Information, Warningés Error. Az A LogFormatenum rövid (LogFormat.Short) és hosszú (LogFormat.Long) formátumok leírására szolgál.

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

Adja hozzá az alábbi egyéni naplózót az alkalmazáshoz. A CustomLogger az előző logLevel konfigurációban meghatározott CustomLoggerConfiguration értékek alapján egyéni naplóformátumokat ad ki.

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

Adja hozzá az alábbi egyéni naplózási szolgáltatót az alkalmazáshoz. CustomLoggerProvider egy Options alapú megközelítést alkalmaz a naplózó konfigurálásához a beépített naplózási konfigurációs funkciók révén. Az alkalmazás például beállíthatja vagy módosíthatja a naplóformátumokat egy appsettings.json fájlon keresztül anélkül, hogy kódmódosítást kellene végeznie az egyéni naplózón, amelyet a szakasz végén mutatunk be.

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

Adja hozzá a következő egyéni naplózóbővítményeket.

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 A gazdanépítő fájlban törölje a meglévő szolgáltatót a ClearProviders hívásával, majd adja hozzá az egyéni naplózási szolgáltatót:

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

Az alábbi CustomLoggerExample összetevőben:

• A hibakeresési üzenet nincs naplózva.
• Az információs üzenet rövid formátumban (LogFormat.Short) van naplózva.
• A figyelmeztető üzenet rövid formátumban (LogFormat.Short) van naplózva.
• A hibaüzenet hosszú formátumban (LogFormat.Long) van naplózva.
• A nyomkövetési üzenet nincs naplózva.

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

A következő kimenet jelenik meg a böngésző fejlesztői eszközeinek konzolján, amikor a Log Messages gomb ki van választva. A naplóbejegyzések az egyéni naplózó által alkalmazott megfelelő formátumokat tükrözik (az ügyfélalkalmazás neve 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.

Az előző példa alkalmi vizsgálatából látható, hogy a naplósor-formátumok szótáron CustomLoggerConfiguration keresztüli beállítása nem feltétlenül szükséges. Az egyéni naplózó (CustomLogger) által alkalmazott sorformátumokat a metódusban való ellenőrzéssel logLevelLog lehetett volna alkalmazni. A naplóformátum konfiguráción keresztüli hozzárendelésének célja, hogy a fejlesztő egyszerűen módosíthatja a naplóformátumot az alkalmazáskonfiguráción keresztül, ahogyan azt az alábbi példa szemlélteti.

Az ügyféloldali alkalmazásban adja hozzá vagy frissítse a fájlt, hogy tartalmazza a appsettings.json naplózási konfigurációt. Állítsa be a naplóformátumot Long mindhárom naplószintre:

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

Az előző példában vegye észre, hogy az egyéni naplózó konfigurációjának CustomLog bejegyzése az egyéni naplózó szolgáltatóra (CustomLoggerProvider) lett alkalmazva az alábbi alias formájában: [ProviderAlias("CustomLog")]. A naplózási konfigurációt a névvel CustomLoggerProviderCustomLoglehetett volna alkalmazni, de az alias CustomLog használata felhasználóbarátabb.

A Program fájlban alkalmazza a naplózási konfigurációt. Adja hozzá a következő kódot:

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

A LoggingBuilderConfigurationExtensions.AddConfiguration hívása az egyéni naplózó szolgáltató hozzáadása előtt vagy után is elhelyezhető.

Futtassa újra az alkalmazást. Válassza a Log Messages gombot. Figyelje meg, hogy a naplózási konfiguráció a appsettings.json fájlból van alkalmazva. Mindhárom naplóbejegyzés hosszú (LogFormat.Long) formátumú (az ügyfélalkalmazás neve 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.

Ügyféloldali napló hatókörei

A fejlesztői eszközök konzolnaplózója nem támogatja a napló hatóköreit. Egy egyéni naplózó azonban támogathatja a naplózási hatóköröket. Ha nem támogatott példát szeretne, amely az igényeinek megfelelően tovább fejleszthető, tekintse meg a BlazorWebAssemblyScopesLoggermintaalkalmazást aBlazor GitHub-adattárban (letöltés).

A mintaalkalmazás szabványos ASP.NET Core BeginScope naplózási szintaxissal jelzi a naplózott üzenetek hatóköreit. A Logger következő példában szereplő szolgáltatás egy ILogger<CustomLoggerExample>, az alkalmazás CustomLoggerExample összetevőébe (CustomLoggerExample.razor) beszúrt szolgáltatás.

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: Információ ] {CLASS} – INFORMÁCIÓ: EGY hatókör. => L1 blazor.webassembly.js:1:35542
[ 3: Információ ] {CLASS} – INFORMÁCIÓ: KÉT hatókör. => L1 => L2 blazor.webassembly.js:1:35542
[ 3: Információ ] {CLASS} – INFORMÁCIÓ: HÁROM hatókör. => L1 => L2 => L3

Az {CLASS} előző példában szereplő helyőrző a következő BlazorWebAssemblyScopesLogger.Pages.CustomLoggerExample: .

Előre beállított összetevők naplózása

Az előre beállított összetevők kétszer hajtják végre az összetevő inicializálási kódját. A naplózás kiszolgálóoldalon történik az inicializálási kód első végrehajtásakor, az ügyféloldalon pedig az inicializálási kód második végrehajtásakor. Az inicializálás során a naplózás céljától függően ellenőrizze a kiszolgálóoldali, ügyféloldali vagy mindkét naplót.

SignalR kliensnaplózás a SignalR kliens építővel

Ez a szakasz a kiszolgálóoldali alkalmazásokra vonatkozik.

A Blazor szkriptindítási konfigurációban adja meg a configureSignalR naplószinttel hívható configureLogging konfigurációs objektumot.

configureLogging A naplószint értékéhez adja meg az argumentumot akár sztringként, akár egész számként a következő táblázat szerint.

LogLevel	Sztringbeállítás	Egész szám beállítása
Trace	trace	0
Debug	debug	1
Information	information	2
Warning	warning	3
Error	error	4
Critical	critical	5
None	none	6

Állítsa be az Information naplószintet string értékkel.

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>

Az előző példában a {BLAZOR SCRIPT} helyőrző a Blazor szkript elérési útja és fájlneve. A szkript helyéről lásd ASP.NET Core Blazor projektstruktúra.

Példa 2: Állítsa be a Information naplószintet egész számértékkel.

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>

Az előző példában a {BLAZOR SCRIPT} helyőrző a Blazor szkript elérési útja és fájlneve. A szkript helyéről lásd ASP.NET Core Blazor projektstruktúra.

Note

A 2. példában a naplózási szint megadására szolgáló egész szám , amelyet gyakran varázsszámnak vagy varázsállandónak is neveznek, rossz kódolási gyakorlatnak számít, mivel az egész szám nem azonosítja egyértelműen a naplózási szintet a forráskód megtekintésekor. Ha a böngészőbe átvitt bájtok minimalizálása prioritást jelent, az egész szám használata indokolt lehet (ilyen esetekben érdemes lehet eltávolítani a megjegyzést).

Az indítással (Blazor) kapcsolatos Blazor.start() további információkért lásd ASP.NET Core-indítástBlazor.

SignalR ügyfélnaplózás alkalmazáskonfigurációval

Az alkalmazásbeállítások konfigurálásának beállítása az ASP.NET Core-konfigurációban Blazorleírtak szerint. Helyezze az alkalmazásbeállításokat tartalmazó fájlokat a wwwroot helyre, amelyek tartalmaznak egy Logging:LogLevel:HubConnection alkalmazásbeállítást.

Note

Az alkalmazásbeállítások használatának alternatívájaként, amikor egy LogLevel összetevőben létrejön a hub kapcsolat, átadhatja az LoggingBuilderExtensions.SetMinimumLevel argumentumot Razor-hez. Ha azonban véletlenül üzembe helyezi az alkalmazást egy éles üzemeltetési környezetben részletes naplózással, teljesítménybeli büntetést vonhat maga után. Javasoljuk, hogy a naplószint beállításához használja az alkalmazásbeállításokat.

Adjon meg egy alkalmazásbeállítást Logging:LogLevel:HubConnection az alapértelmezett appsettings.json fájlban és a Development környezeti alkalmazásbeállítások fájlban. Az alapértelmezetthez használjon tipikusan kevésbé részletes naplószintet, például LogLevel.Warning. Az alapértelmezett alkalmazásbeállítások értéke az, amelyet a rendszer használ a Staging környezetekbenProduction, ha nincsenek alkalmazásbeállítások fájljai ezekhez a környezetekhez. Használjon részletes naplózási szintet a Development környezeti alkalmazás beállításfájljában, például 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

Az előző alkalmazásbeállítások fájljainak konfigurációját az alkalmazás csak akkor használja, ha a ASP.NET Core-konfigurációra Blazor vonatkozó útmutatást követi.

A Razor komponensfájl tetején (.razor):

• Injektáljon be egy ILoggerProvider elemet, hogy hozzáadjon egy WebAssemblyConsoleLogger a naplózási szolgáltatókhoz, amelyeknek átlettek adva HubConnectionBuilder. A ConsoleLoggerProvider a böngészőspecifikus naplózási API-k (például WebAssemblyConsoleLogger) burkolója, ellentétben a console.log-val. A WebAssemblyConsoleLogger használata lehetővé teszi a naplózást a Mono-ban egy böngészőkörnyezeten belül.
• Injektáljon egy értéket IConfiguration az alkalmazásbeállítás olvasásához Logging:LogLevel:HubConnection .

Note

WebAssemblyConsoleLogger belső, és nem támogatott a fejlesztői kódban való közvetlen használathoz.

@inject ILoggerProvider LoggerProvider
@inject IConfiguration Config

Note

Az alábbi példa az oktatóanyagban szereplőSignalRBlazorbemutatón alapul. További részletekért tekintse meg az oktatóanyagot.

Az összetevő OnInitializedAsync metódusában, használja a HubConnectionBuilderExtensions.ConfigureLogging kifejezést a naplózási szolgáltató hozzáadására, és állítsa be a minimális naplószintet a konfiguráció alapján:

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

Az előző példában Navigation egy injektált NavigationManager.

Az alkalmazás környezetének beállításával kapcsolatos további információkért lásd ASP.NET Core-környezeteketBlazor.

Ügyféloldali hitelesítés naplózása

Naplózza Blazor a hitelesítési üzeneteket az LogLevel.Debug vagy LogLevel.Trace naplószinteken az alkalmazásbeállításokban megadott naplózási konfiguráció vagy egy naplószűrő segítségével a Microsoft.AspNetCore.Components.WebAssembly.Authentication fájlban Program.

Használja az alábbi módszerek egyikét :

• Alkalmazásbeállítások fájlban (például wwwroot/appsettings.Development.json):

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

  Az ügyféloldali alkalmazások alkalmazásbeállítási fájlok olvasására való konfigurálásáról további információt ASP.NET Core-konfigurációban Blazortalál.

• Naplószűrő használata esetén a következő példa:

  • A Debug buildkonfiguráció naplózását aktiválja egy C#-előfeldolgozó-direktíva segítségével.
  • Naplózza a Blazor hitelesítési üzeneteket a Debug napló szintjén.

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

Note

Razor az ügyfélen megjelenített összetevők csak az ügyféloldali böngésző fejlesztői eszközeinek konzoljára jelentkeznek be.

További erőforrások

• Bejelentkezés a .NET-ben és a ASP.NET Core-ban
• Loglevel Enum (API-dokumentáció)
• Egyéni naplózási szolgáltató implementálása a .NET-ben
• Böngészőfejlesztői eszközök dokumentációja:
  • Chrome Fejlesztői eszközök
  • Microsoft Edge fejlesztői eszközök áttekintése
• Blazor GitHub-adattár mintái (dotnet/blazor-samples) (hogyan lehet letölteni)