AYUDA .NET

Registro de Microsoft C# (Cómo Funciona para Desarrolladores)

Publicado en 27 de enero, 2024

Introducción

El registro es una técnica esencial en C# que captura información, advertencias, errores y otros datos pertinentes mientras se ejecuta una aplicación. Ayuda a los desarrolladores a controlar el comportamiento de sus programas, solucionar problemas y comprender cómo funciona la aplicación en distintos contextos. C# ofrece algunos marcos y paquetes de registro para facilitar las tareas de registro. Microsoft.Extensions.Logging es uno de los marcos de registro más utilizados en las aplicaciones .NET Core. El paquete NuGet Microsoft.Extensions.Logging para .NET Core nos da acceso a varios métodos de extensión para ayudarnos a escribir diferentes niveles de registro. En este artículo, vamos a ver más sobre el registro de MS.

Cómo configurar el registro de MS

Crear un nuevoVisual Studio proyecto.
Instale la biblioteca Microsoft.Extensions.Logging desdela página del paquete Microsoft.Extensions.Logging en NuGet.
Inyecta la interfaz Logger en la consola.
Configure la salida de registro.
Escribir registros a diferentes niveles.
Ejecuta el código.

Paso 1: Crear un nuevo proyecto de Visual Studio

Para empezar, cree un nuevo proyecto en Visual Studio.

Paso 2: Instalar la biblioteca Microsoft.Extensions.Logging

Instale la librería Microsoft.Extensions.Logging usandola página del paquete Microsoft.Extensions.Logging en NuGet. Esta biblioteca proporciona las clases y métodos necesarios para el registro en aplicaciones .NET Core.

Paso 3: Inyectar la interfaz Logger en la consola

Para utilizar la funcionalidad de registro, debe inyectar una instancia de la interfaz Logger en su aplicación de consola. Esto puede hacerse utilizando un marco de inyección de dependencias o creando manualmente una instancia de la clase Logger.

using Microsoft.Extensions.Logging;

// Inject the logger into the console
ILogger logger = LoggerFactory.Create(builder =>
{
    builder.AddConsole();
}).CreateLogger<Program>();

using Microsoft.Extensions.Logging;

// Inject the logger into the console
ILogger logger = LoggerFactory.Create(builder =>
{
    builder.AddConsole();
}).CreateLogger<Program>();

Imports Microsoft.Extensions.Logging

' Inject the logger into the console
Private logger As ILogger = LoggerFactory.Create(Sub(builder)
	builder.AddConsole()
End Sub).CreateLogger<Program>()

VB C#

Paso 4: Configurar la salida de registro

Configure la salida de los registros. Esto puede hacerse añadiendo uno o más proveedores de registro al generador de registros. El proveedor más común es el registrador de consola, que envía los registros a la consola.

builder.AddConsole(options =>
{
    options.TimestampFormat = "[HH:mm:ss] ";
});

builder.AddConsole(options =>
{
    options.TimestampFormat = "[HH:mm:ss] ";
});

builder.AddConsole(Sub(options)
	options.TimestampFormat = "[HH:mm:ss] "
End Sub)

VB C#

Paso 5: Escribir registros a distintos niveles

Ahora puede escribir registros a diferentes niveles utilizando el objeto logger. Los métodos de registro disponibles son LogDebug(), LogInformation(), LogWarning(), LogError(), y 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");

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

VB C#

Paso 6: Ejecutar el código

Por último, ejecute su código y observe la salida de los registros de acuerdo con los ajustes configurados.

Ya está.! Ha configurado y utilizado correctamente el registro de MS en su aplicación C#.

Instalar MS Logging

Para instalar MS Logging, siga estos pasos:

Inicie Visual Studio.
Vaya a Herramientas > Gestor de paquetes NuGet > Consola del gestor de paquetes.
En la consola del gestor de paquetes, ejecute el siguiente comando:

    Install-Package Microsoft.Extensions.Logging

Pulse Intro para ejecutar el comando. Esto descargará e instalará el paquete Microsoft.Extensions.Logging en su proyecto.

Niveles de registro

El framework Microsoft.Extensions.Logging en C# dispone de varios niveles de registro que permiten a los desarrolladores clasificar y ordenar los mensajes de registro en función de su importancia y gravedad. Estos niveles se utilizan con frecuencia para distinguir entre varios tipos de mensajes y ayudan a regular la verbosidad de los registros.

Los niveles de registro por defecto que ofrece Microsoft.Extensions.Logging son los siguientes:

Rastreo: El nivel más exhaustivo, a menudo empleado para datos increíblemente detallados que ofrecen un profundo nivel de comprensión del funcionamiento interno del programa.
Depuración: Información de depuración que resulta útil durante las fases de desarrollo y depuración, pero que no suele ser necesaria en un entorno de producción.
Información: Ofrece detalles sobre el funcionamiento normal de la aplicación. Normalmente, el funcionamiento regular del programa se controla utilizando estos registros.
Advertencia: Señala un posible problema o algo que puede requerir atención en el futuro. Se utiliza para situaciones anómalas o inesperadas que podrían dar lugar a problemas pero que no necesariamente provocan el bloqueo del programa.
Error: Señala un problema o error grave que debe solucionarse inmediatamente. Suele utilizarse para registrar problemas que afectan al funcionamiento de la aplicación.
Crítico: El estado más grave, utilizado para registrar problemas críticos que deben ser abordados inmediatamente ya que podrían causar problemas graves o caídas del programa.
Cada nivel de registro tiene una finalidad específica y ofrece a los desarrolladores la posibilidad de gestionar la cantidad de datos que genera el marco de registro. Los desarrolladores pueden elegir el nivel adecuado para el registro de mensajes en función de la gravedad y la importancia de los datos registrados.

Configuración del registro en C

A continuación se muestra un ejemplo básico de cómo configurar el registro utilizando 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();
    }
}

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

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()
	End Sub
End Class

VB C#

En este ejemplo, se añade un registrador de consola a la configuración de registro, que escribe los registros en la consola. Sin embargo, Microsoft.Extensions.Logging ofrece varios proveedores de registro, incluyendo el registro en archivos, bases de datos, o la conexión con otros marcos de registro. Además, es posible crear proveedores de registro personalizados que pueden dar formato a los registros según requisitos específicos.

Incluir proveedores adicionales para el registro

Puede añadir fuentes de registro adicionales encadenando los métodos correspondientes dentro de la función Create() función. Por ejemplo:

Para añadir un proveedor de registro de salida de depuración, utilice builder.AddDebug().
Para añadir un proveedor de registro de archivos, utilice builder.AddFile("log.txt").

MSLogging en IronPDF

Para habilitar el registro en IronPDF, puede utilizar el marco Microsoft.Extensions.Logging junto con las capacidades de registro incorporadas de IronPDF. A continuación se muestra un ejemplo de cómo configurar el registro en 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();
    }
}

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 Class

VB C#

En este ejemplo, creamos una instancia del LoggerFactory del framework Microsoft.Extensions.Logging. A continuación, creamos un registrador de la fábrica para la clase Program.

Para habilitar el registro en IronPDF, establecemos la propiedad estática Logger.Log a una instancia de LoggerImplementation que toma el logger de loggerFactory. Con esta configuración, puede utilizar métodos Logger.Log para registrar mensajes dentro de IronPDF.

Después de realizar las operaciones necesarias con IronPDF, puede cerrar y deshacerse de los recursos y, a continuación, vaciar los mensajes de registro deshaciéndose del loggerFactory.

Nota: Asegúrese de que tiene instaladas las dependencias y paquetes necesarios para Microsoft.Extensions.Logging e IronPDF.

Instalar IronPDF

Para instalar la biblioteca IronPDF, siga estos pasos:

Abra la consola del gestor de paquetes en Visual Studio.
Introduzca el siguiente comando para instalar la biblioteca IronPDF utilizando NuGet:

Install-Package IronPdf

También puede utilizar la CLI .NET ejecutando el siguiente comando en el terminal:

dotnet add package IronPdf

Pulse Intro para ejecutar el comando. Esto descargará e instalará el paquete IronPDF en su proyecto.
También es posible instalar la biblioteca IronPDF mediante la interfaz gráfica de usuario del gestor de paquetes NuGet. Sólo tiene que buscar el paquete "IronPDF" en la pestaña Examinar, seleccionar el paquete deseado de la lista e instalar la última versión de IronPDF.
Una vez finalizada la instalación, puede empezar a utilizar la biblioteca IronPDF en su proyecto.

Registro de MS mediante IronPDF

A partir de enero de 2022, IronPDF no interactúa directamente con Microsoft.Extensions.Logging y no es compatible de forma nativa. IronPDF se utiliza principalmente como herramienta para crear y modificar PDF en programas C#.

No obstante, puede incorporar el registro mediante Microsoft.Extensions. Al integrar el registro en su programa C# junto con IronPDF, puede gestionar y registrar los eventos relacionados con la producción de PDF, el flujo de trabajo de la aplicación o los problemas que se producen al utilizar IronPDF.

He aquí un ejemplo de cómo utilizar Microsoft.Extensions para integrar el registro con 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();
    }
}

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

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()
	End Sub
End Class

VB C#

Este ejemplo muestra una forma sencilla de configurar Microsoft.Extensions.Logging en una aplicación C# que utiliza IronPDF. Los mensajes de registro se generan para documentar la creación correcta de PDF y para registrar cualquier excepción que pueda producirse.

Asegúrese de personalizar los niveles de registro, la gestión de errores y los mensajes según las necesidades específicas de su aplicación y los escenarios en los que se utiliza IronPDF para la creación o modificación de PDF. Diferenciar adecuadamente los distintos tipos de mensajes de registro mediante los niveles de registro puede ser útil para una depuración y supervisión eficaces.

Para obtener más información sobre IronPDF, visite la página webPágina principal de IronPDF,.

Conclusión

En conclusión, la integración de Microsoft.Extensions.Logging permite a los desarrolladores de C# gestionar eficazmente las tareas de registro. IronPDF proporciona funciones completas de registro, lo que permite registrar, analizar y elaborar informes exhaustivos de los eventos, fallos y datos vitales de las aplicaciones. Esto mejora la fiabilidad, el mantenimiento y la depuración de las aplicaciones.

IronPDF ofrece diferentes productos de software, incluido un paquete Lite con un precio de $749. Este paquete incluye una licencia permanente, opciones de actualización, un año de mantenimiento del software y una garantía de devolución del dinero de treinta días. Durante el periodo de prueba con marca de agua, puede explorar las funciones de IronPDF. Para obtener más información sobre los productos de software que ofrece Iron Software, visiteSitio web oficial de Iron Software.

< ANTERIOR
Cefsharp.WPF.NET Core (Cómo Funciona Para Desarrolladores)

SIGUIENTE >
Serilog .NET (Cómo funciona para desarrolladores)