Blazor registrazione di base ASP.NET

Questo articolo illustra la registrazione delle Blazor app, inclusa la configurazione e come scrivere messaggi di log dai Razor componenti.

Impostazione

La configurazione della registrazione può essere caricata dai file di impostazioni dell'app. Per altre informazioni, vedere configurazione di ASP.NET CoreBlazor.

A livello di log predefinito e senza configurare provider di registrazione aggiuntivi:

• Nel server, la registrazione si verifica solo nella console .NET lato server nell'ambiente Development a LogLevel.Information livello o superiore.
• Nel client, la registrazione si verifica solo nella console degli strumenti di sviluppo del browser sul lato client a LogLevel.Information livello o superiore.

Quando l'app è configurata nel file di progetto per l'uso di spazi dei nomi impliciti (<ImplicitUsings>enable</ImplicitUsings>), non è necessaria una using direttiva per Microsoft.Extensions.Logging o qualsiasi API nella LoggerExtensions classe per supportare i completamenti di Visual Studio IntelliSense per le API o la compilazione di app. Se gli spazi dei nomi impliciti non sono abilitati, Razor i componenti devono definire@usingin modo esplicito le direttive per la registrazione degli spazi dei nomi che non vengono importati tramite il _Imports.razor file.

Livelli di registrazione

I livelli di log sono conformi ai livelli di log delle app principali ASP.NET elencati nella documentazione dell'API all'indirizzo LogLevel.

Razor registrazione dei componenti

L'esempio seguente:

• Inserisce un ILogger oggetto (ILogger<Counter1>) per creare un logger. La categoria del log è il nome completo del tipo del componente, Counter.
• Chiama LogWarning per la registrazione al livello 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++;
    }
}

Nell'esempio seguente viene illustrata la registrazione con un oggetto ILoggerFactory nei componenti.

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

Registrazione lato server

Per indicazioni generali sulla registrazione di ASP.NET Core, vedere Registrazione in .NET Core e ASP.NET Core.

Registrazione lato client

Non tutte le funzionalità della registrazione core di ASP.NET sono supportate sul lato client. Ad esempio, i componenti lato client non hanno accesso al file system o alla rete del client, quindi la scrittura dei log nell'archiviazione fisica o di rete del client non è possibile. Quando si usa un servizio di registrazione di terze parti progettato per l'uso con app a pagina singola ,seguire le indicazioni sulla sicurezza del servizio. Tenere presente che tutti i dati, incluse le chiavi o i segreti archiviati sul lato client, sono insicuri e possono essere facilmente individuati da utenti malintenzionati.

Configurare la registrazione nelle app lato client con la WebAssemblyHostBuilder.Logging proprietà . La Logging proprietà è di tipo ILoggingBuilder, quindi sono supportati i metodi di estensione di ILoggingBuilder .

Per impostare il livello di registrazione minimo, chiamare LoggingBuilderExtensions.SetMinimumLevel sul generatore host nel Program file con .LogLevel L'esempio seguente imposta il livello minimo di log su Warning:

builder.Logging.SetMinimumLevel(LogLevel.Warning);

Accedere al file lato Program client

La registrazione è supportata nelle app lato client dopo la WebAssemblyHostBuilder compilazione di usando il provider del logger interno della console del framework (WebAssemblyConsoleLoggerProvider (origine di riferimento)).

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

Strumenti di sviluppo output della console:

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

Nota

I collegamenti della documentazione all'origine del riferimento .NET in genere caricano il ramo predefinito del repository, che rappresenta lo sviluppo corrente per la versione successiva di .NET. Per selezionare un tag per una versione specifica, usare l'elenco a discesa Switch branches or tags. Per altre informazioni, vedere How to select a version tag of ASP.NET Core source code (dotnet/AspNetCore.Docs #26205) (Come selezionare un tag di versione del codice sorgente di ASP.NET - dotnet/AspNetCore.Docs #26205).

Categoria di log lato client

Sono supportate le categorie di log.

L'esempio seguente illustra come usare le categorie di log con il Counter componente di un'app creata da un Blazor modello di progetto.

IncrementCount Nel metodo del componente dell'app Counter (Counter.razor) che inserisce come ILoggerFactoryLoggerFactory:

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

Strumenti di sviluppo output della console:

warn: CustomCategory[0]
Someone has clicked me!

ID evento del log sul lato client

L'ID evento del log è supportato.

L'esempio seguente illustra come usare gli ID evento del log con il Counter componente di un'app creata da un Blazor modello di progetto.

LogEvent.cs:

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

IncrementCount Nel metodo del componente dell'app Counter (Counter.razor):

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

Strumenti di sviluppo output della console:

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

Modello di messaggio di log sul lato client

Sono supportati i modelli di messaggio di log:

L'esempio seguente illustra come usare i modelli di messaggio di log con il Counter componente di un'app creata da un Blazor modello di progetto.

IncrementCount Nel metodo del componente dell'app Counter (Counter.razor):

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

Strumenti di sviluppo output della console:

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

Parametri delle eccezioni del log sul lato client

Sono supportati i parametri delle eccezioni del log.

L'esempio seguente illustra come usare i parametri di eccezione del log con il Counter componente di un'app creata da un Blazor modello di progetto.

IncrementCount Nel metodo del componente dell'app 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);
}

Strumenti di sviluppo output della console:

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

Funzione di filtro lato client

Le funzioni di filtro sono supportate.

L'esempio seguente illustra come usare un filtro con il Counter componente di un'app creata da un Blazor modello di progetto.

Nel file Program:

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

IncrementCount Nel metodo del componente dell'app Counter (Counter.razor) che inserisce come ILoggerFactoryLoggerFactory:

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

Nell'output della console degli strumenti di sviluppo il filtro consente solo la registrazione per la categoria e Information il CustomCategory2 messaggio a livello di log:

info: CustomCategory2[0]
Someone has clicked me!

L'app può anche configurare il filtro dei log per spazi dei nomi specifici. Ad esempio, impostare il livello di log su Trace nel Program file:

builder.Logging.SetMinimumLevel(LogLevel.Trace);

In genere a livello di log, l'output Trace della console degli strumenti di sviluppo a livello dettagliato include Microsoft.AspNetCore.Components.RenderTree messaggi di registrazione, ad esempio i seguenti:

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

Nel file la Program registrazione dei messaggi specifici di Microsoft.AspNetCore.Components.RenderTree può essere disabilitata usando uno degli approcci seguenti:

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

Dopo l'aggiunta di uno dei filtri precedenti all'app, l'output della console a livello dettagliato non mostra i messaggi di registrazione dall'API Microsoft.AspNetCore.Components.RenderTree .

Provider di logger personalizzato lato client

Nell'esempio riportato in questa sezione viene illustrato un provider di logger personalizzato per un'ulteriore personalizzazione.

Aggiungere un riferimento al pacchetto all'app per il Microsoft.Extensions.Logging.Configuration pacchetto.

Nota

Per indicazioni sull'aggiunta di pacchetti alle app .NET, vedere gli articoli sotto Installare e gestire pacchetti in Flusso di lavoro dell'utilizzo di pacchetti (documentazione di NuGet). Confermare le versioni corrette del pacchetto all'indirizzo NuGet.org.

Aggiungere la configurazione del logger personalizzata seguente. La configurazione stabilisce un dizionario che imposta un LogLevels formato di log personalizzato per tre livelli di log: Information, Warninge Error. Un LogFormatenum oggetto viene utilizzato per descrivere formati brevi (LogFormat.Short) e lunghi (LogFormat.Long).

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

Aggiungere il logger personalizzato seguente all'app. Restituisce CustomLogger i formati di log personalizzati in base ai logLevel valori definiti nella configurazione precedente CustomLoggerConfiguration .

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

Aggiungere il provider di logger personalizzato seguente all'app. CustomLoggerProvider adotta un Optionsapproccio basato su per configurare il logger tramite funzionalità di configurazione della registrazione predefinite. Ad esempio, l'app può impostare o modificare i formati di log tramite un appsettings.json file senza richiedere modifiche al codice al logger personalizzato, illustrato alla fine di questa sezione.

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

Aggiungere le estensioni del logger personalizzate seguenti.

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

Nel file nel Program generatore host cancellare il provider esistente chiamando ClearProviders e aggiungere il provider di registrazione personalizzato:

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

Nel componente CustomLoggerExample seguente:

• Il messaggio di debug non viene registrato.
• Il messaggio informativo viene registrato nel formato breve (LogFormat.Short).
• Il messaggio di avviso viene registrato nel formato breve (LogFormat.Short).
• Il messaggio di errore viene registrato nel formato lungo (LogFormat.Long).
• Il messaggio di traccia non viene registrato.

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

L'output seguente viene visualizzato nella console degli strumenti di sviluppo del browser quando il Log Messages pulsante è selezionato. Le voci di log riflettono i formati appropriati applicati dal logger personalizzato (l'app client è denominata 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.

Da un'ispezione casuale dell'esempio precedente, è evidente che l'impostazione dei formati di riga di log tramite il dizionario in CustomLoggerConfiguration non è strettamente necessaria. I formati di riga applicati dal logger personalizzato (CustomLogger) potrebbero essere stati applicati semplicemente controllando l'oggetto logLevelLog nel metodo . Lo scopo dell'assegnazione del formato di log tramite la configurazione consiste nel fatto che lo sviluppatore può modificare facilmente il formato del log tramite la configurazione dell'app, come illustrato nell'esempio seguente.

Nell'app sul lato client aggiungere o aggiornare il file in modo da includere la appsettings.json configurazione della registrazione. Impostare il formato del log su Long per tutti e tre i livelli di log:

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

Nell'esempio precedente si noti che la voce per la configurazione del logger personalizzata è CustomLog, che è stata applicata al provider di logger personalizzato (CustomLoggerProvider) come alias con [ProviderAlias("CustomLog")]. La configurazione di registrazione potrebbe essere stata applicata con il nome CustomLoggerProvider invece di CustomLog, ma l'uso dell'alias CustomLog è più facile da usare.

Program Nel file utilizzare la configurazione di registrazione. Aggiungere il codice seguente:

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

La chiamata a LoggingBuilderConfigurationExtensions.AddConfiguration può essere effettuata prima o dopo l'aggiunta del provider di logger personalizzato.

Eseguire nuovamente l'app. Seleziona il pulsante Log Messages. Si noti che la configurazione di registrazione viene applicata dal appsettings.json file . Tutte e tre le voci di log sono nel formato long (LogFormat.Long) (l'app client è denominata 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.

Ambiti del log lato client

Il logger della console degli strumenti di sviluppo non supporta gli ambiti di log. Tuttavia, un logger personalizzato può supportare gli ambiti di log. Per un esempio non supportato che è possibile sviluppare ulteriormente in base alle proprie esigenze, vedere l'app BlazorWebAssemblyScopesLogger di esempio nelBlazorrepository GitHub degli esempi (come scaricare).

L'app di esempio usa la sintassi di registrazione standard ASP.NET Core BeginScope per indicare gli ambiti per i messaggi registrati. Il Logger servizio nell'esempio seguente è un ILogger<CustomLoggerExample>, che viene inserito nel componente dell'app 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.");
        }
    }
}

Output:

[ 3: Informazioni ] {CLASS} - INFO: UN ambito. => L1 blazor.webassembly.js:1:35542
[ 3: Informazioni ] {CLASS} - INFO: DUE ambiti. => L1 => L2 blazor.webassembly.js:1:35542
[ 3: Informazioni ] {CLASS} - INFO: THR edizione Enterprise ambiti. = L1 =>> L2 => L3

Il {CLASS} segnaposto nell'esempio precedente è BlazorWebAssemblyScopesLogger.Pages.CustomLoggerExample.

Registrazione preliminare dei componenti

I componenti prerisorsi eseguono il codice di inizializzazione dei componenti due volte. La registrazione viene eseguita sul lato server nella prima esecuzione del codice di inizializzazione e sul lato client nella seconda esecuzione del codice di inizializzazione. A seconda dell'obiettivo della registrazione durante l'inizializzazione, controllare i log lato server, lato client o entrambi.

SignalR registrazione client con il SignalR generatore di client

Questa sezione si applica alle app lato server.

Nella Blazor configurazione di avvio dello script passare l'oggetto configureSignalR di configurazione che chiama configureLogging con il livello di log.

Per il valore del configureLogging livello di log, passare l'argomento come livello di log stringa o intero illustrato nella tabella seguente.

LogLevel	Impostazione stringa	Impostazione integer
Trace	trace	0
Debug	debug	1
Information	information	2
Warning	warning	3
Error	error	4
Critical	critical	5
None	none	6

Esempio 1: impostare il livello di Information log con un valore stringa.

Blazor App Web:

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

Nell'esempio precedente il {BLAZOR SCRIPT} segnaposto è il percorso dello script e il Blazor nome del file. Per la posizione dello script, vedere ASP.NET Struttura del progetto CoreBlazor.

Esempio 2: impostare il livello di Information log con un valore intero.

Blazor App Web:

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

Nell'esempio precedente il {BLAZOR SCRIPT} segnaposto è il percorso dello script e il Blazor nome del file. Per la posizione dello script, vedere ASP.NET Struttura del progetto CoreBlazor.

Per altre informazioni sull'avvio Blazor (), vedere ASP.NET avvio di CoreBlazorBlazor.start().

SignalR registrazione client con configurazione dell'app

Configurare la configurazione delle impostazioni dell'app come descritto in configurazione di ASP.NET CoreBlazor. Inserire i file di impostazioni dell'app in wwwroot che contengono un'impostazione dell'app Logging:LogLevel:HubConnection .

Nota

In alternativa all'uso delle impostazioni dell'app, è possibile passare LogLevel come argomento a LoggingBuilderExtensions.SetMinimumLevel quando viene creata la connessione hub in un Razor componente. Tuttavia, la distribuzione accidentale dell'app in un ambiente di hosting di produzione con registrazione dettagliata può comportare una riduzione delle prestazioni. È consigliabile usare le impostazioni dell'app per impostare il livello di log.

Specificare un'impostazione Logging:LogLevel:HubConnection dell'app nel file predefinito appsettings.json e nel file delle impostazioni dell'app dell'ambiente Development . Usare un livello di log meno dettagliato tipico per l'impostazione predefinita, ad esempio LogLevel.Warning. Il valore predefinito delle impostazioni dell'app è quello usato in Staging e Production negli ambienti se non sono presenti file di impostazioni dell'app per tali ambienti. Usare un livello di log dettagliato nel file di impostazioni dell'app dell'ambiente Development , ad esempio 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"
    }
  }
}

Importante

La configurazione nei file di impostazioni dell'app precedenti viene usata dall'app solo se vengono seguite le indicazioni riportate in ASP.NET configurazione coreBlazor.

Nella parte superiore del Razor file del componente (.razor):

• Inserire un ILoggerProvider oggetto per aggiungere un WebAssemblyConsoleLogger oggetto ai provider di registrazione passati a HubConnectionBuilder. A differenza di un tradizionale ConsoleLogger, WebAssemblyConsoleLogger è un wrapper per le API di registrazione specifiche del browser , ad esempio console.log. L'uso di rende possibile la registrazione all'interno di Mono all'interno di WebAssemblyConsoleLogger un contesto del browser.
• Inserire un oggetto IConfiguration per leggere l'impostazione dell'app Logging:LogLevel:HubConnection .

Nota

WebAssemblyConsoleLogger è interno e non supportato per l'uso diretto nel codice per sviluppatori.

@inject ILoggerProvider LoggerProvider
@inject IConfiguration Config

Nota

L'esempio seguente si basa sulla dimostrazione nell'esercitazione SignalRcon .Blazor Per altri dettagli, vedere l'esercitazione.

Nel metodo del OnInitializedAsync componente usare HubConnectionBuilderExtensions.ConfigureLogging per aggiungere il provider di registrazione e impostare il livello minimo di log dalla configurazione:

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

Nota

Nell'esempio precedente, Navigation è un oggetto inserito NavigationManager.

Per altre informazioni sull'impostazione dell'ambiente dell'app, vedere ASP.NET Ambienti principaliBlazor.

Registrazione dell'autenticazione lato client

Registrare Blazor i messaggi di autenticazione a LogLevel.Debug livelli o LogLevel.Trace di registrazione con una configurazione di registrazione nelle impostazioni dell'app o usando un filtro di log per Microsoft.AspNetCore.Components.WebAssembly.Authentication nel Program file.

Usare uno degli approcci seguenti:

• In un file di impostazioni dell'app (ad esempio, wwwroot/appsettings.Development.json):

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

  Per altre informazioni su come configurare un'app sul lato client per leggere i file di impostazioni dell'app, vedere ASP.NET Configurazione di baseBlazor.

• Usando un filtro di log, l'esempio seguente:

  • Attiva la registrazione per la configurazione di Debug compilazione usando una direttiva del preprocessore C#.
  • Registra i Blazor messaggi di autenticazione a livello di Debug log.

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

Nota

Razori componenti di cui viene eseguito il rendering nel client accedono solo alla console degli strumenti di sviluppo del browser sul lato client.

Risorse aggiuntive

• Registrazione in .NET Core e ASP.NET Core
• Loglevel Enumerazione (documentazione dell'API)
• Implementare un provider di registrazione personalizzato in .NET
• Documentazione degli strumenti di sviluppo del browser:
  • Chrome DevTools (Strumenti di sviluppo di Chrome)
  • Firefox Developer Tools (Strumenti di sviluppo di Firefox)
  • Panoramica degli strumenti di sviluppo di Microsoft Edge
• Blazorrepository GitHub di esempi () (dotnet/blazor-samplescome scaricare)