O desenvolvimento, a configuração e a implementação de serviços do Windows são facilitados com a ajuda do pacote Topshelf .NET, um projeto de código aberto. Ao simplificar bastante o processo de criação de serviços do Windows, os desenvolvedores podem se concentrar mais nas funcionalidades essenciais de seus aplicativos, em vez das nuances da administração de serviços do Windows.

Com poucas alterações no código, o Topshelf facilita para os desenvolvedores transformar aplicativos de console em serviços. Oferece também uma API flexível para definir as configurações do serviço, incluindo dependências, opções de recuperação e ações para iniciar e parar serviços. Para desenvolvedores .NET que desejam criar serviços Windows estáveis ​​e gerenciáveis ​​de forma eficaz, o Topshelf é uma opção bastante popular devido à sua facilidade de uso e adaptabilidade.

Diversas funcionalidades oferecidas pelo Topshelf facilitam o projeto e a manutenção de serviços do Windows em .NET. Aqui estão alguns de seus atributos mais importantes:

Facilidade de uso

O Topshelf oferece uma API básica e fluida que simplifica o processo de configuração e administração de serviços do Windows. Os desenvolvedores podem converter facilmente aplicativos de console em serviços com pouca ou nenhuma modificação de código.

Flexibilidade de configuração

As ações de iniciar, parar, pausar e continuar estão entre as opções de configuração suportadas. Os desenvolvedores também podem especificar as dependências de serviço e as opções de recuperação para classes de serviço.

Instalação e desinstalação

A implantação de serviços de hospedagem escritos usando o .NET Framework é facilitada pelas funções integradas do Topshelf para instalação e desinstalação de serviços. Os serviços podem ser instalados programaticamente ou através da linha de comando.

Registro

O Topshelf facilita aos desenvolvedores a capacidade de registrar com eficiência as operações e falhas dos serviços, integrando-se a frameworks de registro conhecidos como log4net, NLog e Serilog.

Controle de serviço

É compatível com todos os controles de serviço comuns do Windows, como pausar, continuar, iniciar e parar. Os desenvolvedores agora têm controle total sobre todo o ciclo de vida do serviço.

Tratamento de Exceções

O tratamento robusto de exceções é um recurso do Topshelf que garante que os serviços possam lidar com falhas de forma adequada e permanecer estáveis.

Instâncias de serviço múltiplas

Isso proporciona flexibilidade para arquiteturas de serviço complexas, permitindo a criação e o gerenciamento de várias instâncias de serviço dentro da mesma aplicação.

Opções de linha de comando personalizadas

As opções de linha de comando personalizadas permitem que os desenvolvedores personalizem e controlem ainda mais o comportamento de seus serviços.

Consciência do Ambiente

Seja um servidor de produção, um ambiente de teste ou um sistema de desenvolvimento, o Topshelf consegue reconhecer e se adaptar ao ambiente.

Suporte para Injeção de Dependência

O Topshelf facilita uma melhor arquitetura de software e simplifica o gerenciamento de dependências de serviços quando usado em conjunto com frameworks de injeção de dependência.

Capacidades multiplataforma

O Topshelf foi criado principalmente para Windows, mas também pode executar serviços em Linux e macOS ao utilizar o .NET Core, o que aumenta sua compatibilidade com outros sistemas operacionais.

Criar e Configurar o Topshelf C

Install-Package Topshelf

using System;
using Topshelf;

namespace MyWindowsService
{
    // Define a simple service class with Start and Stop methods
    public class MyService
    {
        public bool Start()
        {
            // Service start logic
            Console.WriteLine("Service Started.");
            return true;
        }

        public bool Stop()
        {
            // Service stop logic
            Console.WriteLine("Service Stopped.");
            return true;
        }
    }

    // Main program class to run the Topshelf service
    class Program
    {
        static void Main(string[] args)
        {
            HostFactory.Run(x =>
            {
                // Configure the service
                x.Service<MyService>(s =>
                {
                    s.ConstructUsing(name => new MyService());
                    s.WhenStarted(tc => tc.Start());
                    s.WhenStopped(tc => tc.Stop());
                });

                // Run the service as a local system
                x.RunAsLocalSystem();

                // Set service details
                x.SetServiceName("MyService");
                x.SetDisplayName("My Service");
                x.SetDescription("This is a sample service created using Topshelf.");
            });
        }
    }
}

using System;
using Topshelf;

namespace MyWindowsService
{
    // Define a simple service class with Start and Stop methods
    public class MyService
    {
        public bool Start()
        {
            // Service start logic
            Console.WriteLine("Service Started.");
            return true;
        }

        public bool Stop()
        {
            // Service stop logic
            Console.WriteLine("Service Stopped.");
            return true;
        }
    }

    // Main program class to run the Topshelf service
    class Program
    {
        static void Main(string[] args)
        {
            HostFactory.Run(x =>
            {
                // Configure the service
                x.Service<MyService>(s =>
                {
                    s.ConstructUsing(name => new MyService());
                    s.WhenStarted(tc => tc.Start());
                    s.WhenStopped(tc => tc.Stop());
                });

                // Run the service as a local system
                x.RunAsLocalSystem();

                // Set service details
                x.SetServiceName("MyService");
                x.SetDisplayName("My Service");
                x.SetDescription("This is a sample service created using Topshelf.");
            });
        }
    }
}

Imports System
Imports Topshelf

Namespace MyWindowsService
	' Define a simple service class with Start and Stop methods
	Public Class MyService
		Public Function Start() As Boolean
			' Service start logic
			Console.WriteLine("Service Started.")
			Return True
		End Function

		Public Function [Stop]() As Boolean
			' Service stop logic
			Console.WriteLine("Service Stopped.")
			Return True
		End Function
	End Class

	' Main program class to run the Topshelf service
	Friend Class Program
		Shared Sub Main(ByVal args() As String)
			HostFactory.Run(Sub(x)
				' Configure the service
				x.Service(Of MyService)(Sub(s)
					s.ConstructUsing(Function(name) New MyService())
					s.WhenStarted(Function(tc) tc.Start())
					s.WhenStopped(Function(tc) tc.Stop())
				End Sub)

				' Run the service as a local system
				x.RunAsLocalSystem()

				' Set service details
				x.SetServiceName("MyService")
				x.SetDisplayName("My Service")
				x.SetDescription("This is a sample service created using Topshelf.")
			End Sub)
		End Sub
	End Class
End Namespace

MyWindowsService.exe install

MyWindowsService.exe install

MyWindowsService.exe start

MyWindowsService.exe start

MyWindowsService.exe uninstall

MyWindowsService.exe uninstall

O que é o IronPDF?

IronPDF for .NET Libraries é uma biblioteca .NET rica em recursos que programas em C# podem usar para criar, ler e editar documentos PDF. Com este programa, os desenvolvedores podem facilmente produzir PDFs de alta qualidade e prontos para impressão a partir de conteúdo HTML, CSS e JavaScript . A capacidade de dividir e mesclar PDFs, adicionar marcas d'água a documentos, incluir cabeçalhos e rodapés e converter HTML em PDF são algumas das funções essenciais. O IronPDF é compatível com o .NET Framework e o .NET Core, o que o torna útil para uma ampla gama de aplicações.

Como os PDFs são fáceis de integrar e possuem uma vasta documentação, os desenvolvedores podem incorporá-los facilmente em seus programas. O IronPDF garante que os PDFs gerados sejam muito semelhantes ao conteúdo HTML original, lidando com layouts e formatações complexas com facilidade.

Funcionalidades do IronPDF

Geração de PDF a partir de HTML

Converter JavaScript, HTML e CSS para PDF. Suporta consultas de mídia e design responsivo, dois padrões web contemporâneos. Útil para decorar dinamicamente faturas, relatórios e documentos em PDF com HTML e CSS.

Edição de PDF

É possível adicionar texto, fotos e outros conteúdos a arquivos PDF preexistentes. Extrair texto e imagens de arquivos PDF. Combine vários PDFs em um único arquivo. Divida arquivos PDF em vários documentos separados. Inclua marcas d'água, anotações, cabeçalhos e rodapés.

Conversão de PDF

Converta diversos formatos de arquivo, incluindo arquivos Word, Excel e imagens, para o formato PDF. Conversão de PDF para imagem (PNG, JPEG, etc.).

Desempenho e confiabilidade

Alto desempenho e confiabilidade são qualidades desejáveis ​​em projetos de ambientes industriais. Gerencia grandes conjuntos de documentos com facilidade.

Instale o IronPDF

Para obter as ferramentas necessárias para trabalhar com PDFs em projetos .NET , instale o pacote IronPDF .

Install-Package IronPdf

Crie sua classe de serviço com o IronPDF

Defina a funcionalidade do IronPDF para criar e modificar arquivos PDF, bem como a lógica de serviço para a classe.

using System;
using IronPdf;
using Topshelf;

namespace PdfService
{
    // Define a service class with PDF generation logic
    public class MyPdfService
    {
        public bool Start()
        {
            Console.WriteLine("Service Starting...");
            GeneratePdf();
            return true;
        }

        public bool Stop()
        {
            Console.WriteLine("Service Stopping...");
            return true;
        }

        // Method to generate a PDF using IronPDF
        private void GeneratePdf()
        {
            var renderer = new HtmlToPdf();
            var pdf = renderer.RenderHtmlAsPdf("<h1>Hello, PDF!</h1>");
            pdf.SaveAs("GeneratedDocument.pdf");
            Console.WriteLine("PDF Generated.");
        }
    }

    // Main program to configure and run the service using Topshelf
    class Program
    {
        static void Main(string[] args)
        {
            HostFactory.Run(x =>
            {
                x.Service<MyPdfService>(s =>
                {
                    s.ConstructUsing(name => new MyPdfService());
                    s.WhenStarted(tc => tc.Start());
                    s.WhenStopped(tc => tc.Stop());
                });

                x.RunAsLocalSystem();
                x.SetServiceName("MyPdfService");
                x.SetDisplayName("My PDF Service");
                x.SetDescription("A service that generates PDF files using IronPDF and Topshelf.");
            });
        }
    }
}

using System;
using IronPdf;
using Topshelf;

namespace PdfService
{
    // Define a service class with PDF generation logic
    public class MyPdfService
    {
        public bool Start()
        {
            Console.WriteLine("Service Starting...");
            GeneratePdf();
            return true;
        }

        public bool Stop()
        {
            Console.WriteLine("Service Stopping...");
            return true;
        }

        // Method to generate a PDF using IronPDF
        private void GeneratePdf()
        {
            var renderer = new HtmlToPdf();
            var pdf = renderer.RenderHtmlAsPdf("<h1>Hello, PDF!</h1>");
            pdf.SaveAs("GeneratedDocument.pdf");
            Console.WriteLine("PDF Generated.");
        }
    }

    // Main program to configure and run the service using Topshelf
    class Program
    {
        static void Main(string[] args)
        {
            HostFactory.Run(x =>
            {
                x.Service<MyPdfService>(s =>
                {
                    s.ConstructUsing(name => new MyPdfService());
                    s.WhenStarted(tc => tc.Start());
                    s.WhenStopped(tc => tc.Stop());
                });

                x.RunAsLocalSystem();
                x.SetServiceName("MyPdfService");
                x.SetDisplayName("My PDF Service");
                x.SetDescription("A service that generates PDF files using IronPDF and Topshelf.");
            });
        }
    }
}

Imports System
Imports IronPdf
Imports Topshelf

Namespace PdfService
	' Define a service class with PDF generation logic
	Public Class MyPdfService
		Public Function Start() As Boolean
			Console.WriteLine("Service Starting...")
			GeneratePdf()
			Return True
		End Function

		Public Function [Stop]() As Boolean
			Console.WriteLine("Service Stopping...")
			Return True
		End Function

		' Method to generate a PDF using IronPDF
		Private Sub GeneratePdf()
			Dim renderer = New HtmlToPdf()
			Dim pdf = renderer.RenderHtmlAsPdf("<h1>Hello, PDF!</h1>")
			pdf.SaveAs("GeneratedDocument.pdf")
			Console.WriteLine("PDF Generated.")
		End Sub
	End Class

	' Main program to configure and run the service using Topshelf
	Friend Class Program
		Shared Sub Main(ByVal args() As String)
			HostFactory.Run(Sub(x)
				x.Service(Of MyPdfService)(Sub(s)
					s.ConstructUsing(Function(name) New MyPdfService())
					s.WhenStarted(Function(tc) tc.Start())
					s.WhenStopped(Function(tc) tc.Stop())
				End Sub)

				x.RunAsLocalSystem()
				x.SetServiceName("MyPdfService")
				x.SetDisplayName("My PDF Service")
				x.SetDescription("A service that generates PDF files using IronPDF and Topshelf.")
			End Sub)
		End Sub
	End Class
End Namespace

Os desenvolvedores podem projetar rapidamente serviços robustos do Windows para produção e manipulação de PDFs combinando o Topshelf com o IronPDF em C#. O Topshelf oferece uma API fluida e fácil de usar que simplifica a configuração e o gerenciamento de serviços do Windows.

Uma classe MyPdfService, que implementa métodos para iniciar (Start) e encerrar (Stop) o serviço, encapsula a lógica do serviço no exemplo fornecido. O IronPDF é usado no método Start para criar um documento PDF simples usando HTML a partir de texto HTML. The ability to render HTML into a PDF format using IronPDF's HtmlToPdf class is demonstrated, showing how to turn basic HTML information (such as "

Hello, PDF!

Essa integração demonstra como o Topshelf gerencia o ciclo de vida do serviço para garantir que ele funcione como um serviço completo do Windows e como o IronPDF lida com facilidade com o complexo processo de criação de PDFs. Com as funcionalidades combinadas do Topshelf e do IronPDF em C#, essa integração é perfeita para aplicações que necessitam de criação ou modificação automatizada de documentos. Proporciona confiabilidade e facilidade de manutenção.