C # | Application console | Comment faire attendre le programme (temps en ms) avant d'exécuter la ligne suivante?

Une manière simple de faire ceci est d'utiliser

System.Threading.Thread.Sleep (5000); // Fait une pause de 5 secondes. Donc, pour flasher, faites ceci.

Console.Clear();
Console.WriteLine("SomeText");
System.Threading.Thread.Sleep(1000);
Console.Clear();
Console.WriteLine("SomeText");
System.Threading.Thread.Sleep(1000);
/// ETC.. 

Console.WriteLine("Press Any key To Continue...)

C'est la manière la plus simple de le faire et vous aidera à mieux comprendre le codage. Si vous voulez qu'il continue à clignoter, placez-le simplement à l'intérieur d'une boucle. POURTANT! Gardez à l'esprit que le code "Suspend" effectivement l'exécution du code. Donc, s'il est sur une ligne de pause, il NE permettra PAS à un utilisateur d'appuyer sur une touche pour continuer. C'est pourquoi j'ai placé la dernière Console.WriteLine (); en bas. Si vous voulez que l'utilisateur puisse appuyer sur une touche à tout moment et la faire clignoter en permanence, vous devrez vous impliquer dans le multi-threading, qui est probablement un peu plus complexe que ce qui vous intéresse.

Tout d'abord, je n'utiliserais pas Thread.Sleep pour cela. Dormir votre fil principal offre une expérience utilisateur assez rude ... C'est une approche rapide et sale, mais pas vraiment à quoi sert cette méthode.

Voici un exemple rapide qui utilise une minuterie pour flasher une ligne de texte.

using System.Timers;
class Program
{
    static void Main(string[] aszArgs)
    {
        Timer myTimer = new Timer(500);
        myTimer.Elapsed += MyTimer_Elapsed;
        myTimer.Enabled = true;

        //Wait for a key. Or do other work... whatever you want
        Console.ReadKey();
    }

    private static bool cleared = true;
    private static void MyTimer_Elapsed(object sender, ElapsedEventArgs e)
    {
        if (cleared)
            Console.WriteLine("Flash text");
        else
            Console.Clear();

        cleared = !cleared;
    }
}  

J'utilise System.Timers.Timer dans cet exemple, qui contient une documentation solide et des exemples ici .

Vous pouvez effectuer un lot d'actions à intervalles égaux comme ceci:

using System;
using System.Threading;

namespace ConsoleApp
{
    class Program
    {
        static void Main(string[] args)
        {
            new Program().Run();
        }

        private void Run()
        {
            do
            {
                while (!Console.KeyAvailable)
                    this.InvokeWithIntervals(1000,
                                             () => Console.WriteLine("Press any key to continue..."),
                                             () => Console.Clear());
            } while (Console.ReadKey(true).Key != ConsoleKey.Escape);
        }

        private void InvokeWithIntervals(int interval, params Action[] actions)
        {
            foreach(var action in actions)
            {
                action.Invoke();
                Thread.Sleep(interval);
            }
        }
    }
}

Une approche légèrement différente serait d'utiliser la classe Chronomètre pour mesurer le temps, et de ne changer le texte que si nous avons dépassé "l'intervalle de flash" spécifié.

Nous pourrions écrire une méthode pour ce faire, ce qui prendrait une invite de chaîne à afficher, et un intervalle TimeSpan qui spécifie le temps d'attente entre le clignotement du texte.

Dans le code, nous capturions la position du curseur et les couleurs de la console, démarrions un chronomètre, puis chaque fois que le chronomètre passait le laps de temps spécifié par intervalle , nous échangions la Console. et Console.BackgroundColor.

La méthode le ferait jusqu'à ce que l'utilisateur appuie sur une touche, que nous retournerions à l'appelant:

private static void Main()
{
    Console.WriteLine("Hello! The text below will flash red " + 
        "and green once per second until you press [Enter]");

    Console.ForegroundColor = ConsoleColor.Red;
    Console.BackgroundColor = ConsoleColor.Green;

    while (FlashPrompt("Press [Enter] to continue...", 
        TimeSpan.FromSeconds(1)) != ConsoleKey.Enter) ;

    Console.ResetColor();

    // Code will now continue in the original colors
}

Maintenant, du côté appelant, nous lui transmettons le texte «Appuyez sur échapper pour continuer» et le temps que nous voulons attendre ( TimeSpan.FromMilliseconds (500) code > dans votre cas), et alors nous pourrions appeler cela dans un while boucle, jusqu'à ce que l'utilisateur appuie sur ConsoleKey.Escape:

private static void Main()
{
    // Flash prompt until user presses escape
    while (FlashPrompt("Press escape to continue...", 
        TimeSpan.FromMilliseconds(500)) != ConsoleKey.Escape) ;

    // Code execution continues after they press escape...
}

La bonne chose ici est que vous pouvez réutiliser la logique et peut spécifier des temps de flash plus courts ou plus longs. Vous pouvez également changer les couleurs qui deviennent "flashées" en les spécifiant avant d'appeler la méthode (ou la méthode pourrait être écrite pour les prendre comme arguments).

Par exemple, essayez ceci:

private static ConsoleKey FlashPrompt(string prompt, TimeSpan interval)
{
    // Capture the cursor position and console colors
    var cursorTop = Console.CursorTop;
    var colorOne = Console.ForegroundColor;
    var colorTwo = Console.BackgroundColor;

    // Use a stopwatch to measure time interval
    var stopwach = Stopwatch.StartNew();
    var lastValue = TimeSpan.Zero;

    // Write the initial prompt
    Console.Write(prompt);

    while (!Console.KeyAvailable)
    {
        var currentValue = stopwach.Elapsed;

        // Only update text with new color if it's time to change the color
        if (currentValue - lastValue < interval) continue;

        // Capture the current value, swap the colors, and re-write our prompt
        lastValue = currentValue;
        Console.ForegroundColor = Console.ForegroundColor == colorOne 
            ? colorTwo : colorOne;
        Console.BackgroundColor = Console.BackgroundColor == colorOne 
            ? colorTwo : colorOne;
        Console.SetCursorPosition(0, cursorTop);
        Console.Write(prompt);
    }

    // Reset colors to where they were when this method was called
    Console.ForegroundColor = colorOne;
    Console.BackgroundColor = colorTwo;

    return Console.ReadKey(true).Key;
}