El registro es un aspecto esencial del desarrollo de software. Ayuda a los desarrolladores a seguir el comportamiento de sus aplicaciones, solucionar problemas y obtener información sobre el rendimiento de su código en distintos entornos. NLog es un popular marco de registro para C# que facilita la implementación de un registro robusto y flexible en sus aplicaciones. En esta completa guía y tutorial, exploraremos el mundo de NLog en C#.

¿Qué es NLog?

NLog es una biblioteca de registro gratuita y de código abierto para aplicaciones .NET y .NET Core. Proporciona una forma flexible y altamente configurable de registrar mensajes en su aplicación. NLog es una plataforma de registro libre muy utilizada en el ecosistema .NET debido a su rendimiento, extensibilidad y facilidad de uso.

Primeros pasos con NLog

Podemos utilizar NLog en Aplicaciones Web ASP.NET, APIs WEB ASP.NET, Aplicaciones Windows Form, Aplicaciones MVC ASP.NET, o cualquier tipo según nuestras necesidades. Utilizaremos la Aplicación de Consola para demostrar todos los casos de uso.

Instalar el paquete nLog Nuget

Para empezar a utilizar NLog, tendrás que instalar el paquete NLog NuGet en tu proyecto. Puede hacerlo a través del gestor de paquetes NuGet en Visual Studio siguiendo los pasos que se indican a continuación:

1. En el menú "Herramientas", seleccione "Gestor de paquetes NuGet" y, a continuación, "Gestionar paquetes NuGet para la solución".

2. O bien, haga clic con el botón derecho en el proyecto en el Explorador de soluciones, seleccione "Administrar paquetes NuGet" y elija "Examinar".

3. En la ventana del Gestor de paquetes NuGet, haz clic en la pestaña "Examinar" y, en el cuadro de búsqueda, escribe "NLog".

4. Debería ver el paquete NLog en los resultados de la búsqueda. Haga clic en él para seleccionarlo.

5. En la parte derecha de la ventana de NuGet Package Manager, hay una lista de proyectos en su solución. Seleccione el proyecto(s) donde desea instalar NLog.

6. Elija la versión deseada del paquete NLog en el desplegable de versiones. Puede seleccionar la última versión estable o una versión específica si es necesario.

7. Tras seleccionar el proyecto(s) y la versión, haga clic en el botón "Instalar" para iniciar el proceso de instalación.

   El gestor de paquetes NuGet descargará e instalará NLog y cualquier dependencia. Verá el progreso en la ventana de salida.

   NLog está ahora instalado con éxito en su proyecto, y puede empezar a utilizarlo para el registro dentro de su código C#.

Crear archivo de configuración NLog

Para crear un archivo de configuración NLog(normalmente llamado nlog.config)puede seguir estos pasos. Este archivo de configuración especificará cómo NLog debe comportarse en su aplicación, incluyendo objetivos de registro, renderizadores de diseño y reglas.

En su proyecto, haga clic con el botón derecho del ratón en el proyecto o en la carpeta deseada donde desee crear el archivo de configuración.

1. Seleccione "Añadir" > "Nuevo elemento...".

2. En el cuadro de diálogo "Añadir nuevo elemento", busque "Archivo XML" o "XML" y selecciónelo.

3. Nombra el archivo nlog.config y haz clic en el botón "Añadir".

   

4. Abra el archivo nlog.config recién creado en un editor de texto o XML.

5. Añada la siguiente configuración en el archivo NLog.XML. A continuación se muestra un ejemplo básico de una configuración NLog que registra mensajes en un destino Consola. Puede personalizar este archivo de configuración para adaptarlo a sus necesidades:

Archivo de configuración

<?xml version="1.0" encoding="utf-8" ?>
<nlog xmlns="http://www.nlog-project.org/schemas/NLog.xsd"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">

  <!-- Define targets -->
  <targets>
    <!-- Log to a file -->
    <target name="console" xsi:type="Console" layout="${longdate}
${message}"/>
  </targets>

  <!-- Define rules -->
  <rules>
    <!-- All messages with a minimum log level of Debug or higher are written to the Console -->
    <logger name="*" minlevel="Debug" writeTo="Console" />
  </rules>

</nlog>

<?xml version="1.0" encoding="utf-8" ?>
<nlog xmlns="http://www.nlog-project.org/schemas/NLog.xsd"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">

  <!-- Define targets -->
  <targets>
    <!-- Log to a file -->
    <target name="console" xsi:type="Console" layout="${longdate}
${message}"/>
  </targets>

  <!-- Define rules -->
  <rules>
    <!-- All messages with a minimum log level of Debug or higher are written to the Console -->
    <logger name="*" minlevel="Debug" writeTo="Console" />
  </rules>

</nlog>

En su código C#, asegúrese de cargar la configuración NLog desde el archivo nlog.config. Normalmente esto se hace en el código de inicio de la aplicación, como en un ASP.NET Core Startup.cs(para .NET Versión igual o anterior a .NET 5)Archivo program.cs(para .NET 6 o una versión posterior) o el método Main de una aplicación de consola:

internal class Program
{
    private static Logger logger = LogManager.GetCurrentClassLogger();
    static void Main(string [] args)
    {
        logger.Debug("This is Debug Message");
        Console.Read();
    }
}

internal class Program
{
    private static Logger logger = LogManager.GetCurrentClassLogger();
    static void Main(string [] args)
    {
        logger.Debug("This is Debug Message");
        Console.Read();
    }
}

Friend Class Program
	Private Shared logger As Logger = LogManager.GetCurrentClassLogger()
	Shared Sub Main(ByVal args() As String)
		logger.Debug("This is Debug Message")
		Console.Read()
	End Sub
End Class

La salida del programa anterior es como:

En este ejemplo, creamos una instancia de la clase Logger y la utilizamos para registrar mensajes en el nivel Debug. Exploremos el nivel de rastreo soportado por NLog.

Niveles de registro

NLog admite varios niveles de registro, cada uno con su propia importancia:

1. Rastreo: El nivel más detallado, utilizado normalmente con fines de diagnóstico.

2. Depurar: Se utiliza para información de depuración que puede ser útil durante el desarrollo.

3. Información: Información general sobre el funcionamiento de la aplicación.

4. Advertencia: Indica un problema potencial que no interrumpe la aplicación.

5. Error: Indica un fallo que debe ser investigado pero que no necesariamente bloquea la aplicación.

6. Fatal: Indica un fallo crítico que debe solucionarse inmediatamente.

   Al clasificar los mensajes de registro en estos niveles, puede filtrarlos y priorizarlos fácilmente en función de su gravedad.

   Establezca minlevel="Trace" en la etiqueta rules de su archivo nLog.Config como se muestra a continuación.

<rules>
  <!-- All messages with a minimum log level of Trace or higher are written to the Console -->
  <logger name="*" minlevel="Trace" writeTo="Console" />
</rules>

<rules>
  <!-- All messages with a minimum log level of Trace or higher are written to the Console -->
  <logger name="*" minlevel="Trace" writeTo="Console" />
</rules>

Escribamos un código para registrar los mensajes de todos los niveles de seguimiento.

internal class Program
{
    private static Logger logger = LogManager.GetCurrentClassLogger();
    static void Main(string [] args)
    {
        logger.Trace("This is Trace Message");
        logger.Debug("This is Debug Message");
        logger.Info("This is Info Message");
        logger.Warn("This is Warning Message");
        logger.Error("This is Error Message");
        logger.Fatal("This is Fatal Message");
        Console.Read();
    }
}

internal class Program
{
    private static Logger logger = LogManager.GetCurrentClassLogger();
    static void Main(string [] args)
    {
        logger.Trace("This is Trace Message");
        logger.Debug("This is Debug Message");
        logger.Info("This is Info Message");
        logger.Warn("This is Warning Message");
        logger.Error("This is Error Message");
        logger.Fatal("This is Fatal Message");
        Console.Read();
    }
}

Friend Class Program
	Private Shared logger As Logger = LogManager.GetCurrentClassLogger()
	Shared Sub Main(ByVal args() As String)
		logger.Trace("This is Trace Message")
		logger.Debug("This is Debug Message")
		logger.Info("This is Info Message")
		logger.Warn("This is Warning Message")
		logger.Error("This is Error Message")
		logger.Fatal("This is Fatal Message")
		Console.Read()
	End Sub
End Class

Nuestro Programa ha registrado mensajes en la Consola como se muestra a continuación.

Ahora, hemos demostrado el ejemplo de registro de mensajes en la consola, Ahora vamos a configurar NLog objetivo para registrar los mensajes en el archivo.

Mensaje de registro en el archivo

Tenemos que establecer un objetivo de archivo en lugar de un objetivo de consola en nuestro archivo de configuración para el registro de archivos.

  <targets>
  <target xsi:type="File" name="fileTarget" fileName="D:\Logs\mylog.txt" layout="${longdate} ${level:uppercase=true} ${message}" />
</targets>

<rules>
  <logger name="*" minlevel="Trace" writeTo="fileTarget" />
</rules>

  <targets>
  <target xsi:type="File" name="fileTarget" fileName="D:\Logs\mylog.txt" layout="${longdate} ${level:uppercase=true} ${message}" />
</targets>

<rules>
  <logger name="*" minlevel="Trace" writeTo="fileTarget" />
</rules>

Ahora, ejecute el programa para registrar los mensajes en un archivo.

Objetivos de registro

NLog admite varios destinos de salida de registro, lo que le permite elegir dónde deben almacenarse los mensajes de registro. Algunos objetivos habituales son:

1. Archivo: Registra los mensajes en uno o varios archivos.

2. Consola: Registra mensajes en la consola.

3. Base de datos: Registra los mensajes en una base de datos(SQL Server, MySQL, Oracle, PostgreSQL, etc.) mesa.

4. Correo electrónico: Envía los mensajes de registro como correos electrónicos.

5. Registro de sucesos: Registra mensajes en el registro de sucesos de Windows.

6. Objetivos personalizados: Puedes crear objetivos de registro personalizados que se adapten a tus necesidades específicas.

   Puedes configurar NLog para que utilice uno o varios objetivos simultáneamente.

Presentación de IronPDF

Más información sobre IronPDF es una potente biblioteca .NET que simplifica el manejo de PDF en aplicaciones C# y VB.NET. Ofrece sólidas funciones de creación, edición y manipulación de documentos PDF, así como de conversión de contenidos HTML a formato PDF, lo que la convierte en una herramienta esencial para desarrolladores de una amplia gama de sectores, como el desarrollo web, la elaboración de informes y la gestión de documentos.

La característica más destacada de IronPDF es suConversión de HTML a PDF que conserva sus diseños y estilos. Genera archivos PDF a partir de contenido web, por lo que es ideal para informes, facturas y documentación. Los archivos HTML, las URL y las cadenas HTML pueden convertirse fácilmente en PDF.

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

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 Class

Vamos a generar un PDF con registro.

Generación de PDF con registro

El primer paso es instalar la biblioteca IronPDF en nuestro proyecto. Podemos hacerlo utilizando el gestor de paquetes NuGet en Visual Studio o a través de la CLI de NuGet. Abra su proyecto y escriba el siguiente comando en la consola del gestor de paquetes.

Install-Package IronPdf

Este comando instalará IronPDF con todas las dependencias necesarias en nuestro proyecto.

Escriba el siguiente código para generar un archivo PDF a partir de HTML con registro.

private static Logger logger = LogManager.GetCurrentClassLogger();
static void Main(string [] args)
{
    logger.Info("Initializing Chrome PDF Renderer");
    ChromePdfRenderer renderer = new ChromePdfRenderer();
    logger.Info("Creating PDF From HTML String");
    var pdf = renderer.RenderHtmlAsPdf("<h1>This is my Sample PDF<h1>");
    logger.Info("Saving PDF File");
    pdf.SaveAs(@"D:\myPDF.pdf");
}

private static Logger logger = LogManager.GetCurrentClassLogger();
static void Main(string [] args)
{
    logger.Info("Initializing Chrome PDF Renderer");
    ChromePdfRenderer renderer = new ChromePdfRenderer();
    logger.Info("Creating PDF From HTML String");
    var pdf = renderer.RenderHtmlAsPdf("<h1>This is my Sample PDF<h1>");
    logger.Info("Saving PDF File");
    pdf.SaveAs(@"D:\myPDF.pdf");
}

Private Shared logger As Logger = LogManager.GetCurrentClassLogger()
Shared Sub Main(ByVal args() As String)
	logger.Info("Initializing Chrome PDF Renderer")
	Dim renderer As New ChromePdfRenderer()
	logger.Info("Creating PDF From HTML String")
	Dim pdf = renderer.RenderHtmlAsPdf("<h1>This is my Sample PDF<h1>")
	logger.Info("Saving PDF File")
	pdf.SaveAs("D:\myPDF.pdf")
End Sub

El fragmento de código anterior creará un archivo PDF con un mensaje registrado en el archivo como se muestra a continuación.

Registro y archivo PDF

Conclusión

En conclusión, NLog ha surgido como una herramienta esencial para el registro eficaz en aplicaciones C#, ofreciendo a los desarrolladores un marco robusto para la captura, categorización y gestión de datos de registro. Su flexibilidad y facilidad de uso lo convierten en la opción ideal para las necesidades de registro en diversos ámbitos. Además, cuando se combina con bibliotecas complementarias como IronPDF, que simplifica la generación y manipulación de PDF en aplicaciones .NET, los desarrolladores pueden ampliar sus capacidades de gestión para abarcar la creación de registros e informes basados en PDF. Vale la pena mencionar que IronPDF ofreceprueba gratuita de IronPDF para probar sus funciones. Si cumple sus requisitos, puede optar por unlicencia comercial para IronPDF, proporcionando un acceso continuado a las capacidades de IronPDF con ventajas añadidas y soporte para una integración perfecta en sus proyectos, especialmente para las funcionalidades relacionadas con PDF.

Al emplear conjuntamente la potencia de NLog e IronPDF, los desarrolladores no sólo pueden obtener información sobre el comportamiento de sus aplicaciones, sino también mejorar sus procesos de generación de informes y gestión de documentos, garantizando que su software siga siendo eficiente, mantenible y con un registro estructurado bien documentado.