Pakiet Topshelf .NET to projekt open-source, który ułatwia tworzenie, konfigurowanie i wdrażanie usług Windows. Usuwając wiele elementów złożoności z procesu tworzenia usług Windows, pozwala programistom skupić się na kluczowych funkcjach aplikacji zamiast na niuansach administrowania usługami Windows.

Dzięki minimalnym zmianom w kodzie Topshelf umożliwia łatwe przekształcenie aplikacji konsolowych w usługi. Oferuje również płynne API do konfigurowania ustawień usługi, w tym zależności, opcji przywracania oraz akcji uruchamiania i zatrzymywania. Dla programistów .NET chcących efektywnie tworzyć stabilne i łatwe w zarządzaniu usługi Windows Topshelf jest popularnym wyborem ze względu na prostotę i elastyczność.

Topshelf oferuje szereg funkcji ułatwiających projektowanie i utrzymanie usług Windows w .NET. Oto kilka jego najważniejszych cech:

Łatwość użytkowania

Topshelf oferuje proste i płynne API upraszczające konfigurowanie i administrowanie usługami Windows. Programiści mogą łatwo przekształcić aplikacje konsolowe w usługi przy minimalnych zmianach w kodzie.

Elastyczność konfiguracji

Obsługuje akcje start, stop, wstrzymanie i wznowienie. Programiści mogą również definiować zależności usług oraz opcje przywracania dla klas usług.

Instalacja i deinstalacja

Wbudowane funkcje instalowania i deinstalowania usług ułatwiają wdrażanie usług tworzonych w .NET Framework. Usługi można instalować programowo lub z wiersza poleceń.

Rejestrowanie zdarzeń

Topshelf ułatwia rejestrowanie operacji i błędów usług dzięki integracji z popularnymi frameworkami rejestrowania, takimi jak log4net, NLog i Serilog.

Kontrola usługi

Jest kompatybilny ze wszystkimi standardowymi mechanizmami kontroli usług Windows: wstrzymaniem, wznowieniem, uruchomieniem i zatrzymaniem. Programiści mają pełną kontrolę nad całym cyklem życia usługi.

Obsługa wyjątków

Topshelf zapewnia solidną obsługę wyjątków, gwarantując, że usługi radzą sobie z błędami bez utraty stabilności.

Wiele instancji usługi

Umożliwia tworzenie wielu instancji usługi w ramach tej samej aplikacji, zapewniając elastyczność dla złożonych architektur.

Niestandardowe opcje wiersza poleceń

Niestandardowe opcje wiersza poleceń pozwalają programistom na dalsze dostosowywanie i kontrolowanie zachowania usług.

Świadomość środowiska

Topshelf potrafi rozpoznać i dostosować się do środowiska — niezależnie od tego, czy jest to serwer produkcyjny, środowisko testowe, czy system deweloperski.

Obsługa wstrzykiwania zależności

Topshelf ułatwia lepszą architekturę oprogramowania i zarządzanie zależnościami usług w połączeniu z frameworkami wstrzykiwania zależności.

Możliwości wieloplatformowe

Topshelf został stworzony głównie dla systemu Windows, ale może również uruchamiać usługi w systemach Linux i macOS przy użyciu .NET Core, co zwiększa jego kompatybilność z innymi systemami operacyjnymi.

Tworzenie i konfiguracja 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

Czym jest IronPDF?

IronPDF dla .NET to bogata w funkcje biblioteka .NET, którą aplikacje C# mogą wykorzystywać do tworzenia, odczytu i edycji dokumentów PDF. Dzięki niej programiści mogą łatwo generować wysokiej jakości pliki PDF gotowe do druku na podstawie treści HTML, CSS i JavaScript. Do kluczowych funkcji należą: dzielenie i łączenie plików PDF, dodawanie znaków wodnych i nagłówków oraz stopek, a także konwersja HTML do PDF. IronPDF obsługuje zarówno .NET Framework, jak i .NET Core, co czyni go przydatnym w szerokim zakresie zastosowań.

Dzięki prostej integracji i bogatej dokumentacji programiści mogą łatwo włączyć IronPDF do swoich aplikacji. IronPDF sprawnie obsługuje złożone układy i formatowanie, zapewniając, że generowane pliki PDF wiernie odzwierciedlają źródłową treść HTML.

Funkcje IronPDF

Generowanie plików PDF z HTML

Konwertuj JavaScript, HTML i CSS do formatu PDF. Obsługuje zapytania o media i responsywny projekt, dwa współczesne standardy internetowe. Przydatne do dynamicznego ozdabiania faktur, raportów i dokumentów PDF za pomocą HTML i CSS.

Edycja plików PDF

Do istniejących plików PDF można dodawać tekst, zdjęcia i inne treści. Możliwe jest wyodrębnianie tekstu i obrazów z plików PDF. Łączenie wielu plików PDF w jeden plik. Podział plików PDF na wiele oddzielnych dokumentów. Dodawanie znaków wodnych, adnotacji, nagłówków i stopek.

Konwersja plików PDF

Konwersja różnych formatów plików, w tym Word, Excel i plików graficznych, do formatu PDF. Konwersja PDF do obrazu (PNG, JPEG itd.).

Wydajność i niezawodność

Wysoka wydajność i niezawodność to cechy projektowe pożądane w środowiskach przemysłowych. Z łatwością zarządza dużymi zbiorami dokumentów.

Zainstaluj IronPDF

Aby uzyskać narzędzia potrzebne do pracy z plikami PDF w projektach .NET, należy zainstalować pakiet IronPDF.

Install-Package IronPdf

Tworzenie klasy usługi z IronPDF

Należy zdefiniować funkcjonalność IronPDF do tworzenia i modyfikowania plików PDF oraz logikę usługi dla klasy.

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

Łącząc Topshelf z IronPDF w C#, można szybko projektować wydajne usługi Windows do tworzenia i przetwarzania plików PDF. Topshelf oferuje płynne i przyjazne API ułatwiające konfigurowanie usług Windows i zarządzanie nimi.

Klasa MyPdfService, implementująca metody uruchamiania (Start) i zatrzymywania (Stop) usługi, hermetyzuje logikę usługi w przedstawionym przykładzie. W metodzie Start IronPDF jest używany do tworzenia prostego dokumentu PDF z HTML. Przykład demonstruje możliwość renderowania HTML do formatu PDF za pomocą klasy HtmlToPdf biblioteki IronPDF, pokazując, jak przekształcić podstawową treść HTML (np. „

Hello, PDF!

Ta integracja pokazuje, w jaki sposób Topshelf zarządza cyklem życia usługi, aby zapewnić jej działanie jako pełnoprawnej usługi systemu Windows, oraz w jaki sposób IronPDF z łatwością radzi sobie z trudnym procesem tworzenia plików PDF. Dzięki połączonym możliwościom Topshelf i IronPDF w języku C# ta integracja idealnie nadaje się do aplikacji wymagających automatycznego tworzenia lub modyfikacji dokumentów. Zapewnia niezawodność i łatwość konserwacji.