O registro de logs é uma técnica essencial em C# que captura informações, avisos, erros e outros dados relevantes enquanto um aplicativo está em execução. Isso ajuda os desenvolvedores a monitorar o comportamento de seus programas, solucionar problemas e compreender como o aplicativo funciona em diversos contextos. O C# oferece algumas estruturas e pacotes de registro (logging) para facilitar as tarefas de registro de logs. Microsoft.Extensions.Logging está entre os frameworks de registro de logs mais utilizados em aplicações .NET Core . O pacote Microsoft.Extensions.Logging NuGet for .NET Core nos dá acesso a vários métodos de extensão para nos ajudar a escrever diferentes níveis de log. Neste artigo, vamos ver mais sobre o registro de logs da Microsoft.
Microsoft.Extensions.Logging a partir da página do pacote Microsoft.Extensions.Logging no NuGet.Logger no console.Para começar, crie um novo projeto no Visual Studio.
Instale a biblioteca Microsoft.Extensions.Logging usando a página do pacote Microsoft.Extensions.Logging no NuGet. Esta biblioteca fornece as classes e os métodos necessários para o registro de logs em aplicações .NET Core .
Para usar a funcionalidade de logging, você precisa injetar uma instância da interface ILogger em sua aplicação de console. Isso pode ser feito usando uma fábrica de registro de logs.
using Microsoft.Extensions.Logging;
// Create a logger for the application
ILogger<Program> logger = LoggerFactory.Create(builder =>
{
builder.AddConsole(); // Adding console logging
}).CreateLogger<Program>();Imports Microsoft.Extensions.Logging
' Create a logger for the application
Private logger As ILogger(Of Program) = LoggerFactory.Create(Sub(builder)
builder.AddConsole() ' Adding console logging
End Sub).CreateLogger<Program>()Configure como os registros devem ser exibidos. Isso pode ser feito adicionando um ou mais provedores de registro ao construtor de registros. O provedor mais comum é o logger do console, que exibe os logs no console.
builder.AddConsole(options =>
{
options.TimestampFormat = "[HH:mm:ss] "; // Setting the timestamp format for logs
});builder.AddConsole(Sub(options)
options.TimestampFormat = "[HH:mm:ss] " ' Setting the timestamp format for logs
End Sub)Agora você pode gravar logs em diferentes níveis usando o objeto logger. Os métodos de logging disponíveis são LogDebug(), LogInformation(), LogWarning(), LogError() e LogCritical().
logger.LogDebug("This is a debug message");
logger.LogInformation("This is an information message");
logger.LogWarning("This is a warning message");
logger.LogError("This is an error message");
logger.LogCritical("This is a critical message");logger.LogDebug("This is a debug message")
logger.LogInformation("This is an information message")
logger.LogWarning("This is a warning message")
logger.LogError("This is an error message")
logger.LogCritical("This is a critical message")Por fim, execute o código e observe os registros gerados de acordo com as configurações definidas.
É isso! Você configurou e utilizou com sucesso o registro de logs da Microsoft em seu aplicativo C#.
Para instalar o MS Logging, siga estes passos:
Inicie o Visual Studio.
Navegue até Ferramentas > Gerenciador de Pacotes NuGet > Console do Gerenciador de Pacotes .
No Console do Gerenciador de Pacotes, execute o seguinte comando:
Install-Package Microsoft.Extensions.LoggingPressione Enter para executar o comando. Isso irá baixar e instalar o pacote Microsoft.Extensions.Logging em seu projeto.
Vários níveis de logging estão disponíveis no framework Microsoft.Extensions.Logging em C#, permitindo que os desenvolvedores classifiquem e classifiquem mensagens de log de acordo com sua importância e severidade. Esses níveis são frequentemente usados para distinguir entre vários tipos de mensagens e auxiliar na regulação da verbosidade dos registros.
Os níveis de logging padrão oferecidos por Microsoft.Extensions.Logging são os seguintes:
Cada nível de registro tem uma finalidade específica e oferece aos desenvolvedores a capacidade de gerenciar a quantidade de dados que a estrutura de registro gera. Os desenvolvedores podem escolher o nível apropriado para o registro de mensagens com base na gravidade e importância dos dados registrados.
Aqui está um exemplo básico de como configurar o logging usando Microsoft.Extensions.Logging:
using Microsoft.Extensions.Logging;
using System;
class Program
{
// Create a LoggerFactory instance
private static readonly ILoggerFactory LoggerFactory = LoggerFactory.Create(builder =>
{
// Add console logger
builder.AddConsole();
// You can add other logging providers here (e.g., AddDebug, AddFile, etc.)
});
// Create a logger
private static readonly ILogger Logger = LoggerFactory.CreateLogger<Program>();
static void Main(string[] args)
{
// Example log messages
Logger.LogInformation("Information log");
Logger.LogWarning("Warning log");
Logger.LogError("Error log");
try
{
// Simulate an exception
throw new Exception("Exception occurred");
}
catch (Exception ex)
{
// Log exception details
Logger.LogError(ex, "Exception log");
}
Console.ReadKey(); // Wait for a key press before closing the application
}
}Imports Microsoft.Extensions.Logging
Imports System
Friend Class Program
' Create a LoggerFactory instance
Private Shared ReadOnly LoggerFactory As ILoggerFactory = LoggerFactory.Create(Sub(builder)
' Add console logger
builder.AddConsole()
' You can add other logging providers here (e.g., AddDebug, AddFile, etc.)
End Sub)
' Create a logger
Private Shared ReadOnly Logger As ILogger = LoggerFactory.CreateLogger(Of Program)()
Shared Sub Main(ByVal args() As String)
' Example log messages
Logger.LogInformation("Information log")
Logger.LogWarning("Warning log")
Logger.LogError("Error log")
Try
' Simulate an exception
Throw New Exception("Exception occurred")
Catch ex As Exception
' Log exception details
Logger.LogError(ex, "Exception log")
End Try
Console.ReadKey() ' Wait for a key press before closing the application
End Sub
End ClassNeste exemplo, um logger de console é adicionado à configuração de registro, que grava logs no console. No entanto, Microsoft.Extensions.Logging oferece vários provedores de logging, incluindo logging para arquivos, bancos de dados ou conexão com outros frameworks de logging. Além disso, é possível criar provedores de registro personalizados que podem formatar os registros de acordo com requisitos específicos.
Você pode adicionar fontes de logging adicionais encadeando os métodos relevantes dentro da função Create(). Por exemplo:
builder.AddDebug().builder.AddFile("log.txt").O IronPDF se destaca na conversão de HTML para PDF , garantindo a preservação precisa dos layouts e estilos originais. É perfeito para criar PDFs a partir de conteúdo da web, como relatórios, faturas e documentação. Com suporte para arquivos HTML, URLs e strings HTML brutas, o IronPDF produz facilmente documentos PDF de alta qualidade.
using IronPdf;
class Program
{
static void Main(string[] args)
{
var renderer = new ChromePdfRenderer();
// 1. Convert HTML String to PDF
var htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>";
var pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent);
pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf");
// 2. Convert HTML File to PDF
var htmlFilePath = "path_to_your_html_file.html"; // Specify the path to your HTML file
var pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath);
pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf");
// 3. Convert URL to PDF
var url = "http://ironpdf.com"; // Specify the URL
var pdfFromUrl = renderer.RenderUrlAsPdf(url);
pdfFromUrl.SaveAs("URLToPDF.pdf");
}
}Imports IronPdf
Friend Class Program
Shared Sub Main(ByVal args() As String)
Dim renderer = New ChromePdfRenderer()
' 1. Convert HTML String to PDF
Dim htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>"
Dim pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent)
pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf")
' 2. Convert HTML File to PDF
Dim htmlFilePath = "path_to_your_html_file.html" ' Specify the path to your HTML file
Dim pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath)
pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf")
' 3. Convert URL to PDF
Dim url = "http://ironpdf.com" ' Specify the URL
Dim pdfFromUrl = renderer.RenderUrlAsPdf(url)
pdfFromUrl.SaveAs("URLToPDF.pdf")
End Sub
End ClassPara habilitar o logging no IronPDF, você pode usar o framework Microsoft.Extensions.Logging juntamente com as capacidades de logging embutidas do IronPDF. Aqui está um exemplo de como configurar o registro de logs no IronPDF:
using Microsoft.Extensions.Logging;
using IronPdf;
class Program
{
static void Main(string[] args)
{
ILoggerFactory loggerFactory = LoggerFactory.Create(builder =>
{
builder
.AddConsole()
.AddDebug();
});
ILogger<Program> logger = loggerFactory.CreateLogger<Program>();
// Enable logging in IronPDF
Logger.Log = new LoggerImplementation(logger);
// Use IronPDF and perform operations
// ...
// Example of logging an error in IronPDF
Logger.Log.Error("An error occurred while processing the PDF");
// Example of logging a warning in IronPDF
Logger.Log.Warning("This is a warning message");
// Example of logging an information message in IronPDF
Logger.Log.Information("This is an information message");
// ...
// Close and dispose resources
// ...
// Flush the log messages
loggerFactory.Dispose();
}
}Imports Microsoft.Extensions.Logging
Imports IronPdf
Friend Class Program
Shared Sub Main(ByVal args() As String)
Dim loggerFactory As ILoggerFactory = LoggerFactory.Create(Sub(builder)
builder.AddConsole().AddDebug()
End Sub)
Dim logger As ILogger(Of Program) = loggerFactory.CreateLogger(Of Program)()
' Enable logging in IronPDF
Logger.Log = New LoggerImplementation(logger)
' Use IronPDF and perform operations
' ...
' Example of logging an error in IronPDF
Logger.Log.Error("An error occurred while processing the PDF")
' Example of logging a warning in IronPDF
Logger.Log.Warning("This is a warning message")
' Example of logging an information message in IronPDF
Logger.Log.Information("This is an information message")
' ...
' Close and dispose resources
' ...
' Flush the log messages
loggerFactory.Dispose()
End Sub
End ClassNeste exemplo, criamos uma instância do LoggerFactory do framework Microsoft.Extensions.Logging. Em seguida, criamos um logger da fábrica para a classe Program.
Para habilitar o logging no IronPDF, definimos a propriedade estática Logger.Log para uma instância de LoggerImplementation que obtém o logger de loggerFactory. Com essa configuração, você pode usar os métodos Logger.Log para registrar mensagens dentro do IronPDF.
Após realizar as operações necessárias com o IronPDF, você pode fechar e dispensar recursos, e então liberar as mensagens de log descartando o loggerFactory.
Nota: Certifique-se de ter as dependências e pacotes necessários instalados para Microsoft.Extensions.Logging e IronPDF.
Para instalar a biblioteca IronPDF , siga estes passos:
Alternativamente, você pode usar a CLI do .NET executando o seguinte comando no terminal:
Também é possível instalar a biblioteca IronPDF usando a interface gráfica do gerenciador de pacotes NuGet . Basta pesquisar o pacote "IronPDF" na aba Procurar, selecionar o pacote desejado na lista e instalar a versão mais recente do IronPDF.
Após a conclusão da instalação, você poderá começar a usar a biblioteca IronPDF em seu projeto.
A partir de janeiro de 2022, o IronPDF não interage diretamente com Microsoft.Extensions.Logging e não é suportado nativamente. O IronPDF é usado principalmente como uma ferramenta para criar e modificar PDFs em programas C#.
No entanto, você ainda pode incorporar o registro de logs usando o Microsoft.Extensions. Ao integrar o registro de logs ao seu programa C# juntamente com o IronPDF, você pode gerenciar e registrar eventos relacionados à produção de PDFs, ao fluxo de trabalho do aplicativo ou a problemas que ocorram ao usar o IronPDF.
Aqui está um exemplo de como usar o Microsoft.Extensions para integrar o registro de logs com o IronPDF:
using Microsoft.Extensions.Logging;
using IronPdf;
using System;
class Program
{
private static readonly ILoggerFactory LoggerFactory = LoggerFactory.Create(builder =>
{
builder.AddConsole(); // Add other logging providers as needed
});
private static readonly ILogger Logger = LoggerFactory.CreateLogger<Program>();
static void Main(string[] args)
{
try
{
// Your IronPDF code for PDF generation or manipulation
var Renderer = new IronPdf.HtmlToPdf();
var PDF = Renderer.RenderHtmlAsPdf("<h1>Hello World!</h1>");
PDF.SaveAs("Output.pdf");
Logger.LogInformation("PDF created successfully.");
}
catch (Exception ex)
{
Logger.LogError(ex, "An error occurred while generating the PDF.");
}
Console.ReadKey(); // Wait for a key press before closing the application
}
}Imports Microsoft.Extensions.Logging
Imports IronPdf
Imports System
Friend Class Program
Private Shared ReadOnly LoggerFactory As ILoggerFactory = LoggerFactory.Create(Sub(builder)
builder.AddConsole() ' Add other logging providers as needed
End Sub)
Private Shared ReadOnly Logger As ILogger = LoggerFactory.CreateLogger(Of Program)()
Shared Sub Main(ByVal args() As String)
Try
' Your IronPDF code for PDF generation or manipulation
Dim Renderer = New IronPdf.HtmlToPdf()
Dim PDF = Renderer.RenderHtmlAsPdf("<h1>Hello World!</h1>")
PDF.SaveAs("Output.pdf")
Logger.LogInformation("PDF created successfully.")
Catch ex As Exception
Logger.LogError(ex, "An error occurred while generating the PDF.")
End Try
Console.ReadKey() ' Wait for a key press before closing the application
End Sub
End ClassEste exemplo demonstra uma maneira simples de configurar o Microsoft.Extensions.Logging em um aplicativo C# que usa o IronPDF. As mensagens de registro são geradas para documentar a criação bem-sucedida de PDFs e para registrar quaisquer exceções que possam ocorrer.
Certifique-se de personalizar os níveis de registro, o tratamento de erros e as mensagens de acordo com as necessidades específicas da sua aplicação e os cenários em que o IronPDF é usado para criação ou modificação de PDFs. Diferenciar corretamente os diferentes tipos de mensagens de log usando níveis de registro pode ser útil para depuração e monitoramento eficazes.
Para saber mais sobre o IronPDF, visite a página inicial do IronPDF .
Em resumo, a integração do Microsoft.Extensions.Logging permite que os desenvolvedores C# lidem com tarefas de registro de logs de forma eficaz. O IronPDF oferece recursos abrangentes de registro, permitindo o registro, análise e geração de relatórios detalhados de eventos, falhas e dados vitais do aplicativo. Isso melhora a confiabilidade, a manutenção e a depuração do aplicativo.
O IronPDF oferece diferentes produtos de software, incluindo um pacote Lite com preço de $999. Este pacote inclui uma licença permanente, opções de atualização, um ano de manutenção do software e uma garantia de reembolso de trinta dias. Durante o período de avaliação com marca d'água, você pode explorar os recursos do IronPDF. Para saber mais sobre os produtos de software oferecidos pela Iron Software, visite o site oficial da Iron Software .
Curtis Chau é bacharel em Ciência da Computação (Universidade Carleton) e se especializa em desenvolvimento front-end, com experiência em Node.js, TypeScript, JavaScript e React. Apaixonado por criar interfaces de usuário intuitivas e esteticamente agradáveis, Curtis gosta de trabalhar com frameworks modernos e criar manuais bem estruturados e visualmente atraentes.
IronPDF faz parte do IRON SUITE.
10 produtos de API .NET para seus documentos de escritório
Quando você precisa que seu PDF tenha a aparência de HTML, rapidamente.
