Espere um segundo no programa em execução

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

Quero esperar um segundo antes de imprimir minhas células de grade com este código, mas não está funcionando. O que eu posso fazer?

Ele está fazendo uma pausa, mas você não vê a cor vermelha aparecer na célula? Experimente isto:

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

Pessoalmente, acho que Thread.Sleepé uma implementação ruim. Ele bloqueia a interface do usuário, etc. Eu pessoalmente gosto de implementações de cronômetro, pois ele espera e dispara.

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

Função de espera usando temporizadores, sem bloqueios de IU.

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

Uso: basta colocar isso dentro do seu código que precisa esperar:

wait(1000); //wait one second

A espera ocupada não será uma desvantagem grave se for curta. No meu caso, houve a necessidade de dar feedback visual ao usuário, piscando um controle (é um controle gráfico que pode ser copiado para a área de transferência, que muda seu fundo por alguns milissegundos). Funciona bem desta forma:

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

Acho que tudo o que estava errado aqui era a ordem, Selçuklu queria que o aplicativo esperasse um segundo antes de preencher a grade, então o comando Sleep deveria vir antes do comando fill.

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

.Net Core parece estar faltando o DispatcherTimer.

Se concordarmos em usar um método assíncrono, Task.Delayisso atenderá às nossas necessidades. Isso também pode ser útil se você quiser esperar dentro de um loop for por motivos de limitação de taxa.

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

Você pode aguardar a conclusão deste método da seguinte forma:

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

use dataGridView1.Refresh();:)

Experimente esta função

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

Função de chamada

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

A melhor maneira de esperar sem congelar seu thread principal é usando a função Task.Delay .

Portanto, seu código será semelhante a este

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

Experimente este código:

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

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