Prism Logging (Cómo funciona para los desarrolladores)

Las aplicaciones de consola, a pesar de carecer de interfaz gráfica de usuario, suelen requerir sólidos mecanismos de registro para rastrear errores, supervisar el rendimiento de la aplicación y depurar problemas con eficacia. Prism.Plugin.Logging Prism Logging, una extensión del marco Prism Logging, ofrece una completa solución de registro para aplicaciones .NET, incluida la compatibilidad con varios proveedores de registro.

En este artículo, exploramos cómo integrar Prism Logging en aplicaciones de consola utilizando IronPDF una potente biblioteca .NET para trabajar con documentos PDF. Combinando estas herramientas, los desarrolladores pueden implementar funciones avanzadas de registro en sus aplicaciones de consola, mejorando las capacidades de mantenimiento y resolución de problemas.

Introducción a Prism Logging

Prism.Plugin.Logging amplía Prism, un popular marco de trabajo para la creación de aplicaciones XAML, proporcionando completas funciones de registro. Con soporte para múltiples proveedores de registro como NLog, Serilog, y Microsoft.Extensions.Logging, Prism.Plugin.Logging ofrece flexibilidad y opciones de personalización para adaptarse a diversos requisitos de aplicación.

Ventajas de utilizar Prism logging

Configuración flexible de registro: Prism.Plugin.Logging permite a los desarrolladores configurar varios proveedores de registro sin problemas, incluyendo opciones populares como NLog, Serilog y Microsoft.Extensions.Logging.

Soporte de registro estructurado: Los desarrolladores pueden registrar datos estructurados con sus mensajes utilizando Prism.Plugin.Logging. Esta función es especialmente útil en situaciones que implican aplicaciones de consola en las que deben registrarse y añadirse a los informes de registro producidos por IronPDF datos contextuales completos, como marcas de tiempo, códigos de error o actividades del usuario.

Cómo utilizar el registro Prism

1. Crear un nuevo proyecto C
2. Instale el paquete de registro Prism.
3. Crea un objeto para el SyslogLogger y pasa la configuración como parámetro.
4. Llame al método de registro cuando sea necesario y pase el mensaje de registro y el nivel de registro.
5. Elimina el objeto log al final.

Primeros pasos con Prism Logs

Configuración de Prism en C# Proyectos

Integrar Prism en un proyecto C# es fácil. Para añadir Prism es necesario utilizar NuGet, el gestor de paquetes .NET de Microsoft. Esta biblioteca proporciona las herramientas y bibliotecas necesarias para incorporar Prism Logs a sus proyectos.

Implementación de Prism en aplicaciones Dot .NET

Prism es compatible con varios tipos de aplicaciones Dot .NET, incluidas Windows Forms (WinForms) y la consola de Windows. Aunque cada framework se implementa de forma diferente, el concepto básico es siempre el mismo, ayudándonos a registrar los datos relacionados con su aplicación.

Creación de un nuevo proyecto en Visual Studio

Seleccione el menú Archivo de la aplicación Visual Studio. Haz clic en "Nuevo proyecto" y elige "Aplicación de consola".

Introduzca el nombre del proyecto en el área de texto designada tras seleccionar la ubicación del archivo. A continuación, como se muestra en el ejemplo siguiente, seleccione el .NET Framework necesario haciendo clic en el botón Crear.

La aplicación elegida determinará cómo se organiza el proyecto de Visual Studio. Basta con abrir el archivo program.cs para empezar a añadir código a la aplicación y construirla. Puede utilizar Windows, la consola o la aplicación web.

Después de esto, se puede añadir la biblioteca y probar el código.

Ejemplo básico de uso de registros con Prism.

En el siguiente ejemplo de código, lanzamos el objeto prism log y luego añadimos diferentes niveles de registro uno a uno en los registros de Prism y guardamos todos los registros y la criticidad en una lista.

using Prism.Logging.Syslog;
class Program
{
    public class Demo
    {
        public string name { get; set; }
        public int age { get; set; }
        static Options genOptions = new Options
        {
            HostNameOrIp = "127.0.0.1",
            Port = 514,
            AppNameOrTag = "LoggingDemo"
        };
        static SyslogLogger logger = new SyslogLogger(genOptions);
        static IList<LogData> Loglst = new List<LogData>();
        static async Task Main(string [] args)
        {
            MessageLog("Application started.", Prism.Logging.Syslog.Level.Information);
            PerformApplicationLogic();
            MessageLog("Application started.", Prism.Logging.Syslog.Level.Information);
        }
        static void PerformApplicationLogic()
        {
            //  Ejemplo de lógica de aplicación
            Console.WriteLine("Performing application logic...");
            //  Simular error
            try
            {
                throw new Exception();//  Esto lanzará una excepción
            }
            catch (Exception ex)
            {
                MessageLog($"Error occurred: {ex.Message}", Prism.Logging.Syslog.Level.Error);
            }
        }
        static void MessageLog(string Message, Prism.Logging.Syslog.Level _level)
        {
            Loglst.Add(new LogData { message = Message, Level = _level.ToString() });
            logger.Log(Message, _level);
        }
        public class LogData
        {
            public string message { get; set; }
            public string Level { get; set; }
        }
        public class Options : ISyslogOptions
        {
            public string HostNameOrIp { get; set; }
            public int? Port { get; set; }
            public string AppNameOrTag { get; set; }
        }
    }
}

using Prism.Logging.Syslog;
class Program
{
    public class Demo
    {
        public string name { get; set; }
        public int age { get; set; }
        static Options genOptions = new Options
        {
            HostNameOrIp = "127.0.0.1",
            Port = 514,
            AppNameOrTag = "LoggingDemo"
        };
        static SyslogLogger logger = new SyslogLogger(genOptions);
        static IList<LogData> Loglst = new List<LogData>();
        static async Task Main(string [] args)
        {
            MessageLog("Application started.", Prism.Logging.Syslog.Level.Information);
            PerformApplicationLogic();
            MessageLog("Application started.", Prism.Logging.Syslog.Level.Information);
        }
        static void PerformApplicationLogic()
        {
            //  Ejemplo de lógica de aplicación
            Console.WriteLine("Performing application logic...");
            //  Simular error
            try
            {
                throw new Exception();//  Esto lanzará una excepción
            }
            catch (Exception ex)
            {
                MessageLog($"Error occurred: {ex.Message}", Prism.Logging.Syslog.Level.Error);
            }
        }
        static void MessageLog(string Message, Prism.Logging.Syslog.Level _level)
        {
            Loglst.Add(new LogData { message = Message, Level = _level.ToString() });
            logger.Log(Message, _level);
        }
        public class LogData
        {
            public string message { get; set; }
            public string Level { get; set; }
        }
        public class Options : ISyslogOptions
        {
            public string HostNameOrIp { get; set; }
            public int? Port { get; set; }
            public string AppNameOrTag { get; set; }
        }
    }
}

Imports Prism.Logging.Syslog
Friend Class Program
	Public Class Demo
		Public Property name() As String
		Public Property age() As Integer
		Private Shared genOptions As New Options With {
			.HostNameOrIp = "127.0.0.1",
			.Port = 514,
			.AppNameOrTag = "LoggingDemo"
		}
		Private Shared logger As New SyslogLogger(genOptions)
		Private Shared Loglst As IList(Of LogData) = New List(Of LogData)()
		Shared Async Function Main(ByVal args() As String) As Task
			MessageLog("Application started.", Prism.Logging.Syslog.Level.Information)
			PerformApplicationLogic()
			MessageLog("Application started.", Prism.Logging.Syslog.Level.Information)
		End Function
		Private Shared Sub PerformApplicationLogic()
			'  Ejemplo de lógica de aplicación
			Console.WriteLine("Performing application logic...")
			'  Simular error
			Try
				Throw New Exception() '  Esto lanzará una excepción
			Catch ex As Exception
				MessageLog($"Error occurred: {ex.Message}", Prism.Logging.Syslog.Level.Error)
			End Try
		End Sub
		Private Shared Sub MessageLog(ByVal Message As String, ByVal _level As Prism.Logging.Syslog.Level)
			Loglst.Add(New LogData With {
				.message = Message,
				.Level = _level.ToString()
			})
			logger.Log(Message, _level)
		End Sub
		Public Class LogData
			Public Property message() As String
			Public Property Level() As String
		End Class
		Public Class Options
			Implements ISyslogOptions

			Public Property HostNameOrIp() As String
			Public Property Port() As Integer?
			Public Property AppNameOrTag() As String
		End Class
	End Class
End Class

Los informes de registro se generan desde Prism Logging. Estamos utilizando una herramienta llamada Kiwi Syslog service Manager para supervisar los registros de prisma.

Salida Prism Log file

Operaciones de Prism Logs

Registro extensible

Las capacidades de registro de Prism.Plugin.Prism se amplían mediante el registro, que proporciona más funcionalidad y flexibilidad. Ofrece una serie de opciones de configuración para ajustar los niveles de registro, los objetivos de registro y otras variables para satisfacer las necesidades de registro de su aplicación.

Múltiples objetivos de registro

Con Prism.Plugin.Logging puede dirigir los mensajes de registro a una variedad de ubicaciones, incluyendo la consola, archivos, bases de datos y otros servicios de registro. Gracias a esta flexibilidad, puede seleccionar los mejores objetivos de registro para los requisitos y el entorno de su aplicación.

Registradores personalizados

Con el plugin, puedes implementar la interfaz ILoggerFacade de Prism para construir loggers personalizados. Esto le permite construir capacidades de registro personalizadas basadas en las necesidades de su aplicación o interactuar con marcos de registro de terceros.

Crear registro con Prism Logs

Los registros de Prism pueden crearse fácilmente con unas pocas líneas de código. A continuación se muestra el ejemplo para crear un registro.

static Options genOptions = new Options
{
        HostNameOrIp = "127.0.0.1",
        Port = 514,
        AppNameOrTag = "LoggingDemo"
};
static SyslogLogger logger = new SyslogLogger(genOptions);
logger.Log(Message, _level);

static Options genOptions = new Options
{
        HostNameOrIp = "127.0.0.1",
        Port = 514,
        AppNameOrTag = "LoggingDemo"
};
static SyslogLogger logger = new SyslogLogger(genOptions);
logger.Log(Message, _level);

Private Shared genOptions As New Options With {
	.HostNameOrIp = "127.0.0.1",
	.Port = 514,
	.AppNameOrTag = "LoggingDemo"
}
Private Shared logger As New SyslogLogger(genOptions)
logger.Log(Message, _level)

Integración de Prism Logging y IronPDF

Uso conjunto de Prism e IronPDF

Combinación de *Prism** con IronPDF en un proyecto C# abre algunas posibilidades apasionantes. IronPDF es una herramienta fantástica para convertir este contenido en PDF, aunque Prism es una gran herramienta para trabajar con registros. Gracias a esta conectividad, los programadores pueden crear aplicaciones que registren el artículo en un documento PDF diseñado a medida.

Prism Logging con IronPDF

Al crear una aplicación de consola de Windows que utiliza Prism Logs, los usuarios pueden interactuar con los Logs dentro de su programa. Este mando debería caber en la consola con espacio de sobra para hacer troncos. Añade operaciones de registro del servidor y registros HTTP.

Instalar IronPDF

• Abra el Visual Studio proyecto.
• Seleccione "Herramientas" > "Gestor de paquetes NuGet" > "Consola del gestor de paquetes".
  • En la consola del gestor de paquetes, escriba el siguiente comando y pulse Intro:

Install-Package IronPdf

• Otra forma de instalar IronPDF es utilizando NuGet Package Manager for Solutions.

  • Busque el paquete IronPDF en los resultados de la búsqueda, selecciónelo y haga clic en el botón "Instalar". Visual Studio se encargará de la descarga y la instalación automáticamente.

  

• NuGet descargará e instalará el paquete IronPDF y cualquier dependencia necesaria para su proyecto.
• Una vez instalado IronPDF, puede utilizarlo para su proyecto.

Instalación a través del sitio web de NuGet

Visite la página de IronPDF en https://www.nuget.org/packages/IronPdf en el sitio web de NuGet para obtener más información sobre las características de IronPDF, su compatibilidad y otras opciones de descarga.

Utilizar DLL para instalar

Como alternativa, puede incorporar IronPDF directamente a su proyecto utilizando su archivo DLL. Para descargar el archivo ZIP que contiene la DLL, haga clic aquí enlace. Una vez descomprimida, incluye la DLL en tu proyecto.

Aplicación de la lógica

• Configurar el renderizador y el registrador: El software configura el renderizador IronPDF y el registrador Prism.
• Registro de Mensajes: Los mensajes con una categoría y prioridad designadas pueden registrarse utilizando el MessageLog() método. En este ejemplo, registramos los mensajes de inicio y parada de la aplicación, así como cualquier excepción que surja mientras se ejecuta la aplicación.
• Lógica de la aplicación: Una parte de la lógica de la aplicación se simula mediante la función PerformApplicationLogic() método. Para ilustrar el registro de errores, en este caso sólo produce un mensaje y lanza una excepción.

• Creación de un informe de registro en PDF: Tras la ejecución de la lógica de la aplicación, el software crea un documento HTML basado en los mensajes registrados. A continuación, utiliza RenderHtmlAsPdf de IronPDF() para transformar el documento HTML en un archivo de registro como informe PDF. A continuación, el archivo PDF se guarda en el disco.

  Ampliación del código previamente definido para integrar el código IronPDF:

using IronPdf;
static void GeneratePdfLogReport(ChromePdfRenderer Renderer)
{
    var Renderer = new ChromePdfRenderer(); //  Instancia del renderizador de Chrome
        //  Generar contenido HTML para un informe PDF
        string htmlContent = "<h1>Log Report</h1><ul>";
        foreach (var log in Loglst)
        {
             htmlContent += $"<li><strong>{log.message}:</strong> {log.Level}</li>";
        }
        htmlContent += "</ul>";
        //  Generar documento PDF
        var pdfDocument = Renderer.RenderHtmlAsPdf(htmlContent);
        //  Guardar archivo PDF
        string filePath = "log_report.pdf";
        pdfDocument.SaveAs(filePath);
        Console.WriteLine($"PDF log report generated: {filePath}");
}

using IronPdf;
static void GeneratePdfLogReport(ChromePdfRenderer Renderer)
{
    var Renderer = new ChromePdfRenderer(); //  Instancia del renderizador de Chrome
        //  Generar contenido HTML para un informe PDF
        string htmlContent = "<h1>Log Report</h1><ul>";
        foreach (var log in Loglst)
        {
             htmlContent += $"<li><strong>{log.message}:</strong> {log.Level}</li>";
        }
        htmlContent += "</ul>";
        //  Generar documento PDF
        var pdfDocument = Renderer.RenderHtmlAsPdf(htmlContent);
        //  Guardar archivo PDF
        string filePath = "log_report.pdf";
        pdfDocument.SaveAs(filePath);
        Console.WriteLine($"PDF log report generated: {filePath}");
}

Imports IronPdf
Shared Sub GeneratePdfLogReport(ByVal Renderer As ChromePdfRenderer)
	Dim Renderer = New ChromePdfRenderer() '  Instancia del renderizador de Chrome
		'  Generar contenido HTML para un informe PDF
		Dim htmlContent As String = "<h1>Log Report</h1><ul>"
		For Each log In Loglst
			 htmlContent &= $"<li><strong>{log.message}:</strong> {log.Level}</li>"
		Next log
		htmlContent &= "</ul>"
		'  Generar documento PDF
		Dim pdfDocument = Renderer.RenderHtmlAsPdf(htmlContent)
		'  Guardar archivo PDF
		Dim filePath As String = "log_report.pdf"
		pdfDocument.SaveAs(filePath)
		Console.WriteLine($"PDF log report generated: {filePath}")
End Sub

A continuación se muestra el informe de registro de imágenes generado desde IronPDF

Para saber más sobre las referencias del código IronPDF, consulte aquí.

Conclusión

Prism.Plugin.Logging integración con IronPDF permite a los desarrolladores incorporar fácilmente una amplia capacidad de registro en las aplicaciones de terminal. Los desarrolladores pueden mejorar el mantenimiento general de los programas, optimizar las capacidades de depuración y acelerar las operaciones de registro utilizando las funciones de ambas herramientas. Prism.Plugin.Logging permite que las aplicaciones de consola obtengan una cobertura de registro completa, garantizando sólidas capacidades de supervisión y solución de problemas, con la implementación y configuración correctas.

IronPDF ofrece una licencia perpetua de $ 749 Lite bundle que viene con una licencia permanente, un año de mantenimiento de software, y una actualización de la biblioteca. IronPDF ofrece licencias gratuitas para fines de desarrollo, sujetas a restricciones temporales y de redistribución. Para adquirir el prueba gratuita. Para obtener más información sobre los distintos productos de Iron Software, visite su sitio web sitio web enlace.