Jak utrzymać uruchomioną aplikację konsoli .NET?

Rozważ aplikację konsolową, która uruchamia niektóre usługi w osobnym wątku. Wszystko, co musi zrobić, to poczekać, aż użytkownik naciśnie Ctrl + C, aby go wyłączyć.

Która z poniższych opcji jest lepszym sposobem na zrobienie tego?

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
}

Lub to, używając 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
}

zawsze chcesz zapobiec używaniu pętli while, zwłaszcza gdy wymuszasz na kodzie ponowne sprawdzanie zmiennych. Marnuje zasoby procesora i spowalnia program.

Zdecydowanie powiedziałbym o pierwszym.

Alternatywnie prostszym rozwiązaniem jest po prostu:

Console.ReadLine();

Możesz to zrobić (i usunąć CancelKeyPressmoduł obsługi zdarzeń):

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

Nie jestem pewien, czy to jest lepsze, ale nie podoba mi się pomysł wywoływania Thread.Sleeppętli. Myślę, że blokowanie danych wejściowych użytkownika jest czystsze.

Wolę korzystać z Application.Run

static void Main(string[] args) {

   //Do your stuff here

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

   //Cleanup/Before Quit
}

z dokumentów:

Rozpoczyna uruchamianie standardowej pętli komunikatów aplikacji w bieżącym wątku, bez formularza.

Wygląda na to, że utrudniasz to, niż potrzebujesz. Dlaczego nie tylko Joinwątek po zasygnalizowaniu jego zatrzymania?

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);
        }
    }
}

Możliwe jest również zablokowanie wątku / programu na podstawie tokenu anulowania.

token.WaitHandle.WaitOne();

WaitHandle jest sygnalizowany, gdy token jest anulowany.

Widziałem tę technikę używaną przez Microsoft.Azure.WebJobs.JobHost, gdzie token pochodzi ze źródła tokenu anulowania WebJobsShutdownWatcher (obserwator plików, który kończy zadanie).

Daje to pewną kontrolę nad tym, kiedy program może się zakończyć.

Z dwóch pierwszy jest lepszy

_quitEvent.WaitOne();

ponieważ w drugim wątek budzi się co jedną milisekundę i zostaje zamieniony na przerwanie systemu operacyjnego, co jest drogie

Powinieneś to zrobić tak, jak gdybyś programował usługę Windows. Nigdy nie użyłbyś instrukcji while zamiast tego użyłbyś delegata. WaitOne () jest zwykle używana podczas oczekiwania na usunięcie wątków - Thread.Sleep () - nie jest zalecane - Czy myślałeś o użyciu System.Timers.Timer przy użyciu tego zdarzenia do sprawdzenia zdarzenia zamknięcia?