El registro es un aspecto esencial del desarrollo de software. Ayuda a los desarrolladores a rastrear el comportamiento de sus aplicaciones, solucionar problemas y obtener información sobre cómo está funcionando su código en varios entornos. NLog es un marco de registro popular para C# que facilita la implementación de registros robustos y flexibles en sus aplicaciones. En esta guía y tutorial completos, 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 gratuita ampliamente utilizada en el ecosistema .NET debido a su rendimiento, extensibilidad y facilidad de uso.

Cómo empezar con NLog

Podemos usar NLog en aplicaciones web ASP.NET, API web ASP.NET, aplicaciones de formularios de Windows, aplicaciones ASP.NET MVC o cualquier tipo según nuestras necesidades. Usaremos la aplicación de consola para demostrar todos los casos de uso.

Instalar paquete NuGet de NLog

Para comenzar con NLog, necesitará instalar el paquete NuGet de NLog en su proyecto. Puede hacerlo a través del administrador de paquetes NuGet en Visual Studio siguiendo los pasos:

1. En el menú "Herramientas", seleccione "Administrador de paquetes NuGet," luego elija "Administrar paquetes NuGet para la solución."
2. O, haga clic derecho en su proyecto en el Explorador de soluciones, seleccione "Administrar paquetes NuGet" y elija "Buscar."
3. En la ventana del administrador de paquetes NuGet, haga clic en la pestaña "Buscar" y en el cuadro de búsqueda, escriba "NLog." Debería ver el paquete NLog en los resultados de búsqueda. Haga clic en él para seleccionarlo.
4. En el lado derecho de la ventana del administrador de paquetes NuGet, hay una lista de proyectos en su solución. Seleccione el o los proyectos donde desea instalar NLog.
5. Elija la versión deseada del paquete NLog desde el menú desplegable de versiones. Puede seleccionar la última versión estable o una versión específica si es necesario.
6. Después de seleccionar el o los proyectos y la versión, haga clic en el botón "Instalar" para iniciar el proceso de instalación.

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

NLog ahora está instalado correctamente en su proyecto, y puede comenzar a usarlo para el registro dentro de su código C#.

Crear archivo de configuración NLog

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

En su proyecto, haga clic derecho en el proyecto o la carpeta deseada donde desea crear el archivo de configuración.

1. Elija "Agregar" > "Nuevo elemento..."
2. En el cuadro de diálogo "Agregar nuevo elemento," busque "Archivo XML" o "XML" y selecciónelo.
3. Nombre el archivo nlog.config y haga clic en el botón "Agregar."

4. Abra el archivo nlog.config recién creado en un editor de texto o editor 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 de NLog que registra mensajes a un objetivo de consola. Personalice este archivo de configuración según 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 console -->
    <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 console -->
    <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 tu código C#, asegúrate de cargar la configuración de NLog desde el archivo nlog.config. Normalmente, haces esto en el código de inicio de la aplicación, como en un archivo Startup.cs de ASP.NET Core (para Versión .NET igual o anterior a .NET 5), en el archivo program.cs (for .NET 6 o una versión posterior), o en el método Main de una aplicación de consola:

using NLog;

internal class Program
{
    // Create an instance of the Logger
    private static Logger logger = LogManager.GetCurrentClassLogger();

    static void Main(string[] args)
    {
        // Log a debug message
        logger.Debug("This is a Debug Message");
        
        // Pause the console for viewing output
        Console.Read();
    }
}

using NLog;

internal class Program
{
    // Create an instance of the Logger
    private static Logger logger = LogManager.GetCurrentClassLogger();

    static void Main(string[] args)
    {
        // Log a debug message
        logger.Debug("This is a Debug Message");
        
        // Pause the console for viewing output
        Console.Read();
    }
}

Imports NLog

Friend Class Program
    ' Create an instance of the Logger
    Private Shared logger As Logger = LogManager.GetCurrentClassLogger()

    Shared Sub Main(args As String())
        ' Log a debug message
        logger.Debug("This is a Debug Message")

        ' Pause the console for viewing output
        Console.Read()
    End Sub
End Class

Imports NLog

Friend Class Program
    ' Create an instance of the Logger
    Private Shared logger As Logger = LogManager.GetCurrentClassLogger()

    Shared Sub Main(args As String())
        ' Log a debug message
        logger.Debug("This is a Debug Message")

        ' Pause the console for viewing output
        Console.Read()
    End Sub
End Class

La salida del programa anterior es como se muestra:

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

Niveles de registro

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

1. Trace: El nivel más detallado, típicamente usado para fines de diagnóstico.
2. Debug: Usado para información de depuración que puede ser útil durante el desarrollo.
3. Info: Información general sobre la operación de la aplicación.
4. Warn: Indica un problema potencial que no interrumpe la aplicación.
5. Error: Indica un fallo que debe investigarse pero que no necesariamente hace que la aplicación se cierre.
6. Fatal: Indica un fallo crítico que debe ser abordado de inmediato.

Al categorizar los mensajes de registro en estos niveles, puede filtrarlos y priorizarlos fácilmente según su gravedad.

Establece minlevel="Trace" en la etiqueta de reglas en tu 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 código para registrar mensajes de todos los niveles de rastreo.

using NLog;

internal class Program
{
    // Create an instance of the Logger
    private static Logger logger = LogManager.GetCurrentClassLogger();

    static void Main(string[] args)
    {
        // Log messages of different tracking levels
        logger.Trace("This is a Trace Message");
        logger.Debug("This is a Debug Message");
        logger.Info("This is an Info Message");
        logger.Warn("This is a Warning Message");
        logger.Error("This is an Error Message");
        logger.Fatal("This is a Fatal Message");

        // Pause the console for viewing output
        Console.Read();
    }
}

using NLog;

internal class Program
{
    // Create an instance of the Logger
    private static Logger logger = LogManager.GetCurrentClassLogger();

    static void Main(string[] args)
    {
        // Log messages of different tracking levels
        logger.Trace("This is a Trace Message");
        logger.Debug("This is a Debug Message");
        logger.Info("This is an Info Message");
        logger.Warn("This is a Warning Message");
        logger.Error("This is an Error Message");
        logger.Fatal("This is a Fatal Message");

        // Pause the console for viewing output
        Console.Read();
    }
}

Imports NLog

Friend Class Program
	' Create an instance of the Logger
	Private Shared logger As Logger = LogManager.GetCurrentClassLogger()

	Shared Sub Main(ByVal args() As String)
		' Log messages of different tracking levels
		logger.Trace("This is a Trace Message")
		logger.Debug("This is a Debug Message")
		logger.Info("This is an Info Message")
		logger.Warn("This is a Warning Message")
		logger.Error("This is an Error Message")
		logger.Fatal("This is a Fatal Message")

		' Pause the console for viewing output
		Console.Read()
	End Sub
End Class

Imports NLog

Friend Class Program
	' Create an instance of the Logger
	Private Shared logger As Logger = LogManager.GetCurrentClassLogger()

	Shared Sub Main(ByVal args() As String)
		' Log messages of different tracking levels
		logger.Trace("This is a Trace Message")
		logger.Debug("This is a Debug Message")
		logger.Info("This is an Info Message")
		logger.Warn("This is a Warning Message")
		logger.Error("This is an Error Message")
		logger.Fatal("This is a Fatal Message")

		' Pause the console for viewing output
		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 configuraremos un objetivo de NLog para registrar mensajes en el archivo.

Mensaje de registro en archivo

Debemos establecer un objetivo de archivo en lugar de uno de consola en nuestro archivo de configuración para el registro.

<targets>
  <!-- Log to a file at specified location -->
  <target xsi:type="File" name="fileTarget" fileName="D:\Logs\mylog.txt" layout="${longdate} ${level:uppercase=true} ${message}" />
</targets>

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

<targets>
  <!-- Log to a file at specified location -->
  <target xsi:type="File" name="fileTarget" fileName="D:\Logs\mylog.txt" layout="${longdate} ${level:uppercase=true} ${message}" />
</targets>

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

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

Objetivos de registro

NLog admite varios objetivos de salida de registro, lo que le permite elegir dónde deben almacenarse sus mensajes de registro. Algunos objetivos comunes incluyen:

1. Archivo: Registra mensajes en uno o más archivos.
2. Consola: Registra mensajes en la consola.
3. Base de datos: Registra mensajes en una tabla de base de datos (SQL Server, MySQL, Oracle, PostgreSQL, etc.).
4. Correo electrónico: Envía mensajes de registro por correo.
5. Registro de eventos: Registra mensajes en el registro de eventos de Windows.
6. Objetivos personalizados: Crea objetivos de registro adaptados a tus necesidades.

Puede configurar NLog para usar uno o varios objetivos simultáneamente.

Presentando IronPDF

Explore más sobre IronPDF es una poderosa biblioteca .NET que simplifica la manipulación de PDF en aplicaciones C# y VB.NET. Proporciona capacidades robustas para crear, editar y manipular documentos PDF, así como para convertir contenido HTML al formato PDF, lo que lo convierte en una herramienta esencial para desarrolladores en una amplia gama de industrias, incluidas el desarrollo web, informes y gestión de documentos.

La característica destacada de IronPDF es su función de Conversión de HTML a PDF, que mantiene sus diseños y estilos preservados. Genera PDFs a partir de contenido web, lo que lo hace ideal para informes, facturas y documentación. Los archivos HTML, URLs y cadenas HTML pueden ser fácilmente convertidos a PDFs.

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

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

Generemos un PDF con registro.

Generación de PDF con registro

El primer paso es instalar la biblioteca IronPDF en nuestro proyecto. Podemos hacerlo usando el administrador de paquetes NuGet en Visual Studio o mediante la línea de comandos de NuGet. Abra su proyecto y escriba el siguiente comando en la consola del administrador de paquetes.

Install-Package IronPdf

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

Escriba el siguiente código para generar un archivo PDF desde HTML con registro.

using NLog;
using IronPdf;

internal class Program
{
    // Create an instance of the Logger
    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");
    }
}

using NLog;
using IronPdf;

internal class Program
{
    // Create an instance of the Logger
    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");
    }
}

Imports NLog
Imports IronPdf

Friend Class Program
	' Create an instance of the Logger
	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
End Class

Imports NLog
Imports IronPdf

Friend Class Program
	' Create an instance of the Logger
	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
End Class

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

Log y archivo PDF

Conclusión

En conclusión, NLog ha emergido como una herramienta esencial para el registro efectivo en aplicaciones C#, ofreciendo a los desarrolladores un marco robusto para capturar, categorizar y gestionar datos de registro. Su flexibilidad y facilidad de uso lo convierten en una elección predilecta para las necesidades de registro en varios dominios. 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 extender sus capacidades de gestión para abarcar la creación de registros y reportes basados en PDF. Vale la pena mencionar que IronPDF ofrece una prueba gratuita de IronPDF para probar sus características. Si cumple con sus requisitos, puede optar por una licencia comercial para IronPDF, que proporciona acceso continuo a las capacidades de IronPDF con beneficios adicionales y soporte para una integración sin problemas en sus proyectos, especialmente para funcionalidades relacionadas con PDF.

Al emplear el poder de NLog e IronPDF juntos, los desarrolladores pueden no solo obtener información sobre el comportamiento de su aplicación, sino también mejorar sus procesos de informe y gestión de documentos, asegurando que su software siga siendo eficiente, mantenible y bien documentado con un registro estructurado.