Wie kann eine .NET-Konsolen-App ausgeführt werden?

Stellen Sie sich eine Konsolenanwendung vor, die einige Dienste in einem separaten Thread startet. Sie müssen lediglich warten, bis der Benutzer Strg + C drückt, um das System herunterzufahren.

Welcher der folgenden Wege ist der bessere?

static ManualResetEvent _quitEvent = new ManualResetEvent(false);

static void Main() {
    Console.CancelKeyPress += (sender, eArgs) => {
        _quitEvent.Set();
        eArgs.Cancel = true;
    };

    // kick off asynchronous stuff 

    _quitEvent.WaitOne();

    // cleanup/shutdown and quit
}

Oder dies mit Thread.Sleep (1):

static bool _quitFlag = false;

static void Main() {
    Console.CancelKeyPress += delegate {
        _quitFlag = true;
    };

    // kick off asynchronous stuff 

    while (!_quitFlag) {
        Thread.Sleep(1);
    }

    // cleanup/shutdown and quit
}

Sie möchten immer die Verwendung von while-Schleifen verhindern, insbesondere wenn Sie den Code zwingen, Variablen erneut zu überprüfen. Es verschwendet CPU-Ressourcen und verlangsamt Ihr Programm.

Ich würde definitiv den ersten sagen.

Alternativ ist eine einfachere Lösung einfach:

Console.ReadLine();

Sie können dies tun (und den CancelKeyPressEreignishandler entfernen ):

while(!_quitFlag)
{
    var keyInfo = Console.ReadKey();
    _quitFlag = keyInfo.Key == ConsoleKey.C
             && keyInfo.Modifiers == ConsoleModifiers.Control;
}

Ich bin mir nicht sicher, ob das besser ist, aber ich mag die Idee, Thread.Sleepeine Schleife aufzurufen , nicht. Ich denke, es ist sauberer, Benutzereingaben zu blockieren.

Ich bevorzuge die Verwendung der Application.Run

static void Main(string[] args) {

   //Do your stuff here

   System.Windows.Forms.Application.Run();

   //Cleanup/Before Quit
}

aus den Dokumenten:

Startet die Ausführung einer Standardanwendungsnachrichtenschleife für den aktuellen Thread ohne Formular.

Scheint, als würdest du es schwieriger machen als nötig. Warum nicht einfach Joinden Thread, nachdem Sie ihm signalisiert haben, dass er aufhören soll?

class Program
{
    static void Main(string[] args)
    {
        Worker worker = new Worker();
        Thread t = new Thread(worker.DoWork);
        t.IsBackground = true;
        t.Start();

        while (true)
        {
            var keyInfo = Console.ReadKey();
            if (keyInfo.Key == ConsoleKey.C && keyInfo.Modifiers == ConsoleModifiers.Control)
            {
                worker.KeepGoing = false;
                break;
            }
        }
        t.Join();
    }
}

class Worker
{
    public bool KeepGoing { get; set; }

    public Worker()
    {
        KeepGoing = true;
    }

    public void DoWork()
    {
        while (KeepGoing)
        {
            Console.WriteLine("Ding");
            Thread.Sleep(200);
        }
    }
}

Es ist auch möglich, den Thread / das Programm basierend auf einem Abbruch-Token zu blockieren.

token.WaitHandle.WaitOne();

WaitHandle wird signalisiert, wenn das Token abgebrochen wird.

Ich habe diese Technik gesehen, die von Microsoft.Azure.WebJobs.JobHost verwendet wird, wobei das Token von einer Storno-Token-Quelle des WebJobsShutdownWatcher (einem Datei-Watcher, der den Job beendet) stammt.

Dies gibt eine gewisse Kontrolle darüber, wann das Programm enden kann.

Von den beiden ist der erste besser

_quitEvent.WaitOne();

denn im zweiten wird der Thread jede Millisekunde aufgeweckt und in einen teuren Betriebssystem-Interrupt umgewandelt

Sie sollten es genauso machen, als würden Sie einen Windows-Dienst programmieren. Sie würden niemals eine while-Anweisung verwenden, sondern einen Delegaten. WaitOne () wird im Allgemeinen verwendet, während auf das Entsorgen von Threads gewartet wird - Thread.Sleep () - ist nicht ratsam - Haben Sie darüber nachgedacht, System.Timers.Timer zu verwenden, um dieses Ereignis zum Überprüfen des Herunterfahrereignisses zu verwenden?