Comment écrire c# service que je peux aussi fonctionner comme un winforms programme?
J'ai un service windows écrit en C# qui agit comme un proxy pour un tas de périphériques réseau à l'arrière de la base de données. Pour les tests, et aussi d'ajouter une simulation de la couche de tester le dos fin, j'aimerais avoir une interface graphique pour l'opérateur de test pour pouvoir exécuter la simulation. Aussi pour un rayé version d'envoyer une démo. Le GUI et le service n'ont pas à s'exécuter en même temps. Quelle est la meilleure façon d'atteindre ce duel opération?
Edit:
Voici ma solution peignage des trucs de cette question , Suis-je l'Exécute en tant que Service et Installer un .NET service windows sans InstallUtil.exe à l'aide de cet excellent code par Marc Gravel
Il utilise la ligne suivante pour tester si pour exécuter l'interface graphique ou d'exécuter en tant que service.
if (arg_gui || Environment.UserInteractive || Debugger.IsAttached)
Voici le code.
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Windows.Forms;
using System.ComponentModel;
using System.ServiceProcess;
using System.Configuration.Install;
using System.Diagnostics;
namespace Form_Service
{
static class Program
{
///
///The main entry point for the application.
///
[STAThread]
static int Main(string[] args)
{
bool arg_install = false;
bool arg_uninstall = false;
bool arg_gui = false;
bool rethrow = false;
try
{
foreach (string arg in args)
{
switch (arg)
{
case "-i":
case "-install":
arg_install = true; break;
case "-u":
case "-uninstall":
arg_uninstall = true; break;
case "-g":
case "-gui":
arg_gui = true; break;
default:
Console.Error.WriteLine("Argument not expected: " + arg);
break;
}
}
if (arg_uninstall)
{
Install(true, args);
}
if (arg_install)
{
Install(false, args);
}
if (!(arg_install || arg_uninstall))
{
if (arg_gui || Environment.UserInteractive || Debugger.IsAttached)
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.Run(new Form1());
}
else
{
rethrow = true; //so that windows sees error...
ServiceBase[] services = { new Service1() };
ServiceBase.Run(services);
rethrow = false;
}
}
return 0;
}
catch (Exception ex)
{
if (rethrow) throw;
Console.Error.WriteLine(ex.Message);
return -1;
}
}
static void Install(bool undo, string[] args)
{
try
{
Console.WriteLine(undo ? "uninstalling" : "installing");
using (AssemblyInstaller inst = new AssemblyInstaller(typeof(Program).Assembly, args))
{
IDictionary state = new Hashtable();
inst.UseNewContext = true;
try
{
if (undo)
{
inst.Uninstall(state);
}
else
{
inst.Install(state);
inst.Commit(state);
}
}
catch
{
try
{
inst.Rollback(state);
}
catch { }
throw;
}
}
}
catch (Exception ex)
{
Console.Error.WriteLine(ex.Message);
}
}
}
[RunInstaller(true)]
public sealed class MyServiceInstallerProcess : ServiceProcessInstaller
{
public MyServiceInstallerProcess()
{
this.Account = ServiceAccount.NetworkService;
}
}
[RunInstaller(true)]
public sealed class MyServiceInstaller : ServiceInstaller
{
public MyServiceInstaller()
{
this.Description = "My Service";
this.DisplayName = "My Service";
this.ServiceName = "My Service";
this.StartType = System.ServiceProcess.ServiceStartMode.Manual;
}
}
}
avez-vous jamais donner un sens à la solution ci-dessous? plus loin en créant les classes wrapper ou tel?
OriginalL'auteur Rex Logan | 2009-01-07
Vous devez vous connecter pour publier un commentaire.
En gros, vous avez deux choix. Exposer une API sur le service que vous pouvez ensuite appeler à partir de l'INTERFACE utilisateur de l'app OU activer le service pour s'exécuter comme une application winforms ou d'un service.
La première option est assez facile à utiliser l'accès distant ou de la WCF pour exposer l'API.
La deuxième option peut être obtenue en déplaçant les "tripes" de votre application dans une classe séparée puis créer un wrapper de service et une victoire-formes wrapper qui à la fois appel à vos "tripes" de la classe.
OriginalL'auteur bozag
Créer une nouvelle application winforms les références à l'assemblée de votre service.
OriginalL'auteur Abtin Forouzandeh
Si vous utilisez le code ci-dessous:
Alors votre EXE sera exécuté comme un service (si lancé par la SCM) ou comme une interface graphique (si lancé par un autre processus).
Essentiellement, tout ce que j'ai fait ici est utilisé Réflecteur à comprendre ce que la viande de
ServiceBase.Run
n', et de le reproduire ici (la réflexion est nécessaire, car il appelle des méthodes privées). La raison de ne pas appelerServiceBase.Run
directement, c'est qu'il affiche une boîte de message pour dire la utilisateur que le service ne peut pas être démarré (si ce n'est lancé par la SCM) et ne retourne rien à dire la code que le service ne peut pas être démarré.Car il utilise la réflexion pour appeler cadre privé méthodes, il peut ne pas fonctionner correctement dans les futures révisions du cadre. Mise en garde codor.
OriginalL'auteur P Daddy
Il est également FireDaemon. Cela vous permet d'exécuter n'importe quelle application windows en tant que service.
OriginalL'auteur Ray Booysen
Voir Suis-je l'exécute en tant que service pour certains d'autres informations utiles.
La chose la plus importante couvert est de savoir comment déterminer de manière fiable si nous sommes à court de manière interactive ou via un service.
OriginalL'auteur Ash
vous avez à mettre en œuvre un processus distinct qui peut communiquer avec votre service. Alors qu'il est possible sur XP et versions antérieures des systèmes de disposer d'un service montrant une INTERFACE utilisateur, qui n'est plus possible sur Vista et les versions ultérieures.
OriginalL'auteur Stefan
Une autre possibilité est de ne PAS utiliser un service, mais pour utiliser une application qui se trouve dans la barre des tâches (pensez Roxio Drag-to-Disc, & il est probable que votre logiciel Anti-virus vit là-bas) qui a une icône en bas à côté de l'horloge, qui lance un menu, lorsqu'il est cliqué avec le bouton droit, et une INTERFACE utilisateur lorsque vous double-cliqué.
S'il vous plaît, ne mettez pas plus de merde dans la barre des tâches si vous n'avez pas à.
C'est la possibilité de répondre aux besoins décrits.. je n'étais pas forcément à recommander que le cours de l'action.
OriginalL'auteur Stephen Wrighton
Si votre service est modulée correctement, vous pouvez héberger le service, soit dans un fichier exécutable comme un service, ou avec un exécutable avec une interface graphique pour le test.
Nous utilisons cette méthode avec notre service, le service autonome-exécutable héberge le service en environnement de production, mais nous avons une console-app pour l'accueil, le service, trop.
OriginalL'auteur Oliver Friedrich
Séparer ton code en différentes composantes: une composante à gérer les éléments du service et de la logique métier. Créer et interagir avec la logique métier de la composante de service. Pour le test (d'une logique d'entreprise), vous pouvez créer une WinForm ou console application qui utilise la logique métier composant sans le composant de service. Mieux encore, utilisez un framework de test unitaire pour la majeure partie de vos tests. De nombreuses méthodes dans le composant de service sera sans aucun doute unité vérifiable.
OriginalL'auteur tvanfosson
Si vous encapsuler la logique d'entreprise dans les classes de service et ensuite utiliser un modèle de fabrique pour la création de ces services, vous pouvez utiliser le même ensemble de services pour une application de bureau (desktop factory) et les services web (hôte dans WCF).
Définition de la prestation:
Usine pour le bureau, WinForms pour obtenir des services pour faire des affaires:
Vous accueillir ce soit avec la WCF ServiceHost classe, ou dans IIS. Les deux vous permettent de spécifier comment instancier chaque instance du service, de sorte que vous pouvez faire de l'initialisation comme les chaînes de connexion, etc.
OriginalL'auteur Jason Jackson
Vous pouvez créer le service d'appel d'un autre exécutable avec un argument de ligne de commande de sorte qu'il est exécuté sans la forme. Lorsque que l'exe est appelé sans argument de ligne de commande, il montre la forme et la loi normale.
OriginalL'auteur Jimmy Bergmark - JTB World