AYUDA .NET

Microsoft Logging C# (Cómo funciona para desarrolladores)

Actualizado 27 de enero, 2024
Compartir:

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

  1. Crear un nuevo Visual Studio proyecto.
  2. Instale la biblioteca Microsoft.Extensions.Logging desde NuGet.
  3. Inyecta la interfaz Logger en la consola.
  4. Configure la salida de registro.
  5. Escribir registros a diferentes niveles.
  6. 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 usando 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;

//  Inyectar el logger en la consola
ILogger logger = LoggerFactory.Create(builder =>
{
    builder.AddConsole();
}).CreateLogger<Program>();
using Microsoft.Extensions.Logging;

//  Inyectar el logger en la consola
ILogger logger = LoggerFactory.Create(builder =>
{
    builder.AddConsole();
}).CreateLogger<Program>();
Imports Microsoft.Extensions.Logging

'  Inyectar el logger en la consola
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:

  1. Inicie Visual Studio.
  2. Vaya a Herramientas > Gestor de paquetes NuGet > Consola del gestor de paquetes.
  3. En la consola del gestor de paquetes, ejecute el siguiente comando:
    Install-Package Microsoft.Extensions.Logging
  1. 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
{
    //  Crear una instancia de LoggerFactory
    private static readonly ILoggerFactory LoggerFactory = LoggerFactory.Create(builder =>
    {
        //  Añadir logger de consola
        builder.AddConsole();
        //  Aquí puede añadir otros proveedores de registro (por ejemplo, AddDebug, AddFile, etc.)
    });

    //  Crear un registrador
    private static readonly ILogger Logger = LoggerFactory.CreateLogger<Program>();

    static void Main(string [] args)
    {
        //  Ejemplos de mensajes de registro
        Logger.LogInformation("Information log");
        Logger.LogWarning("Warning log");
        Logger.LogError("Error log");

        try
        {
            //  Simular una excepción
            throw new Exception("Exception occurred");
        }
        catch (Exception ex)
        {
            //  Registrar los detalles de la excepción
            Logger.LogError(ex, "Exception log");
        }

        Console.ReadKey();
    }
}
using Microsoft.Extensions.Logging;
using System;

class Program
{
    //  Crear una instancia de LoggerFactory
    private static readonly ILoggerFactory LoggerFactory = LoggerFactory.Create(builder =>
    {
        //  Añadir logger de consola
        builder.AddConsole();
        //  Aquí puede añadir otros proveedores de registro (por ejemplo, AddDebug, AddFile, etc.)
    });

    //  Crear un registrador
    private static readonly ILogger Logger = LoggerFactory.CreateLogger<Program>();

    static void Main(string [] args)
    {
        //  Ejemplos de mensajes de registro
        Logger.LogInformation("Information log");
        Logger.LogWarning("Warning log");
        Logger.LogError("Error log");

        try
        {
            //  Simular una excepción
            throw new Exception("Exception occurred");
        }
        catch (Exception ex)
        {
            //  Registrar los detalles de la excepción
            Logger.LogError(ex, "Exception log");
        }

        Console.ReadKey();
    }
}
Imports Microsoft.Extensions.Logging
Imports System

Friend Class Program
	'  Crear una instancia de LoggerFactory
	Private Shared ReadOnly LoggerFactory As ILoggerFactory = LoggerFactory.Create(Sub(builder)
		'  Añadir logger de consola
		builder.AddConsole()
		'  Aquí puede añadir otros proveedores de registro (por ejemplo, AddDebug, AddFile, etc.)
	End Sub)

	'  Crear un registrador
	Private Shared ReadOnly Logger As ILogger = LoggerFactory.CreateLogger(Of Program)()

	Shared Sub Main(ByVal args() As String)
		'  Ejemplos de mensajes de registro
		Logger.LogInformation("Information log")
		Logger.LogWarning("Warning log")
		Logger.LogError("Error log")

		Try
			'  Simular una excepción
			Throw New Exception("Exception occurred")
		Catch ex As Exception
			'  Registrar los detalles de la excepción
			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>();

        //  Activar el registro en IronPDF
        Logger.Log = new LoggerImplementation(logger);

        //  Utilizar IronPDF y realizar operaciones
        //  ...

        //  Ejemplo de registro de un error en IronPDF
        Logger.Log.Error("An error occurred while processing the PDF");

        //  Ejemplo de registro de una advertencia en IronPDF
        Logger.Log.Warning("This is a warning message");

        //  Ejemplo de registro de un mensaje de información en IronPDF
        Logger.Log.Information("This is an information message");

        //  ...

        //  Cerrar y eliminar recursos
        //  ...

        //  Vaciar los mensajes de registro
        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>();

        //  Activar el registro en IronPDF
        Logger.Log = new LoggerImplementation(logger);

        //  Utilizar IronPDF y realizar operaciones
        //  ...

        //  Ejemplo de registro de un error en IronPDF
        Logger.Log.Error("An error occurred while processing the PDF");

        //  Ejemplo de registro de una advertencia en IronPDF
        Logger.Log.Warning("This is a warning message");

        //  Ejemplo de registro de un mensaje de información en IronPDF
        Logger.Log.Information("This is an information message");

        //  ...

        //  Cerrar y eliminar recursos
        //  ...

        //  Vaciar los mensajes de registro
        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)()

		'  Activar el registro en IronPDF
		Logger.Log = New LoggerImplementation(logger)

		'  Utilizar IronPDF y realizar operaciones
		'  ...

		'  Ejemplo de registro de un error en IronPDF
		Logger.Log.Error("An error occurred while processing the PDF")

		'  Ejemplo de registro de una advertencia en IronPDF
		Logger.Log.Warning("This is a warning message")

		'  Ejemplo de registro de un mensaje de información en IronPDF
		Logger.Log.Information("This is an information message")

		'  ...

		'  Cerrar y eliminar recursos
		'  ...

		'  Vaciar los mensajes de registro
		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 disponer de los recursos, y luego vaciar los mensajes de registro disponiendo 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:

  1. Abra la consola del gestor de paquetes en Visual Studio.
  2. 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
  1. 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(); //  Añadir otros proveedores de registro según sea necesario
    });

    private static readonly ILogger Logger = LoggerFactory.CreateLogger<Program>();

    static void Main(string [] args)
    {
        try
        {
            //  Su código IronPDF para la generación o manipulación de PDF
            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(); //  Añadir otros proveedores de registro según sea necesario
    });

    private static readonly ILogger Logger = LoggerFactory.CreateLogger<Program>();

    static void Main(string [] args)
    {
        try
        {
            //  Su código IronPDF para la generación o manipulación de PDF
            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() '  Añadir otros proveedores de registro según sea necesario
	End Sub)

	Private Shared ReadOnly Logger As ILogger = LoggerFactory.CreateLogger(Of Program)()

	Shared Sub Main(ByVal args() As String)
		Try
			'  Su código IronPDF para la generación o manipulación de PDF
			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 su sitio web oficial.

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 ofrecidos por Iron Software, visite su sitio web oficial en https://ironsoftware.com/.

< ANTERIOR
Cefsharp.WPF.NET Core (Cómo funciona para desarrolladores)
SIGUIENTE >
Serilog .NET (Cómo funciona para desarrolladores)

¿Listo para empezar? Versión: 2024.6 recién publicada

Comenzar prueba gratuita Descargas totales: 9,541,998
Ver licencias >