Registro de logs do Prism (Como funciona para desenvolvedores)

Introdução ao Prism Logging

O Prism.Plugin.Logging estende o Prism, um framework popular para a criação de aplicações XAML, fornecendo recursos abrangentes de registro de logs. Com suporte para múltiplos provedores de registro, como NLog, Serilog e Microsoft.Extensions.Logging, o Prism.Plugin.Logging oferece flexibilidade e opções de personalização para atender a diversos requisitos de aplicação.

Vantagens de usar o registro de dados Prism

Configuração flexível de registro de logs: o Prism.Plugin.Logging permite que os desenvolvedores configurem diversos provedores de registro de logs de forma integrada, incluindo opções populares como NLog, Serilog e Microsoft.Extensions.Logging.

Suporte a registro estruturado: os desenvolvedores podem registrar dados estruturados com suas mensagens usando o Prism.Plugin.Logging. Essa função é especialmente útil em cenários que envolvem aplicativos de console, onde dados contextuais abrangentes, incluindo registros de data e hora, códigos de erro ou atividades do usuário, devem ser registrados e adicionados aos relatórios de log produzidos pelo IronPDF.

Como usar o registro de dados do Prism

1. Crie um novo projeto C#
2. Instale o pacote de registro Prism.
3. Crie um objeto para o SyslogLogger e passe a configuração como parâmetro.
4. Chame o método de registro sempre que necessário e passe a mensagem de registro e o nível de registro.
5. Elimine o objeto de log ao final.

Primeiros passos com o Prism Logs

Criando um novo projeto no Visual Studio

Selecione o menu Arquivo no aplicativo Visual Studio. Clique em "Novo projeto" e, em seguida, escolha "Aplicativo de console".

Após selecionar o local do arquivo, insira o nome do projeto na área de texto designada. Em seguida, como mostrado no exemplo abaixo, selecione a .NET Framework necessária clicando no botão Criar.

O aplicativo escolhido determinará como o projeto do Visual Studio será organizado. Basta abrir o arquivo program.cs para começar a adicionar código ao aplicativo e compilá-lo. Você pode usar o Windows, o console ou o aplicativo da web.

Após isso, a biblioteca pode ser adicionada e o código testado.

using Prism.Logging.Syslog;
using System;
using System.Collections.Generic;
using System.Threading.Tasks;

class Program
{
    public class Demo
    {
        public string Name { get; set; }
        public int Age { get; set; }

        // Configure the logger options
        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 stopped.", Prism.Logging.Syslog.Level.Information);
        }

        static void PerformApplicationLogic()
        {
            // Example application logic
            Console.WriteLine("Performing application logic...");

            // Simulate error
            try
            {
                throw new Exception("Simulated Exception");
            }
            catch (Exception ex)
            {
                MessageLog($"Error occurred: {ex.Message}", Prism.Logging.Syslog.Level.Error);
            }
        }

        // Logs messages and their levels
        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;
using System;
using System.Collections.Generic;
using System.Threading.Tasks;

class Program
{
    public class Demo
    {
        public string Name { get; set; }
        public int Age { get; set; }

        // Configure the logger options
        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 stopped.", Prism.Logging.Syslog.Level.Information);
        }

        static void PerformApplicationLogic()
        {
            // Example application logic
            Console.WriteLine("Performing application logic...");

            // Simulate error
            try
            {
                throw new Exception("Simulated Exception");
            }
            catch (Exception ex)
            {
                MessageLog($"Error occurred: {ex.Message}", Prism.Logging.Syslog.Level.Error);
            }
        }

        // Logs messages and their levels
        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
Imports System
Imports System.Collections.Generic
Imports System.Threading.Tasks

Friend Class Program
	Public Class Demo
		Public Property Name() As String
		Public Property Age() As Integer

		' Configure the logger options
		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 stopped.", Prism.Logging.Syslog.Level.Information)
		End Function

		Private Shared Sub PerformApplicationLogic()
			' Example application logic
			Console.WriteLine("Performing application logic...")

			' Simulate error
			Try
				Throw New Exception("Simulated Exception")
			Catch ex As Exception
				MessageLog($"Error occurred: {ex.Message}", Prism.Logging.Syslog.Level.Error)
			End Try
		End Sub

		' Logs messages and their levels
		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

static Options genOptions = new Options
{
    HostNameOrIp = "127.0.0.1",
    Port = 514,
    AppNameOrTag = "LoggingDemo"
};
static SyslogLogger logger = new SyslogLogger(genOptions);
logger.Log("Sample message", Prism.Logging.Syslog.Level.Information);

static Options genOptions = new Options
{
    HostNameOrIp = "127.0.0.1",
    Port = 514,
    AppNameOrTag = "LoggingDemo"
};
static SyslogLogger logger = new SyslogLogger(genOptions);
logger.Log("Sample message", Prism.Logging.Syslog.Level.Information);

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("Sample message", Prism.Logging.Syslog.Level.Information)

Integrando o Prism Logging e o IronPDF

Instale o IronPDF

• Abra o projeto do Visual Studio .

• Selecione "Ferramentas" > "Gerenciador de Pacotes NuGet " > "Console do Gerenciador de Pacotes".

  • No console do Gerenciador de Pacotes, digite o seguinte comando e pressione Enter:

  Install-Package IronPdf

• Outra forma de instalar o IronPDF é usando o Gerenciador de Pacotes NuGet para Soluções.
  • Procure o pacote IronPDF nos resultados da pesquisa, selecione-o e clique no botão "Instalar". O Visual Studio cuidará do download e da instalação automaticamente.

• O NuGet fará o download e instalará o pacote IronPDF e quaisquer dependências necessárias para o seu projeto.
• Depois de instalar o IronPDF , você poderá usá-lo em seu projeto.

Implementando a lógica

• Configuração do Renderizador e do Registrador: O software configura o renderizador IronPDF e o registrador Prism.
• Registro de mensagens: Mensagens com uma categoria e prioridade designadas podem ser registradas usando o método MessageLog() . Neste exemplo, registramos as mensagens de inicialização e parada do aplicativo, bem como quaisquer exceções que ocorram durante a execução do aplicativo.
• Aplicação da lógica: Uma parte da lógica da aplicação é simulada pelo método PerformApplicationLogic() . Para ilustrar o registro de erros, ele simplesmente produz uma mensagem e, neste caso, gera uma exceção.
• Criação de um relatório de log em PDF: Após a execução da lógica do aplicativo, o software cria um documento HTML com base nas mensagens registradas. Em seguida, utiliza o recurso RenderHtmlAsPdf() do IronPDF para transformar o documento HTML em um arquivo de log no formato de relatório PDF. O arquivo PDF é então salvo no disco.

Estender o código previamente definido para integrar o código IronPDF :

using IronPdf;

static void GeneratePdfLogReport()
{
    var renderer = new ChromePdfRenderer(); // Instantiates Chrome Renderer

    // Generate HTML content for PDF report
    string htmlContent = "<h1>Log Report</h1><ul>";
    foreach (var log in Loglst)
    {
        htmlContent += $"<li><strong>Message: {log.Message}</strong> Level: {log.Level}</li>";
    }
    htmlContent += "</ul>";

    // Generate PDF document
    var pdfDocument = renderer.RenderHtmlAsPdf(htmlContent);

    // Save PDF file
    string filePath = "log_report.pdf";
    pdfDocument.SaveAs(filePath);
    Console.WriteLine($"PDF log report generated: {filePath}");
}

using IronPdf;

static void GeneratePdfLogReport()
{
    var renderer = new ChromePdfRenderer(); // Instantiates Chrome Renderer

    // Generate HTML content for PDF report
    string htmlContent = "<h1>Log Report</h1><ul>";
    foreach (var log in Loglst)
    {
        htmlContent += $"<li><strong>Message: {log.Message}</strong> Level: {log.Level}</li>";
    }
    htmlContent += "</ul>";

    // Generate PDF document
    var pdfDocument = renderer.RenderHtmlAsPdf(htmlContent);

    // Save PDF file
    string filePath = "log_report.pdf";
    pdfDocument.SaveAs(filePath);
    Console.WriteLine($"PDF log report generated: {filePath}");
}

Imports IronPdf

Shared Sub GeneratePdfLogReport()
	Dim renderer = New ChromePdfRenderer() ' Instantiates Chrome Renderer

	' Generate HTML content for PDF report
	Dim htmlContent As String = "<h1>Log Report</h1><ul>"
	For Each log In Loglst
		htmlContent &= $"<li><strong>Message: {log.Message}</strong> Level: {log.Level}</li>"
	Next log
	htmlContent &= "</ul>"

	' Generate PDF document
	Dim pdfDocument = renderer.RenderHtmlAsPdf(htmlContent)

	' Save PDF file
	Dim filePath As String = "log_report.pdf"
	pdfDocument.SaveAs(filePath)
	Console.WriteLine($"PDF log report generated: {filePath}")
End Sub

Abaixo está o relatório de registro de imagens gerado pelo IronPDF.

Para saber mais sobre as referências de código do IronPDF , consulte aqui .

Conclusão

A integração do Prism.Plugin.Logging com o IronPDF permite que os desenvolvedores incorporem facilmente recursos avançados de registro de logs em aplicativos de terminal. Os desenvolvedores podem aprimorar a manutenção geral do programa, otimizar os recursos de depuração e acelerar as operações de registro de logs utilizando os recursos de ambas as ferramentas. O Prism.Plugin.Logging permite que aplicativos de console obtenham cobertura completa de logs, garantindo recursos robustos de monitoramento e solução de problemas, com a implementação e configuração corretas.

IronPDF oferece uma licença perpétua de um Lite bundle que inclui uma licença permanente, um ano de manutenção de software e uma atualização da biblioteca. A IronPDF oferece licença gratuita para fins de desenvolvimento, sujeita a restrições de tempo e redistribuição. Para obter a avaliação gratuita . Para saber mais sobre os diversos produtos da Iron Software , visite o site deles através do link.