Attendez une seconde dans le programme en cours d'exécution


104
dataGridView1.Rows[x1].Cells[y1].Style.BackColor = System.Drawing.Color.Red;
System.Threading.Thread.Sleep(1000);

Je veux attendre une seconde avant d'imprimer mes cellules de grille avec ce code, mais cela ne fonctionne pas. Que puis-je faire?


1
Quel code est censé être exécuté après 1 seconde d'attente?
Allensb

1
Comment savez-vous que cela ne fonctionne pas? Essayez Sleep 10000 et voyez si cela fonctionne. 1000 est très court pour évaluer si cela fonctionne.
Missy

Cela fonctionne bien: System.Threading.Thread.Sleep (1000);
Andrew

Réponses:


177

Est-ce qu'il fait une pause, mais vous ne voyez pas votre couleur rouge apparaître dans la cellule? Essaye ça:

dataGridView1.Rows[x1].Cells[y1].Style.BackColor = System.Drawing.Color.Red;
dataGridView1.Refresh();
System.Threading.Thread.Sleep(1000);

28

Personnellement, je pense que Thread.Sleepc'est une mauvaise mise en œuvre. Il verrouille l'interface utilisateur, etc. J'aime personnellement les implémentations de minuterie car il attend puis se déclenche.

Usage: DelayFactory.DelayAction(500, new Action(() => { this.RunAction(); }));

//Note Forms.Timer and Timer() have similar implementations. 

public static void DelayAction(int millisecond, Action action)
{
    var timer = new DispatcherTimer();
    timer.Tick += delegate

    {
        action.Invoke();
        timer.Stop();
    };

    timer.Interval = TimeSpan.FromMilliseconds(millisecond);
    timer.Start();
}

15

Fonction d'attente à l'aide de minuteries, pas de verrous d'interface utilisateur.

public void wait(int milliseconds)
{
    var timer1 = new System.Windows.Forms.Timer();
    if (milliseconds == 0 || milliseconds < 0) return;

    // Console.WriteLine("start wait timer");
    timer1.Interval = milliseconds;
    timer1.Enabled  = true;
    timer1.Start();

    timer1.Tick += (s, e) =>
    {
        timer1.Enabled = false;
        timer1.Stop();
        // Console.WriteLine("stop wait timer");
    };

    while (timer1.Enabled)
    {
        Application.DoEvents();
    }
}

Utilisation: il suffit de placer ceci dans votre code qui doit attendre:

wait(1000); //wait one second

Juste une suggestion. Si vous multipliez le min par 60000, le nom du paramètre sera plus significatif. timer1.Interval = min * 60000;
Golda

Oui, vous avez raison, cela devrait être des millisecondes au lieu de min. Je mettrai à jour le nom. Merci
Dit

2

L'attente occupée ne sera pas un inconvénient majeur si elle est courte. Dans mon cas, il était nécessaire de donner un retour visuel à l'utilisateur en faisant clignoter un contrôle (c'est un contrôle de graphique qui peut être copié dans le presse-papiers, qui change d'arrière-plan pendant quelques millisecondes). Cela fonctionne bien de cette façon:

using System.Threading;
...
Clipboard.SetImage(bm);   // some code
distribution_chart.BackColor = Color.Gray;
Application.DoEvents();   // ensure repaint, may be not needed
Thread.Sleep(50);
distribution_chart.BackColor = Color.OldLace;
....

2

J'ai l'impression que tout ce qui n'allait pas ici était l'ordre, Selçuklu voulait que l'application attende une seconde avant de remplir la grille, donc la commande Sleep aurait dû venir avant la commande fill.

    System.Threading.Thread.Sleep(1000);
    dataGridView1.Rows[x1].Cells[y1].Style.BackColor = System.Drawing.Color.Red;

2

.Net Core semble manquer le DispatcherTimer.

Si nous acceptons d'utiliser une méthode asynchrone, Task.Delayrépondra à nos besoins. Cela peut également être utile si vous souhaitez attendre à l'intérieur d'une boucle for pour des raisons de limitation de débit.

public async Task DoTasks(List<Items> items)
{
    foreach (var item in items)
    {
        await Task.Delay(2 * 1000);
        DoWork(item);
    }
}

Vous pouvez attendre la fin de cette méthode comme suit:

public async void TaskCaller(List<Item> items)
{
    await DoTasks(items);
}

C'est juste la manière parfaite. Merci ! :)
Deniz


0

Essayez cette fonction

public void Wait(int time) 
{           
    Thread thread = new Thread(delegate()
    {   
        System.Threading.Thread.Sleep(time);
    });
    thread.Start();
    while (thread.IsAlive)
    Application.DoEvents();
}

Fonction d'appel

Wait(1000); // Wait for 1000ms = 1s

0

La meilleure façon d'attendre sans geler votre thread principal consiste à utiliser la tâche. fonction .

Donc votre code ressemblera à ceci

var t = Task.Run(async delegate
{              
    dataGridView1.Rows[x1].Cells[y1].Style.BackColor = System.Drawing.Color.Red;
    dataGridView1.Refresh();
    await Task.Delay(1000);             
});

-4

Essayez peut-être ce code:

void wait (double x) {
    DateTime t = DateTime.Now;
    DateTime tf = DateTime.Now.AddSeconds(x);

    while (t < tf) {
        t = DateTime.Now;
    }
}

5
C'est une solution valable. Cependant, vous devez ajouter une description de ses avantages et inconvénients, par exemple en mentionnant que, comme il s'agit d'une solution d'attente très chargée, elle prendra du temps CPU.

1
La solution la plus courte est la meilleure solution
BASEER ULHASSAN
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.