Blazor rejestrowanie podstawowe ASP.NET

W tym artykule opisano Blazor rejestrowanie aplikacji, w tym konfigurację i sposób pisania komunikatów dziennika ze Razor składników.

Konfigurowanie

Konfigurację rejestrowania można załadować z plików ustawień aplikacji. Aby uzyskać więcej informacji, zobacz ASP.NET Core configuration (Konfiguracja ASP.NET CoreBlazor).

Na domyślnych poziomach dziennika i bez konfigurowania dodatkowych dostawców rejestrowania:

• Na serwerze rejestrowanie odbywa się tylko w konsoli .NET po stronie serwera w Development środowisku na LogLevel.Information poziomie lub wyższym.
• Na kliencie rejestrowanie odbywa się tylko w konsoli narzędzi deweloperskich przeglądarki po stronie klienta na LogLevel.Information poziomie lub wyższym.

Jeśli aplikacja jest skonfigurowana w pliku projektu do używania niejawnych przestrzeni nazw (<ImplicitUsings>enable</ImplicitUsings>), using dyrektywa dla Microsoft.Extensions.Logging ani dowolny interfejs API w LoggerExtensions klasie nie jest wymagana do obsługi uzupełniania ani tworzenia aplikacji intelliSense interfejsu API programu Visual Studio. Jeśli niejawne przestrzenie nazw nie są włączone, Razor składniki muszą jawnie definiować @using dyrektywy rejestrowania przestrzeni nazw, które nie są importowane za pośrednictwem _Imports.razor pliku.

Poziomy rejestrowania

Poziomy dzienników są zgodne z poziomami dziennika aplikacji ASP.NET Core, które są wymienione w dokumentacji interfejsu API pod adresem LogLevel.

Razor rejestrowanie składników

Poniższy przykład:

• Wstrzykuje ILogger obiekt (ILogger<Counter1>), aby utworzyć rejestrator. Kategoria dziennika jest w pełni kwalifikowaną nazwą typu składnika . Counter
• Wywołuje metodę LogWarning w celu rejestrowania na poziomie Warning.

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

W poniższym przykładzie pokazano rejestrowanie za pomocą ILoggerFactory składników w programie .

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

Rejestrowanie po stronie serwera

Aby uzyskać ogólne wskazówki dotyczące rejestrowania ASP.NET Core, zobacz Rejestrowanie na platformie .NET Core i ASP.NET Core.

Rejestrowanie po stronie klienta

Nie każda funkcja rejestrowania ASP.NET Core jest obsługiwana po stronie klienta. Na przykład składniki po stronie klienta nie mają dostępu do systemu plików lub sieci klienta, więc zapisywanie dzienników w magazynie fizycznym lub sieciowym klienta nie jest możliwe. W przypadku korzystania z usługi rejestrowania innej firmy przeznaczonej do pracy z aplikacjami jednostronicowymi (SPA) postępuj zgodnie ze wskazówkami dotyczącymi zabezpieczeń usługi. Należy pamiętać, że każdy element danych, w tym klucze lub wpisy tajne przechowywane po stronie klienta są niezabezpieczone i mogą być łatwo wykrywane przez złośliwych użytkowników.

Skonfiguruj rejestrowanie w aplikacjach po stronie klienta za WebAssemblyHostBuilder.Logging pomocą właściwości . Właściwość Logging jest typu ILoggingBuilder, więc obsługiwane są metody ILoggingBuilder rozszerzenia.

Aby ustawić minimalny poziom rejestrowania, wywołaj LoggingBuilderExtensions.SetMinimumLevel konstruktora hosta w Program pliku za pomocą polecenia LogLevel. W poniższym przykładzie ustawiono minimalny poziom dziennika na Warning:

builder.Logging.SetMinimumLevel(LogLevel.Warning);

Zaloguj się do pliku po stronie Program klienta

Rejestrowanie jest obsługiwane w aplikacjach po stronie klienta po WebAssemblyHostBuilder skompilowaniu przy użyciu wewnętrznego dostawcy rejestratora konsoli platformy (WebAssemblyConsoleLoggerProvider (źródło referencyjne)).

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

dane wyjściowe konsoli Narzędzia programistyczne:

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

Uwaga

Linki dokumentacji do źródła referencyjnego platformy .NET zwykle ładują domyślną gałąź repozytorium, która odzwierciedla bieżące programowanie dla następnej wersji platformy .NET. Aby wybrać tag dla określonej wersji, użyj listy rozwijanej Przełącz gałęzie lub tagi. Aby uzyskać więcej informacji, zobacz Jak wybrać tag wersji kodu źródłowego platformy ASP.NET Core (dotnet/AspNetCore.Docs #26205).

Kategoria dziennika po stronie klienta

Obsługiwane są kategorie dzienników .

W poniższym przykładzie pokazano, jak używać kategorii dzienników ze Counter składnikiem aplikacji utworzonej Blazor na podstawie szablonu projektu.

W metodzie IncrementCount składnika aplikacji Counter (Counter.razor), który wprowadza element ILoggerFactory jako LoggerFactory:

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

dane wyjściowe konsoli Narzędzia programistyczne:

warn: CustomCategory[0]
Someone has clicked me!

Identyfikator zdarzenia dziennika po stronie klienta

Identyfikator zdarzenia dziennika jest obsługiwany.

W poniższym przykładzie pokazano, jak używać identyfikatorów zdarzeń dziennika ze Counter składnikiem aplikacji utworzonej Blazor na podstawie szablonu projektu.

LogEvent.cs:

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

W metodzie IncrementCount składnika aplikacji Counter (Counter.razor):

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

dane wyjściowe konsoli Narzędzia programistyczne:

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

Szablon komunikatu dziennika po stronie klienta

Obsługiwane są szablony komunikatów dziennika:

W poniższym przykładzie pokazano, jak używać szablonów komunikatów dziennika ze Counter składnikiem aplikacji utworzonej Blazor na podstawie szablonu projektu.

W metodzie IncrementCount składnika aplikacji Counter (Counter.razor):

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

dane wyjściowe konsoli Narzędzia programistyczne:

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

Parametry wyjątku dziennika po stronie klienta

Obsługiwane są parametry wyjątku dziennika.

W poniższym przykładzie pokazano, jak używać parametrów wyjątku dziennika ze Counter składnikiem aplikacji utworzonej Blazor na podstawie szablonu projektu.

W metodzie IncrementCount składnika aplikacji Counter (Counter.razor):

currentCount++;

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

dane wyjściowe konsoli Narzędzia programistyczne:

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

Funkcja filtru po stronie klienta

Obsługiwane są funkcje filtrowania.

W poniższym przykładzie pokazano, jak używać filtru ze Counter składnikiem aplikacji utworzonej Blazor na podstawie szablonu projektu.

W pliku Program:

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

W metodzie IncrementCount składnika aplikacji Counter (Counter.razor), który wprowadza element ILoggerFactory jako 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!");

W danych wyjściowych konsoli narzędzi deweloperskich filtr zezwala tylko na rejestrowanie dla komunikatu CustomCategory2 kategorii i Information poziomu dziennika:

info: CustomCategory2[0]
Someone has clicked me!

Aplikacja może również skonfigurować filtrowanie dzienników dla określonych przestrzeni nazw. Na przykład ustaw poziom dziennika na Trace w Program pliku:

builder.Logging.SetMinimumLevel(LogLevel.Trace);

Zwykle na Trace poziomie dziennika dane wyjściowe konsoli narzędzi deweloperskich na poziomie pełnej obejmują Microsoft.AspNetCore.Components.RenderTree komunikaty rejestrowania, takie jak:

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

Program W pliku można wyłączyć Microsoft.AspNetCore.Components.RenderTree rejestrowanie komunikatów specyficznych dla jednego z następujących metod:

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

Po dodaniu jednego z powyższych filtrów do aplikacji dane wyjściowe konsoli na poziomie Pełne nie wyświetlają komunikatów rejestrowania z interfejsu Microsoft.AspNetCore.Components.RenderTree API.

Niestandardowy dostawca rejestratora po stronie klienta

W przykładzie w tej sekcji przedstawiono niestandardowego dostawcę rejestratora w celu dalszego dostosowywania.

Dodaj odwołanie do pakietu do aplikacji.Microsoft.Extensions.Logging.Configuration

Uwaga

Aby uzyskać instrukcje dodawania pakietów do aplikacji .NET, zobacz artykuły w sekcji Instalowanie pakietów i zarządzanie nimi w temacie Przepływ pracy użycia pakietów (dokumentacja programu NuGet). Sprawdź prawidłowe wersje pakietów pod adresem NuGet.org.

Dodaj następującą konfigurację niestandardowego rejestratora. Konfiguracja ustanawia LogLevels słownik, który ustawia niestandardowy format dziennika dla trzech poziomów dziennika: Information, Warningi Error. Element A LogFormat enum służy do opisywania krótkich (LogFormat.Short) i długich (LogFormat.Long) formatów.

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

Dodaj następujący niestandardowy rejestrator do aplikacji. Dane CustomLogger wyjściowe niestandardowych formatów dziennika na logLevel podstawie wartości zdefiniowanych w poprzedniej CustomLoggerConfiguration konfiguracji.

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

Dodaj następującego niestandardowego dostawcę rejestratora do aplikacji. CustomLoggerProviderOptionsstosuje podejście oparte na konfigurowaniu rejestratora za pomocą wbudowanych funkcji konfiguracji rejestrowania. Na przykład aplikacja może ustawiać lub zmieniać formaty dziennika za pośrednictwem appsettings.json pliku bez konieczności wprowadzania zmian kodu w niestandardowym rejestratorze, który jest przedstawiony na końcu tej sekcji.

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

Dodaj następujące niestandardowe rozszerzenia rejestratora.

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

W pliku konstruktora Program hosta wyczyść istniejącego dostawcę, wywołując ClearProviders i dodając niestandardowego dostawcę rejestrowania:

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

W poniższym składniku CustomLoggerExample:

• Komunikat debugowania nie jest rejestrowany.
• Komunikat informacyjny jest rejestrowany w krótkim formacie (LogFormat.Short).
• Komunikat ostrzegawczy jest rejestrowany w krótkim formacie (LogFormat.Short).
• Komunikat o błędzie jest rejestrowany w długim formacie (LogFormat.Long).
• Komunikat śledzenia nie jest rejestrowany.

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

Następujące dane wyjściowe są widoczne w konsoli narzędzi deweloperskich przeglądarki po wybraniu Log Messages przycisku. Wpisy dziennika odzwierciedlają odpowiednie formaty stosowane przez niestandardowy rejestrator (aplikacja kliencka ma nazwę 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.

Z przypadkowej inspekcji poprzedniego przykładu wynika, że ustawienie formatów wiersza dziennika za pośrednictwem słownika nie CustomLoggerConfiguration jest ściśle konieczne. Formaty wierszy zastosowane przez niestandardowy rejestrator (CustomLogger) mogły zostać zastosowane jedynie przez sprawdzenie logLevel w metodzie Log . Celem przypisania formatu dziennika za pośrednictwem konfiguracji jest to, że deweloper może łatwo zmienić format dziennika za pomocą konfiguracji aplikacji, jak pokazano w poniższym przykładzie.

W aplikacji po stronie klienta dodaj lub zaktualizuj plik, aby uwzględnić konfigurację appsettings.json rejestrowania. Ustaw format dziennika na Long dla wszystkich trzech poziomów dziennika:

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

W poprzednim przykładzie zwróć uwagę, że wpis konfiguracji niestandardowego rejestratora to CustomLog, który został zastosowany do niestandardowego dostawcy rejestratora (CustomLoggerProvider) jako aliasu z [ProviderAlias("CustomLog")]. Konfiguracja rejestrowania mogła zostać zastosowana z nazwą CustomLoggerProvider zamiast CustomLog, ale użycie aliasu CustomLog jest bardziej przyjazne dla użytkownika.

Program W pliku zużyj konfigurację rejestrowania. Dodaj następujący kod:

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

Wywołanie , które LoggingBuilderConfigurationExtensions.AddConfiguration ma zostać umieszczone przed lub po dodaniu niestandardowego dostawcy rejestratora.

Ponownie uruchom aplikację. Wybierz przycisk Log Messages. Zwróć uwagę, że konfiguracja rejestrowania jest stosowana z appsettings.json pliku. Wszystkie trzy wpisy dziennika mają długi format () (LogFormat.Longaplikacja kliencka ma nazwę 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.

Zakresy dziennika po stronie klienta

Rejestrator konsoli narzędzi deweloperskich nie obsługuje zakresów dzienników. Niestandardowy rejestrator może jednak obsługiwać zakresy dzienników. W przypadku nieobsługiwanego przykładu, który można dalej opracowywać zgodnie z potrzebami, zobacz BlazorWebAssemblyScopesLogger przykładową aplikację w Blazor repozytorium GitHub przykładów (jak pobrać).

Przykładowa aplikacja używa standardowej składni rejestrowania ASP.NET Core BeginScope w celu wskazania zakresów zarejestrowanych komunikatów. Usługa Logger w poniższym przykładzie to ILogger<CustomLoggerExample>element , który jest wstrzykiwany do składnika aplikacji CustomLoggerExample (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.");
        }
    }
}

Wyjście:

[ 3: Informacje ] {CLASS} — INFORMACJE: JEDEN zakres. => L1 blazor.webassembly.js:1:35542
[ 3: Informacje ] {CLASS} — INFORMACJE: DWA zakresy. = L1 =>> L2 blazor.webassembly.js:1:35542
[ 3: Informacje ] {CLASS} — INFORMACJE: TRZY zakresy. = L1 =>> L2 => L3

Symbol {CLASS} zastępczy w poprzednim przykładzie to BlazorWebAssemblyScopesLogger.Pages.CustomLoggerExample.

Rejestrowanie składników wstępnie wstępnie wyeksenderowanych

Składniki wstępnie wstępnie uruchamiają kod inicjowania składnika dwa razy. Rejestrowanie odbywa się po stronie serwera po pierwszym wykonaniu kodu inicjowania i po stronie klienta w drugim wykonaniu kodu inicjowania. W zależności od celu rejestrowania podczas inicjowania sprawdź dzienniki po stronie serwera, po stronie klienta lub oba te elementy.

SignalR rejestrowanie klienta za pomocą konstruktora SignalR klienta

Ta sekcja dotyczy aplikacji po stronie serwera.

W Blazor konfiguracji uruchamiania skryptu configureSignalR przekaż obiekt konfiguracji, który wywołuje configureLogging poziom dziennika.

configureLogging Dla wartości poziomu dziennika przekaż argument jako ciąg lub poziom dziennika liczby całkowitej pokazany w poniższej tabeli.

LogLevel	Ustawienie ciągu	Ustawienie Liczby całkowitej
Trace	trace	0
Debug	debug	1
Information	information	2
Warning	warning	3
Error	error	4
Critical	critical	5
None	none	6

Przykład 1. Ustaw Information poziom dziennika z wartością ciągu.

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>

W poprzednim przykładzie {BLAZOR SCRIPT} symbol zastępczy to ścieżka skryptu Blazor i nazwa pliku. Aby uzyskać informacje o lokalizacji skryptu, zobacz ASP.NET Core project structure (Struktura projektu ASP.NET CoreBlazor).

Przykład 2. Ustaw Information poziom dziennika z wartością całkowitą.

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>

W poprzednim przykładzie {BLAZOR SCRIPT} symbol zastępczy to ścieżka skryptu Blazor i nazwa pliku. Aby uzyskać informacje o lokalizacji skryptu, zobacz ASP.NET Core project structure (Struktura projektu ASP.NET CoreBlazor).

Uwaga

Użycie liczby całkowitej do określenia poziomu rejestrowania w przykładzie 2, często określanego jako liczba magiczna lub stała magiczna, jest uważana za słabą praktykę kodowania, ponieważ liczba całkowita nie wyraźnie identyfikuje poziomu rejestrowania podczas wyświetlania kodu źródłowego. Jeśli minimalizacja bajtów przeniesionych do przeglądarki jest priorytetem, użycie liczby całkowitej może być uzasadnione (rozważ usunięcie komentarza w takich przypadkach).

Aby uzyskać więcej informacji na Blazor temat uruchamiania (Blazor.start()), zobacz ASP.NET Core Blazor startup .

SignalR rejestrowanie klienta przy użyciu konfiguracji aplikacji

Skonfiguruj konfigurację ustawień aplikacji zgodnie z opisem w ASP.NET Konfiguracji coreBlazor. Umieść pliki ustawień aplikacji w wwwroot pliku zawierającym Logging:LogLevel:HubConnection ustawienie aplikacji.

Uwaga

Alternatywą dla używania ustawień aplikacji jest przekazanie argumentu LogLevel jako argumentu podczas LoggingBuilderExtensions.SetMinimumLevel tworzenia połączenia koncentratora w składniku Razor . Jednak przypadkowe wdrożenie aplikacji w środowisku hostingu produkcyjnego z pełnym rejestrowaniem może spowodować karę za wydajność. Zalecamy użycie ustawień aplikacji w celu ustawienia poziomu dziennika.

Podaj ustawienie aplikacji w pliku domyślnym Logging:LogLevel:HubConnection appsettings.json i w Development pliku ustawień aplikacji środowiska. Użyj typowego mniej szczegółowego poziomu dziennika dla wartości domyślnej, takiej jak LogLevel.Warning. Domyślna wartość ustawień aplikacji jest używana w Staging środowiskach i Production , jeśli nie ma plików ustawień aplikacji dla tych środowisk. Użyj pełnego poziomu dziennika w Development pliku ustawień aplikacji środowiska, na przykład 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"
    }
  }
}

Ważne

Konfiguracja w poprzednich plikach ustawień aplikacji jest używana tylko przez aplikację, jeśli są przestrzegane wskazówki opisane w ASP.NET Core Blazor konfiguracji .

W górnej Razor części pliku składnika (.razor):

• Wstrzykiwanie elementu w celu dodania ILoggerProvider elementu WebAssemblyConsoleLogger do dostawców rejestrowania przekazanych do elementu HubConnectionBuilder. W przeciwieństwie do elementu ConsoleLoggerProvider, WebAssemblyConsoleLogger to otoka interfejsów API rejestrowania specyficznego dla przeglądarki (na przykład console.log). Korzystanie z funkcji umożliwia WebAssemblyConsoleLogger rejestrowanie w obrębie platformy Mono w kontekście przeglądarki.
• Wstrzykiwanie elementu IConfiguration w celu odczytania Logging:LogLevel:HubConnection ustawienia aplikacji.

Uwaga

WebAssemblyConsoleLogger program jest wewnętrzny i nie jest obsługiwany do bezpośredniego użycia w kodzie dewelopera.

@inject ILoggerProvider LoggerProvider
@inject IConfiguration Config

Uwaga

Poniższy przykład jest oparty na pokazie w samouczku z samouczkiemBlazorSignalR. Aby uzyskać więcej informacji, zapoznaj się z samouczkiem.

W metodzie składnika OnInitializedAsync użyj polecenia HubConnectionBuilderExtensions.ConfigureLogging , aby dodać dostawcę rejestrowania i ustawić minimalny poziom dziennika z konfiguracji:

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

Uwaga

W poprzednim przykładzie Navigation jest wstrzyknięty NavigationManager.

Aby uzyskać więcej informacji na temat ustawiania środowiska aplikacji, zobacz ASP.NET Core environments (Środowiska podstawowe Blazor ASP.NET).

Rejestrowanie uwierzytelniania po stronie klienta

Komunikaty uwierzytelniania dzienników Blazor na LogLevel.Debug poziomach rejestrowania lub LogLevel.Trace z konfiguracją rejestrowania w ustawieniach aplikacji lub przy użyciu filtru Microsoft.AspNetCore.Components.WebAssembly.Authentication Program dziennika w pliku.

Użyj jednej z następujących metod:

• W pliku ustawień aplikacji (na przykład wwwroot/appsettings.Development.json):

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

  Aby uzyskać więcej informacji na temat konfigurowania aplikacji po stronie klienta w celu odczytywania plików ustawień aplikacji, zobacz ASP.NET Core configuration (Konfiguracja ASP.NET CoreBlazor).

• Korzystając z filtru dziennika, w poniższym przykładzie:

  • Aktywuje rejestrowanie konfiguracji Debug kompilacji przy użyciu dyrektywy preprocesora języka C#.
  • Rejestruje Blazor komunikaty uwierzytelniania na Debug poziomie dziennika.

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

Uwaga

Razorskładniki renderowane na kliencie są rejestrowane tylko w konsoli narzędzi deweloperskich przeglądarki po stronie klienta.

Dodatkowe zasoby

• Rejestrowanie na platformie .NET Core i ASP.NET Core
• Loglevel Wyliczenie (dokumentacja interfejsu API)
• Implementowanie niestandardowego dostawcy rejestrowania na platformie .NET
• Dokumentacja narzędzi deweloperskich przeglądarki:
  • Zestaw Chrome DevTools
  • Omówienie narzędzi deweloperskich przeglądarki Microsoft Edge
• Blazorprzykładowe repozytorium GitHub () (dotnet/blazor-samplesjak pobrać)