CPU amical boucle infinie

Pour éviter le débordement de la boucle de simplement utiliser un WaitHandle. Pour permettre le processus d'être sorti entre le monde extérieur et l'utilisation d'un EventWaitHandle avec une chaîne unique. Ci-dessous est un exemple.

Si vous démarrez pour la première fois, c'est simple imprime un message toutes les 10 secondes. Si vous commencez dans le temps, une deuxième instance du programme, il devra en informer l'autre processus gracieusement sortie et quitte de lui-même immédiatement. L'utilisation du PROCESSEUR pour cette approche: 0%

private static void Main(string[] args)
{
    //Create a IPC wait handle with a unique identifier.
    bool createdNew;
    var waitHandle = new EventWaitHandle(false, EventResetMode.AutoReset, "CF2D4313-33DE-489D-9721-6AFF69841DEA", out createdNew);
    var signaled = false;

    //If the handle was already there, inform the other process to exit itself.
    //Afterwards we'll also die.
    if (!createdNew)
    {
        Log("Inform other process to stop.");
        waitHandle.Set();
        Log("Informer exited.");

        return;
    }

    //Start a another thread that does something every 10 seconds.
    var timer = new Timer(OnTimerElapsed, null, TimeSpan.Zero, TimeSpan.FromSeconds(10));

    //Wait if someone tells us to die or do every five seconds something else.
    do
    {
        signaled = waitHandle.WaitOne(TimeSpan.FromSeconds(5));
        //ToDo: Something else if desired.
    } while (!signaled);

    //The above loop with an interceptor could also be replaced by an endless waiter
    //waitHandle.WaitOne();

    Log("Got signal to kill myself.");
}

private static void Log(string message)
{
    Console.WriteLine(DateTime.Now + ": " + message);
}

private static void OnTimerElapsed(object state)
{
    Log("Timer elapsed.");
}

Pourquoi voulez-vous tolérer l'utilisation d'une boucle infinie? Pour cet exemple, le réglage du programme jusqu'en tant que tâche planifiée, afin d'être exécuté à chaque minute, pas plus économique?

Je l'ai fait pour une application qui avait pour traiter les fichiers qu'ils ont été abandonnés sur un dossier. Votre meilleur pari est d'une minuterie (comme l'a suggéré) avec une Console.ReadLine() à la fin de la "main" sans le mettre dans une boucle.

Maintenant, votre préoccupation à propos de demander à l'application de s'arrêter:

Je l'ai aussi fait par le biais de certains rudimentaire "fichier" moniteur. Il suffit de créer le fichier "quit.txt" dans le dossier racine de l'application (par mon programme ou une autre application qui pourrait demande à l'arrêt) fera la fermeture de l'application. Semi-code:

<do your timer thing here>
watcher = new FileSystemWatcher();
watcher.Path = <path of your application or other known accessible path>;
watcher.Changed += new FileSystemEventHandler(OnNewFile);
Console.ReadLine();

La OnNewFile pourrait être quelque chose comme ceci:

private static void OnNewFile(object source, FileSystemEventArgs e)
{
    if(System.IO.Path.GetFileName(e.FullPath)).ToLower()=="quit.txt")
        ... remove current quit.txt
        Environment.Exit(1);
}

Maintenant, vous avez mentionné que c'est (ou pourrait être) pour une application mobile? Vous pourriez ne pas avoir le fichier system watcher. Dans ce cas, peut-être vous avez juste besoin de "tuer" le processus (vous avez dit "Dans des situations particulières (comme: mise à jour de l'application), j'ai besoin de demander l'application de l'arrêt". Celui qui le "demandeur" à l'arrêt il est, il suffit de tuer le processus)

Vous pouvez utiliser Begin-/End-Invoke céder à d'autres threads. E. g.

public static void ExecuteAsyncLoop(Func<bool> loopBody)
{
    loopBody.BeginInvoke(ExecuteAsyncLoop, loopBody);
}

private static void ExecuteAsyncLoop(IAsyncResult result)
{
    var func = ((Func<bool>)result.AsyncState);
    try
    {
        if (!func.EndInvoke(result))
            return;
    }
    catch
    {
        //Do something with exception.
        return;
    }

    func.BeginInvoke(ExecuteAsyncLoop, func);
}

Que vous pouvez l'utiliser en tant que tel:

ExecuteAsyncLoop(() =>
    {
        //Do something.
        return true; //Loop indefinitely.
    });

Cette habitude de 60% d'un core sur ma machine (complètement vide de la boucle). Alternativement, vous pouvez utiliser cette (Source) code dans le corps de la boucle:

private static readonly bool IsSingleCpuMachine = (Environment.ProcessorCount == 1);
[DllImport("kernel32", ExactSpelling = true)]
private static extern void SwitchToThread();

private static void StallThread()
{
    //On a single-CPU system, spinning does no good
    if (IsSingleCpuMachine) SwitchToThread();
    //Multi-CPU system might be hyper-threaded, let other thread run
    else Thread.SpinWait(1);
}

while (true)
{
    //Do something.
    StallThread();
}

Que 20% d'un core sur ma machine.

La Minuterie approche est probablement votre meilleur pari, mais puisque vous parlez de Fil.Le sommeil est intéressant Fil de discussion.SpinWait ou SpinWait struct alternative pour des problèmes similaires qui peut être parfois mieux que de courtes Fil.Le sommeil des invocations.

Voir aussi cette question: Quel est le but de Fil.SpinWait méthode?

De garder les applications de console en cours d'exécution juste ajouter un Console.ReadLine() à la fin de votre code dans Main().

Si l'utilisateur ne devrait pas être en mesure de mettre fin à l'application, vous pouvez le faire avec une boucle comme suit:

while (true){
   Console.ReadLine();
}