Einen Windows-Dienst im Konsolenmodus ausführen?

Fand ich einige Beispiel-code veröffentlicht
https://groups.google.com/group/microsoft.public.dotnet.languages.csharp/browse_thread/thread/4d45e9ea5471cba4/4519371a77ed4a74?hl=en&pli=1
für selbst installieren ein Windows-Dienst. Ich bin in C# auf fx 4.0. Versuchen
um herauszufinden, wo ich ging Weg von den Schienen...

Meine Fragen:

1. Ich schuf eine Win-Service-Projekt. In das Programm.cs /main() habe ich ziemlich viel
   kopiert den code Beispiel. Es erscheint den meisten alles funktioniert
   außer starten Sie eine Konsole-Fenster wenn ich im DEBUG-Modus (übergabe -
   c natürlich). Für einige Grund die Konsole-Fenster wird nicht geöffnet.
2. Eine weitere Herausforderung, die ich hatte, war der Aufruf von Start() /ShutDown() in
   die Konsole Teil würde nicht kompilieren. Ich landete initialisieren
   mein service-Objekt und rufen Sie dann.
3. Ich erhalte die folgende Fehlermeldung, wenn die Konsole.ReadKey () - Methode aufgerufen wird:

Nicht Lesen kann, Tasten, wenn entweder
Anwendung nicht über eine Konsole oder
wenn " console input umgeleitet wurde
aus einer Datei. Versuchen Sie Der Konsole.Lesen.

Mein code und so Zeug:

Ein Bild von meinem Projekt Struktur:

HINWEIS: ich war das duplizieren der startup-sequence in die TestHarness, wenn
im DEBUG-Modus. Wenn/Wann bekomme ich diese zu arbeiten, ich werde fallen,
aus der Lösung. Die Bibliothek-Projekt ist, wo die Mehrheit meiner
code Leben.

PROGRAMM.CS

using System;
using System.Collections.Generic;
using System.Linq;
using System.ServiceProcess;
using System.Text;
using System.ComponentModel;
using System.Configuration.Install;
using System.Collections;
using RivWorks.FeedHandler.Service;

namespace RivWorks.FeedHandler
{
    static class Program
    {
        ///<summary>
        ///The main entry point for the application.
        ///</summary>
        static int Main(string[] args)
        {
            bool install = false, uninstall = false, console = false, rethrow = false;

            try
            {
                foreach (string arg in args)
                {
                    switch (arg)
                    {
                        case "-i":
                        case "-install":
                            install = true; break;
                        case "-u":
                        case "-uninstall":
                            uninstall = true; break;
                        case "-c":
                        case "-console":
                            console = true; break;
                        default:
                            Console.Error.WriteLine("Argument not expected: " + arg);
                            break;
                    }
                }
                if (uninstall)
                {
                    Install(true, args);
                }
                if (install)
                {
                    Install(false, args);
                }
                if (console)
                {
                    Console.WriteLine("Starting...");
                    FeedListener fl = new FeedListener();
                    fl.StartUp();
                    Console.WriteLine("System running; press any key to stop");
                    Console.ReadKey(true);
                    fl.ShutDown();
                    Console.WriteLine("System stopped");
                }
                else if (!(install || uninstall))
                {
                    rethrow = true; //so that windows sees error...
                    ServiceBase[] services = { new Service.FeedListener() };
                    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 = "Provides a service to listen for, then import, feed files from various sources.";
            this.DisplayName = "RIVWorks Feed Handler (.NET 4.0)";
            this.ServiceName = "FeedListener";
            this.StartType = System.ServiceProcess.ServiceStartMode.Automatic;
        }
    }
}

FEEDLISTENER.CS

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Diagnostics;
using System.Linq;
using System.ServiceProcess;
using System.Text;
using System.IO;
using sysIO = System.IO;
using RivWorks.FeedHandler;
using System.Collections;
using RivWorks.FeedHandler.Library;
using System.Threading;

namespace RivWorks.FeedHandler.Service
{
    public partial class FeedListener : ServiceBase
    {
        #region Declarations
        static private List<string> _keys = new List<string>();
        static private System.Threading.Timer _clock = null;
        static private FileSystemWatcher _watcher;
        static private RivWorks.FeedHandler.Library.QueueHandler _qHandler = null;
        static private bool _isDequeueing = false;
        #endregion

        #region Constructor
        public FeedListener()
        {
            InitializeComponent();
        }
        #endregion

        #region Internal Methods
        internal void StartUp() {...}
        internal void ShutDown() {...}
        #endregion

        #region Start/Stop
        protected override void OnStart(string[] args)
        {
            StartUp();
        }
        protected override void OnStop()
        {
            ShutDown();
        }
        #endregion

        #region Event Handlers
        static void qHandler_QueuesGrew() {...}
        static void qHandler_QueuesShrunk() {...}
        static void qHandler_QueuesChanged() {...}
        static void fileCreatedOrChanged(object sender, sysIO.FileSystemEventArgs e) {...}
        #endregion

        #region Private Methods
        private static void Tick(object state) {...}
        private static void WriteToEventLog(Exception ex, EventLogEntryType eventLogEntryType) {...}
        private static void WriteToEventLog(string message, EventLogEntryType eventLogEntryType) {...}
        #endregion
    }
}

InformationsquelleAutor der Frage Keith Barrows | 2011-05-19