Pruebas en un entorno real
Pruebe en producción sin marcas de agua.
Funciona donde lo necesites.
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#.
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.
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.
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:
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#.
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.
Nombra el archivo nlog.config y haz clic en el botón "Añadir".
<?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.
NLog admite varios niveles de registro, cada uno con su propia importancia:
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>
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.
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>
Ahora, ejecute el programa para registrar los mensajes en un archivo.
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:
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.
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 su 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.
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.
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 ofrece una prueba gratuita para probar sus funciones. Si cumple sus requisitos, puede optar por un licencia comercial, 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.
9 productos API .NET para sus documentos de oficina