Wacht een seconde in lopend programma

Ik wil een seconde wachten voordat ik mijn rastercellen afdruk met deze code, maar het werkt niet. Wat kan ik doen?

Antwoord 1, autoriteit 100%

Is het pauzeren, maar je ziet je rode kleur niet in de cel verschijnen? Probeer dit:

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

Antwoord 2, autoriteit 18%

Persoonlijk vind ik Thread.Sleep een slechte implementatie. Het vergrendelt de gebruikersinterface enz. Persoonlijk hou ik van timer-implementaties omdat het wacht en vervolgens wordt geactiveerd.

Gebruik: 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();
}

Antwoord 3, autoriteit 11%

Wachtfunctie met timers, geen UI-vergrendelingen.

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

Gebruik: plaats dit gewoon in uw code die moet wachten:

wait(1000); //wait one second

Antwoord 4, autoriteit 5%

.Net Core lijkt de DispatcherTimer te missen.

Als we akkoord gaan met het gebruik van een asynchrone methode, zal Task.Delay aan onze behoeften voldoen. Dit kan ook handig zijn als je om snelheidsbeperkende redenen in een for-lus wilt wachten.

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

U kunt als volgt wachten op de voltooiing van deze methode:

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

Antwoord 5, autoriteit 2%

De beste manier om te wachten zonder je hoofdthread te bevriezen, is door de Task.Delay functie.

Dus je code ziet er zo uit

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

Antwoord 6

Ik heb het gevoel dat het enige wat hier fout was de volgorde was. Selcuklu wilde dat de app een seconde wachtte voordat hij het raster invulde, dus het Sleep-commando had voor het fill-commando moeten komen.

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

Antwoord 7

Druk wachten zal geen groot nadeel zijn als het kort is.
In mijn geval was het nodig om de gebruiker visuele feedback te geven door een besturingselement te laten knipperen (het is een kaartbesturingselement dat naar het klembord kan worden gekopieerd, waardoor de achtergrond enkele milliseconden verandert).
Het werkt prima op deze manier:

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;
....

Antwoord 8

gebruik dataGridView1.Refresh(); 🙂

Antwoord 9

Probeer deze functie

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

Belfunctie

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

Antwoord 10

Probeer misschien deze code:

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