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

Registro es una parte crucial del desarrollo de software, sobre todo en lenguajes como C#. Ayuda a los desarrolladores a realizar un seguimiento de los eventos que se producen durante la ejecución de un programa, lo que facilita la comprensión de su comportamiento y el diagnóstico de problemas. Esta guía cubre todos los aspectos del registro en C#.Características de IronPDF para la manipulación avanzada de PDFdesde conceptos básicos hasta configuraciones y herramientas de registro avanzadas. Proporciona una comprensión y un control exhaustivos de la configuración de los registros en sus aplicaciones.

Entender el registro en C#;

En esencia, el registro en C# consiste en registrar información sobre el software a medida que se ejecuta. Estos registros, o mensajes de registro, se almacenan en archivos de registro u otros soportes y pueden incluir datos como mensajes de error, información sobre el estado del software o mensajes de depuración. El propósito del registro es proporcionar una forma de capturar información sobre el funcionamiento de la aplicación en un formato persistente. Esta información es muy valiosa para depurar problemas, supervisar el rendimiento del software y garantizar que la aplicación se comporta como se espera. Esto incluye el archivo de configuración, la API de registro, la configuración de registro, los registros estructurados y las excepciones de registro.

Escribir mensajes de registro

Para iniciar el registro en C#, los desarrolladores necesitan escribir mensajes de registro dentro de su aplicación. Para ello se utiliza un marco o API de registro. En C#, una opción popular es la interfaz ILogger de Microsoft disponible en el espacio de nombres Microsoft.Extensions.Logging. Esta interfaz proporciona una forma sencilla de registrar datos en varios niveles de importancia, que se conocen como niveles de registro. Estos niveles, que incluyen Información, Depuración y Error, ayudan a categorizar y filtrar la salida de registro en función de la gravedad de los mensajes que se registran.

using Microsoft.Extensions.Logging;
public class Program
{
    static void Main(string [] args)
    {
        ILogger logger = LoggerFactory.Create(builder => 
        {
            builder.AddConsole();
        }).CreateLogger<Program>();
        logger.LogInformation("This is an information log message");
        logger.LogError("This is an error log message");
    }
}

using Microsoft.Extensions.Logging;
public class Program
{
    static void Main(string [] args)
    {
        ILogger logger = LoggerFactory.Create(builder => 
        {
            builder.AddConsole();
        }).CreateLogger<Program>();
        logger.LogInformation("This is an information log message");
        logger.LogError("This is an error log message");
    }
}

Imports Microsoft.Extensions.Logging
Public Class Program
	Shared Sub Main(ByVal args() As String)
		Dim logger As ILogger = LoggerFactory.Create(Sub(builder)
			builder.AddConsole()
		End Sub).CreateLogger<Program>()
		logger.LogInformation("This is an information log message")
		logger.LogError("This is an error log message")
	End Sub
End Class

En el ejemplo anterior, el objeto ILogger llamado logger está configurado para enviar mensajes de registro a la consola. Esta configuración es sencilla pero fundamental para ayudarle a entender cómo se generan y muestran los mensajes de registro.

Archivos de registro y proveedores

En una aplicación del mundo real, a menudo es necesario almacenar los mensajes de registro en un archivo o en otro sistema de almacenamiento para su posterior revisión. Aquí es donde entran en juego los proveedores de registro. Los proveedores son componentes de la estructura de registro que gestionan la salida de datos de registro a varios destinos, como archivos, bases de datos o servicios externos.

Por ejemplo, para configurar un registrador para que escriba mensajes en un archivo, puede utilizar un proveedor basado en archivos como FileLoggerProvider. Para ello es necesario modificar el archivo de configuración de la aplicación(a menudo appsettings.json en aplicaciones .NET) para especificar detalles como la ruta del archivo de registro y el nivel mínimo de registro.

{
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft": "Warning"
    },
    "File": {
      "Path": "logs/myapp.log"
    }
  }
}

{
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft": "Warning"
    },
    "File": {
      "Path": "logs/myapp.log"
    }
  }
}

"Logging":
  If True Then
	"LogLevel":
	If True Then
	  "Default": "Information", "Microsoft": "Warning"
	End If
'INSTANT VB TODO TASK: Local functions are not converted by Instant VB:
'   , "File":
'	{
'	  "Path": "logs/myapp.log"
'	}
  End If

La configuración especifica que todos los registros por defecto deben estar en el nivel 'Información', pero las bibliotecas de Microsoft sólo deben registrar advertencias y superiores. También dirige la salida de registro a un archivo de registro llamado myapp.log en un directorio logs.

Técnicas avanzadas de registro

Además de los mensajes de registro básicos, C# admite el registro estructurado, que permite incluir datos estructurados en los registros en lugar de texto sin formato. El registro estructurado facilita la búsqueda y el análisis de los datos de registro, ya que cada elemento de información contextual se almacena como un campo independiente.

logger.LogDebug("Processing order {OrderId} at {Timestamp}", orderId, DateTime.UtcNow);

logger.LogDebug("Processing order {OrderId} at {Timestamp}", orderId, DateTime.UtcNow);

logger.LogDebug("Processing order {OrderId} at {Timestamp}", orderId, DateTime.UtcNow)

En este ejemplo de registro estructurado, OrderId y Timestamp son marcadores de posición dentro de la plantilla de mensaje que se rellenarán con los valores de orderId y DateTime.UtcNow respectivamente. Esto es más potente que el registro tradicional, ya que permite consultar y manipular más fácilmente los datos de registro basándose en campos específicos de cada entrada de registro.

Integración con sistemas externos

El registro en C# puede ampliarse para integrarse con sistemas externos como SQL Server o el registro de sucesos de Windows, lo que mejora la gestión y el análisis de los datos de registro. Mediante el uso de proveedores de registro especializados, los mensajes de registro pueden dirigirse a estos sistemas, proporcionando capacidades más sólidas para la supervisión y respuesta ante errores.

builder.AddEventLog(new EventLogSettings
{
    SourceName = "MyApplication"
});

builder.AddEventLog(new EventLogSettings
{
    SourceName = "MyApplication"
});

builder.AddEventLog(New EventLogSettings With {.SourceName = "MyApplication"})

Este fragmento de configuración dirige la salida del registro al Registro de sucesos de Windows con el nombre de origen "MiAplicación". Esto es especialmente útil para las aplicaciones que se ejecutan en servidores Windows, donde el Registro de sucesos es una herramienta centralizada para supervisar los mensajes de software y del sistema.

Integración de IronPDF con C#;

Registro

Más información sobre IronPDF para la conversión de HTML a PDF es una biblioteca PDF .NET que permite a los desarrolladores crear, manipular y representar archivos PDF. Convierte HTML a PDF, un requisito habitual para generar informes, facturas y otros tipos de documentos a partir de contenido web. IronPDF ofrece un amplio conjunto de funciones que permiten realizar diversas tareas relacionadas con PDF, como editar texto e imágenes, proteger documentos e incluso extraer contenido.

La combinación de IronPDF con el registro de C# puede mejorar la gestión de errores y la depuración cuando se trabaja con archivos PDF. Al integrar el registro, puede realizar un seguimiento del proceso de generación de PDF y capturar cualquier problema o excepción que surja. Esta integración es especialmente útil en situaciones en las que la generación de PDF es una parte fundamental de la funcionalidad de la aplicación, como la generación de informes dinámicos basados en datos de usuario.

Ejemplo de código

Para utilizar IronPDF junto con el registro de C#, tendrá que incorporar llamadas de registro en sus operaciones PDF. He aquí un ejemplo de cómo integrar estas dos tecnologías en una aplicación .NET. Este ejemplo asume que estás usando la interfaz ILogger de Microsoft.Extensions.Logging.

using IronPdf;
using Microsoft.Extensions.Logging;
using System;
public class PdfGenerator
{
    private readonly ILogger _logger;
    public PdfGenerator(ILogger<PdfGenerator> logger)
    {
        _logger = logger;
    }
    public void CreatePdfFromHtml(string htmlContent, string outputPath)
    {
        try
        {
            var renderer = new ChromePdfRenderer();
            var pdf = renderer.RenderHtmlAsPdf(htmlContent);
            pdf.SaveAs(outputPath);
            _logger.LogInformation("PDF created successfully at {OutputPath}", outputPath);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Error creating PDF from HTML");
        }
    }
}
// Usage
public class Program
{
    static void Main(string [] args)
    {
        License.LicenseKey = "License-Key";
        ILoggerFactory loggerFactory = LoggerFactory.Create(builder =>
        {
            builder.AddConsole(); // Works after adding the right package and using directive
        });
        ILogger<PdfGenerator> logger = loggerFactory.CreateLogger<PdfGenerator>(); // Correct type parameter
        PdfGenerator pdfGenerator = new PdfGenerator(logger);
        string htmlContent = "<h1>Hello, PDF!</h1><p>This is a simple PDF generated from HTML.</p>";
        string outputPath = "output.pdf";
        pdfGenerator.CreatePdfFromHtml(htmlContent, outputPath);
    }
}

using IronPdf;
using Microsoft.Extensions.Logging;
using System;
public class PdfGenerator
{
    private readonly ILogger _logger;
    public PdfGenerator(ILogger<PdfGenerator> logger)
    {
        _logger = logger;
    }
    public void CreatePdfFromHtml(string htmlContent, string outputPath)
    {
        try
        {
            var renderer = new ChromePdfRenderer();
            var pdf = renderer.RenderHtmlAsPdf(htmlContent);
            pdf.SaveAs(outputPath);
            _logger.LogInformation("PDF created successfully at {OutputPath}", outputPath);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Error creating PDF from HTML");
        }
    }
}
// Usage
public class Program
{
    static void Main(string [] args)
    {
        License.LicenseKey = "License-Key";
        ILoggerFactory loggerFactory = LoggerFactory.Create(builder =>
        {
            builder.AddConsole(); // Works after adding the right package and using directive
        });
        ILogger<PdfGenerator> logger = loggerFactory.CreateLogger<PdfGenerator>(); // Correct type parameter
        PdfGenerator pdfGenerator = new PdfGenerator(logger);
        string htmlContent = "<h1>Hello, PDF!</h1><p>This is a simple PDF generated from HTML.</p>";
        string outputPath = "output.pdf";
        pdfGenerator.CreatePdfFromHtml(htmlContent, outputPath);
    }
}

Imports IronPdf
Imports Microsoft.Extensions.Logging
Imports System
Public Class PdfGenerator
	Private ReadOnly _logger As ILogger
	Public Sub New(ByVal logger As ILogger(Of PdfGenerator))
		_logger = logger
	End Sub
	Public Sub CreatePdfFromHtml(ByVal htmlContent As String, ByVal outputPath As String)
		Try
			Dim renderer = New ChromePdfRenderer()
			Dim pdf = renderer.RenderHtmlAsPdf(htmlContent)
			pdf.SaveAs(outputPath)
			_logger.LogInformation("PDF created successfully at {OutputPath}", outputPath)
		Catch ex As Exception
			_logger.LogError(ex, "Error creating PDF from HTML")
		End Try
	End Sub
End Class
' Usage
Public Class Program
	Shared Sub Main(ByVal args() As String)
		License.LicenseKey = "License-Key"
		Dim loggerFactory As ILoggerFactory = LoggerFactory.Create(Sub(builder)
			builder.AddConsole() ' Works after adding the right package and using directive
		End Sub)
		Dim logger As ILogger(Of PdfGenerator) = loggerFactory.CreateLogger(Of PdfGenerator)() ' Correct type parameter
		Dim pdfGenerator As New PdfGenerator(logger)
		Dim htmlContent As String = "<h1>Hello, PDF!</h1><p>This is a simple PDF generated from HTML.</p>"
		Dim outputPath As String = "output.pdf"
		pdfGenerator.CreatePdfFromHtml(htmlContent, outputPath)
	End Sub
End Class

Esta configuración no sólo facilita la generación de PDF a partir de HTML, sino que también garantiza que la operación esté bien documentada mediante registros, lo que ayuda en el mantenimiento y la resolución de problemas. La integración del registro con IronPDF puede mejorar significativamente la fiabilidad y la trazabilidad de las capacidades de gestión de PDF de su aplicación.

Conclusión

El registro en C# es una forma flexible y potente de capturar información detallada sobre el funcionamiento de su aplicación. Mediante el uso de diferentes niveles de registro, la configuración de varios proveedores y la implementación de un registro estructurado, los desarrolladores pueden crear un sistema de registro completo que mejore la capacidad de mantenimiento y depuración de sus aplicaciones.

Pruebe IronPDF de forma gratuita a partir de 749 dólares.