Icône de message
Passer au contenu du pied de page
  1. IronPDF
  2. Blog IronPDF
  3. .NET Aide
  4. Topshelf C#
.NET AIDE

Topshelf C# (Comment ça fonctionne pour les développeurs)

Curtis Chau
Curtis Chau
Mis à jour:

Un package open-source très apprécié appelé Topshelf a été créé pour faciliter la création de services Windows en .NET. Le cadre qu'il offre simplifie et rend intelligible la création, le déploiement et l'administration des services Windows, libérant les développeurs pour se concentrer sur la logique métier plutôt que sur les complexités de la gestion du contrôle des services. Associé à IronPDF, une bibliothèque C# riche en fonctionnalités pour créer et modifier des fichiers PDF, les développeurs peuvent construire des services fiables et puissants capables de gérer des tâches d'élaboration de documents complexes.

Cette connexion offre une solution transparente pour les entreprises qui nécessitent des flux de travail documentaires efficaces et automatisés en automatisant la création, la révision et la distribution de PDF au sein d'un cadre complet de services Windows. Les développeurs peuvent obtenir un haut niveau de fonctionnalité et de maintenabilité dans leurs applications de service, garantissant à la fois robustesse et facilité d'utilisation, en utilisant Topshelf avec IronPDF for .NET en C#.

Qu'est-ce que Topshelf C# ?

Le projet open-source Topshelf .NET package facilite le développement, l'installation et la mise en œuvre de services Windows. En supprimant une grande partie de la complexité du processus de création des services Windows, les développeurs sont capables de se concentrer davantage sur les fonctionnalités essentielles de leurs applications plutôt que sur les subtilités de la gestion des services Windows.

Avec peu de modifications de code, Topshelf facilite la transformation des applications console en services pour les développeurs. Il offre également une API fluide pour établir les paramètres de service, y compris les dépendances, les options de récupération et les actions pour démarrer et arrêter les services. Pour les développeurs .NET cherchant à créer efficacement des services Windows stables et gérables, Topshelf est un choix populaire en raison de sa facilité d'utilisation et de son adaptabilité.

Topshelf C# (Comment ça marche pour les développeurs) : Figure 1

Un certain nombre de fonctionnalités offertes par Topshelf facilitent la conception et la maintenance des services Windows en .NET. Voici quelques-unes de ses caractéristiques saillantes :

Facilité d'utilisation

Topshelf fournit une API basique et fluide qui simplifie le processus de configuration et de gestion des services Windows en l'utilisant. Les développeurs peuvent facilement convertir des applications console en services avec peu ou pas de modifications de code.

Flexibilité de Configuration

Les actions de début, d'arrêt, de pause et de reprise font partie des options de configuration qu'il prend en charge. Les dépendances de service et les options de récupération pour les classements de services peuvent également être spécifiées par les développeurs.

Installation et Désinstallation

Le déploiement de services d'hébergement écrits à l'aide du .NET Framework est facilité par les fonctions intégrées de Topshelf pour l'installation et la désinstallation des services. Les services peuvent être installés soit par programme soit via la ligne de commande.

Journalisation

Topshelf facilite la capacité des développeurs à enregistrer efficacement les opérations de service et les pannes en s'intégrant aux frameworks de journaux bien connus tels que log4net, NLog et Serilog.

Contrôle de Service

Il est compatible avec tous les contrôles de service Windows courants, tels que pause, reprise, démarrage et arrêt. Les développeurs ont désormais un contrôle total sur tout le cycle de vie du service.

Gestion des Exceptions

La gestion robuste des exceptions est une caractéristique de Topshelf qui garantit que les services peuvent gérer les fautes avec élégance et rester stables.

Instances de Service Multiples

Elle offre de la flexibilité pour des architectures de service compliquées en permettant la création et la gestion de nombreuses instances de service au sein de la même application.

Options de Ligne de Commande Personnalisées

Les options de ligne de commande personnalisées permettent aux développeurs de personnaliser et de contrôler davantage le comportement de leurs services.

Conscience de l'Environnement

Que ce soit un serveur de production, un environnement de test ou un système de développement, Topshelf peut reconnaître et s'adapter à son environnement.

Support pour l'Injection de Dépendances

Topshelf facilite une meilleure architecture logicielle et rend la gestion des dépendances de service plus facile lorsqu'il est utilisé en conjonction avec des frameworks d'injection de dépendances.

Capacités Multiplateformes

Topshelf a été majoritairement créé pour Windows, mais il peut également exécuter des services sur Linux et macOS lorsqu'il utilise .NET Core, ce qui augmente sa compatibilité avec d'autres systèmes d'exploitation.

Créer et Configurer Topshelf C#

Utilisez Topshelf en C# pour créer et configurer un service Windows en suivant les étapes suivantes :

Créer un Nouveau Projet Visual Studio

Créer un projet console avec Visual Studio est facile. Pour démarrer une application Console dans l'environnement Visual Studio, suivez ces étapes simples :

Avant d'utiliser Visual Studio, assurez-vous de l'avoir installé sur votre ordinateur.

Démarrer un Nouveau Projet

Après avoir choisi Fichier, Projet, sélectionnez le menu Nouveau.

Topshelf C# (Comment ça marche pour les développeurs) : Figure 2

Sélectionnez soit "Application Console" ou "Application Console (.NET Core)" dans la liste des références de modèle de projet ci-dessous.

Pour donner un nom à votre projet, veuillez remplir le champ "Nom".

Topshelf C# (Comment ça marche pour les développeurs) : Figure 3

Sélectionnez l'emplacement de stockage du projet.

Le projet d'application console s'ouvrira lorsque vous cliquerez sur "Créer".

Topshelf C# (Comment ça marche pour les développeurs) : Figure 4

Installer Topshelf via NuGet

À l'aide du gestionnaire de packages NuGet, ajoutez Topshelf à votre projet dans un premier temps. Dans l'application de gestion de packages et de console, exécutez la commande suivante :

Install-Package Topshelf

Créer une Classe de Service

Décrivez la logique de service de la classe. Les actions de service telles que Démarrer et Arrêter, entre autres, doivent être implémentées dans cette classe.

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
$vbLabelText   $csharpLabel

Topshelf C# (Comment ça marche pour les développeurs) : Figure 5

Configurer le Service

Le mécanisme pour initier et finir le service est contenu dans la classe MyService. La définition du service et ses méthodes de cycle de vie (Démarrer et Arrêter) sont liées aux actions de service correspondantes dans la classe Programme, qui abrite la configuration de Topshelf. Les propriétés du service, telles que son nom, son nom d'affichage et sa description, sont définies à l'aide de la méthode run d'une classe de service unique. L'utilisation de Topshelf pour gérer et déployer les services Windows est simplifiée par cette configuration concise.

Construire et Installer le Service

Lors de la construction de votre projet, assurez-vous qu'il est exempt d'erreurs. Utilisez la commande install avec l'exécutable compilé pour lancer le service depuis la ligne de commande :

MyWindowsService.exe install
MyWindowsService.exe install
SHELL

Démarrer le Service

Utilisez la commande suivante pour lancer le service après l'avoir installé :

MyWindowsService.exe start
MyWindowsService.exe start
SHELL

Désinstaller le Service

Utilisez la commande suivante pour vous inviter à désinstaller le service si nécessaire :

MyWindowsService.exe uninstall
MyWindowsService.exe uninstall
SHELL

Cet exemple vous montre comment utiliser Topshelf en C# pour créer et configurer un service Windows. Topshelf rationalise la procédure, facilitant la définition, l'installation, la configuration et l'administration des services Windows avec peu de code.

Commencer

Pour commencer à créer un service Windows en C# à l'aide d'IronPDF et de Topshelf, effectuez les actions suivantes :

Qu'est-ce qu'IronPDF ?

IronPDF pour les bibliothèques .NET est une bibliothèque .NET riche en fonctionnalités que les programmes C# peuvent utiliser pour créer, lire et éditer des documents PDF. Avec ce programme, les développeurs peuvent facilement produire des PDF prêts à imprimer de haute qualité à partir de contenu HTML, CSS et JavaScript. La possibilité de diviser et fusionner des PDF, d'appliquer des filigranes aux documents, d'ajouter des en-têtes et pieds de page, et de convertir HTML en PDF sont quelques-unes des fonctions essentielles. IronPDF prend en charge à la fois le .NET Framework et .NET Core, ce qui le rend utile pour une large gamme d'applications.

Parce que les PDF sont simples à intégrer et disposent d'une riche documentation, les développeurs peuvent facilement les intégrer dans leurs programmes. IronPDF garantit que les PDF générés ressemblent étroitement au contenu HTML source en manipulant facilement les mises en page et les formats complexes.

Topshelf C# (Comment ça marche pour les développeurs) : Figure 6

Caractéristiques de IronPDF

Génération de PDF à partir de HTML

Convertissez JavaScript, HTML et CSS en PDF. Prend en charge les requêtes média et le design réactif, deux normes web contemporaines. Utile pour décorer dynamiquement des factures, des rapports et des documents PDF avec HTML et CSS.

Édition de PDF

Des PDF préexistants peuvent avoir du texte, des photos et d'autres contenus ajoutés à eux. Extraire du texte et des images des fichiers PDF. Combinez de nombreux PDF en un seul fichier. Divisez les fichiers PDF en plusieurs documents séparés. Ajoutez des filigranes, des annotations, des en-têtes et des pieds de page.

Conversion PDF

Convertir plusieurs formats de fichiers, y compris les fichiers Word, Excel et image, au format PDF. Conversion de PDF en image (PNG, JPEG, etc.).

Performance et Fiabilité

La haute performance et la fiabilité sont des qualités de conception souhaitées dans les environnements industriels. Gère aisément de grands ensembles de documents.

Installer IronPDF

Pour obtenir les outils dont vous avez besoin pour travailler avec des PDFs dans vos projets .NET, installez le package IronPDF.

Install-Package IronPdf

Créez votre Classe de Service avec IronPDF

Définissez la fonctionnalité d'IronPDF pour créer et modifier des fichiers PDF ainsi que la logique de service pour la 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
$vbLabelText   $csharpLabel

Les développeurs peuvent rapidement concevoir des services Windows robustes pour produire et manipuler des PDF en combinant Topshelf avec IronPDF en C#. Topshelf offre une API fluide et conviviale qui facilite la configuration et la gestion des services Windows.

Topshelf C# (Comment ça marche pour les développeurs) : Figure 7

Une classe MyPdfService, qui implémente des méthodes pour démarrer (Démarrer) et terminer (Arrêter) le service, encapsule la logique du service dans l'exemple donné. IronPDF est utilisé dans la méthode Démarrer pour créer un document PDF simple en utilisant HTML à partir d'un texte 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!

") into a PDF file ("GeneratedDocument.pdf").

Topshelf C# (Comment ça marche pour les développeurs) : Figure 8

Cette intégration démontre comment Topshelf gère le cycle de vie du service pour s'assurer qu'il fonctionne comme un service Windows complet, et comment IronPDF gère le processus complexe de création de PDF avec facilité. Avec les capacités combinées de Topshelf et d'IronPDF en C#, cette intégration est parfaite pour les applications nécessitant la création ou la modification automatique de documents. Elle fournit fiabilité et facilité de maintenance.

Conclusion

En conclusion, la création et l'administration des services Windows impliquant la création et la manipulation de PDFs est rendue possible par la combinaison de Topshelf et IronPDF en C#. En offrant une API conviviale pour la configuration et la gestion de services, Topshelf simplifie le déploiement des services Windows. En facilitant la génération sans faille de documents PDF à partir des informations HTML dans la logique de service, IronPDF améliore la fonctionnalité dans l'intervalle.

Cette intégration garantit une performance fiable et robuste dans les flux de travaux documentaires automatisés, tout en rationalisant le processus de développement. Topshelf avec IronPDF en C# se démarque comme une option flexible et efficace, permettant aux développeurs de créer facilement des solutions de traitement de documents complexes, que ce soit pour créer des rapports, des factures ou toute autre tâche basée sur des PDF.

IronPDF et Informations sur la licence Iron Software combinent les systèmes incroyablement flexibles et la suite d'Iron Software avec son support central pour offrir au développeur plus d'applications en ligne et de fonctionnalités ainsi qu'un développement plus efficace.

Si les options de licence sont claires et spécifiques au projet, les développeurs peuvent déterminer plus facilement quel modèle est optimal. Ces avantages permettent aux développeurs de résoudre une large gamme de problèmes de manière claire, efficace et intégrée de manière cohérente.

Questions Fréquemment Posées

Comment Topshelf simplifie-t-il la création de services Windows en .NET ?

Topshelf fournit une API simple qui permet aux développeurs de convertir des applications console en services Windows avec un minimum de modifications de code. Il se concentre sur la facilité d'utilisation, la flexibilité de configuration et la gestion robuste des exceptions, permettant aux développeurs de se concentrer sur la logique métier plutôt que sur les complexités de la gestion des services.

Topshelf peut-il être utilisé sur des plateformes autres que Windows ?

Oui, bien que Topshelf soit principalement conçu pour Windows, il peut également fonctionner sur Linux et macOS en utilisant .NET Core, ce qui améliore ses capacités multiplateformes.

Quels avantages l'intégration d'IronPDF avec Topshelf offre-t-elle ?

L'intégration d'IronPDF avec Topshelf permet aux développeurs d'automatiser les flux de travail de documents PDF dans les services Windows. Cette combinaison offre une solution robuste pour créer, modifier et distribuer des documents PDF, en exploitant la gestion des services de Topshelf et les fonctionnalités PDF d'IronPDF.

Comment puis-je convertir du contenu HTML en document PDF en C# ?

Vous pouvez utiliser IronPDF pour convertir du contenu HTML, CSS et JavaScript en documents PDF en utilisant ses méthodes conçues pour la conversion de HTML en PDF. IronPDF prend en charge les normes web modernes et le design réactif, garantissant une sortie PDF de haute qualité.

Quel est le processus pour créer un service Windows en utilisant Topshelf ?

Pour créer un service Windows avec Topshelf, créez un nouveau projet dans Visual Studio, installez Topshelf via NuGet, écrivez une classe de service avec les méthodes Start et Stop, configurez le service en utilisant l'API de Topshelf, puis construisez le projet. Enfin, installez et démarrez le service en utilisant des commandes en ligne de commande.

Quelles sont les principales caractéristiques de Topshelf pour la gestion des services ?

Topshelf offre des fonctionnalités telles que la facilité d'utilisation, la flexibilité de configuration, la journalisation, la gestion robuste des exceptions, le support de plusieurs instances de service et la compatibilité avec les contrôles de service Windows courants, en faisant un outil polyvalent pour les développeurs .NET.

Comment les flux de travail de documents automatisés peuvent-ils être mis en œuvre en utilisant des services Windows ?

Les flux de travail de documents automatisés peuvent être mis en œuvre en intégrant Topshelf avec IronPDF, en créant des services Windows qui gèrent des tâches comme la génération, la modification et la distribution de PDF, le tout dans un cadre de service.

Quelles sont les options de licence disponibles pour IronPDF ?

IronPDF offre des options de licence flexibles adaptées aux différents besoins de projet, permettant aux développeurs d'intégrer efficacement des fonctionnalités PDF dans leurs applications selon leurs besoins spécifiques.

Curtis Chau
Curtis Chau
  Discutez maintenant avec l'équipe d'ingénierie
Rédacteur technique

Curtis Chau détient un baccalauréat en informatique (Université de Carleton) et se spécialise dans le développement front-end avec expertise en Node.js, TypeScript, JavaScript et React. Passionné par la création d'interfaces utilisateur intuitives et esthétiquement plaisantes, Curtis aime travailler avec des frameworks modernes ...

Lire la suite

Articles connexes

Essai de 30 jours → Produit complet. Pas de limites. Pas de carte. Démarrer l'essai gratuit