NLog C# (Cómo funciona para desarrolladores)
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 el paquete NLog Nuget
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:
- En el menú "Herramientas", seleccione "Administrador de paquetes NuGet," luego elija "Administrar paquetes NuGet para la solución."
- O, haga clic derecho en su proyecto en el Explorador de soluciones, seleccione "Administrar paquetes NuGet" y elija "Buscar."
- 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.
- 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.
- 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.
- 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.
- Elija "Agregar" > "Nuevo elemento..."
- En el cuadro de diálogo "Agregar nuevo elemento," busque "Archivo XML" o "XML" y selecciónelo.
Nombre el archivo nlog.config y haga clic en el botón "Agregar."

- Abra el archivo nlog.config recién creado en un editor de texto o editor XML.
- 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 su código C#, asegúrese de cargar la configuración de NLog desde el archivo nlog.config. Normalmente, hace esto en el código de inicio de la aplicación, como en un Startup.cs de ASP.NET Core (para la versión de .NET 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:
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(ByVal 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 ClassLa 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:
- Trace: El nivel más detallado, típicamente usado para fines de diagnóstico.
- Debug: Usado para información de depuración que puede ser útil durante el desarrollo.
- Info: Información general sobre la operación de la aplicación.
- Warn: Indica un problema potencial que no interrumpe la aplicación.
- Error: Indica un fallo que debe investigarse pero que no necesariamente hace que la aplicación se cierre.
- 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.
Establezca minlevel="Trace" en la etiqueta de reglas en 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 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 ClassNuestro 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:
- Archivo: Registra mensajes en uno o más archivos.
- Consola: Registra mensajes en la consola.
- Base de datos: Registra mensajes en una tabla de base de datos (SQL Server, MySQL, Oracle, PostgreSQL, etc.).
- Correo electrónico: Envía mensajes de registro por correo.
- Registro de eventos: Registra mensajes en el registro de eventos de Windows.
- 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 ClassGeneremos 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 ClassEl 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.
Preguntas Frecuentes
¿Cómo mejora NLog el registro en aplicaciones C#?
NLog proporciona un marco de registro robusto y flexible para aplicaciones C#. Permite a los desarrolladores implementar fácilmente el registro definiendo objetivos y reglas de registro en un archivo de configuración, admitiendo varios niveles de registro como Trace, Debug, Info, Warn, Error y Fatal.
¿Cuál es el proceso para configurar NLog en una aplicación .NET?
Para configurar NLog en una aplicación .NET, necesita instalar el paquete NuGet de NLog y configurar los objetivos y reglas de registro en el archivo nlog.config. Esta configuración le permite especificar dónde deben dirigirse los registros, como archivos, consolas, bases de datos o correos electrónicos.
¿Cómo puedo registrar mensajes en una base de datos usando NLog?
Para registrar mensajes en una base de datos usando NLog, necesita configurar un objetivo de base de datos en el archivo nlog.config. Deberá especificar la cadena de conexión y los detalles necesarios de la tabla o procedimiento almacenado para las entradas de registro.
¿Puede NLog enviar mensajes de registro por correo?
Sí, NLog envía mensajes de registro por correo configurando un objetivo en nlog.config. Necesita detalles del servidor SMTP y direcciones de destinatarios.
¿Cuáles son los beneficios de usar IronPDF para la generación de PDFs en .NET?
IronPDF es una potente biblioteca .NET que simplifica la generación, edición y conversión de PDFs. Admite la conversión de HTML a PDF, permitiendo a los desarrolladores generar PDFs a partir de cadenas HTML, archivos o URLs, mejorando los procesos de informes y manejo de documentos.
¿Cómo puedo integrar el registro con la generación de PDFs en una aplicación C#?
Puede integrar NLog con IronPDF en una aplicación C# usando NLog para registrar eventos de la aplicación e IronPDF para generar PDFs. Esta combinación le permite crear informes PDF detallados que incluyen información de registro.
¿Cuáles son algunos pasos comunes de solución de problemas para problemas de configuración de NLog?
Los pasos comunes de solución de problemas para problemas de configuración de NLog incluyen verificar el archivo nlog.config en busca de errores de sintaxis, asegurar las rutas de archivo correctas y los permisos para los objetivos de registro, y verificar excepciones en la aplicación que puedan afectar el registro.
¿Cómo puedo probar las capacidades de IronPDF antes de comprar?
IronPDF ofrece una prueba gratuita que permite a los desarrolladores probar sus funciones. Este período de prueba brinda la oportunidad de evaluar las capacidades de IronPDF para la generación, edición y conversión de PDF antes de optar por una licencia comercial.








