Quando usar Task.Delay, quando usar Thread.Sleep?

Existem boas regras para quando usar Task.Delay versus Thread.Sleep ?

• Especificamente, existe um valor mínimo para garantir que um seja eficaz / eficiente em relação ao outro?
• Por fim, como o Task.Delay causa a alternância de contexto em uma máquina de estado assíncrona / aguardada, há uma sobrecarga de usá-la?

Use Thread.Sleepquando quiser bloquear o encadeamento atual.

Use Task.Delayquando desejar um atraso lógico sem bloquear o encadeamento atual.

A eficiência não deve ser uma preocupação primordial com esses métodos. Seu uso primário no mundo real é como temporizadores de repetição para operações de E / S, que são da ordem de segundos e não de milissegundos.

A maior diferença entre Task.Delaye Thread.Sleepé a Task.Delayintenção de executar de forma assíncrona. Não faz sentido usar Task.Delayno código síncrono. É uma péssima idéia usar Thread.Sleepno código assíncrono.

Normalmente você ligará Task.Delay() com a awaitpalavra-chave:

await Task.Delay(5000);

ou, se você deseja executar algum código antes do atraso:

var sw = new Stopwatch();
sw.Start();
Task delay = Task.Delay(5000);
Console.WriteLine("async: Running for {0} seconds", sw.Elapsed.TotalSeconds);
await delay;

Adivinha o que isso vai imprimir? Em execução por 0,0070048 segundos. Se movermos o await delayacima Console.WriteLine, em vez disso, ele imprimirá Running por 5.0020168 segundos.

Vejamos a diferença com Thread.Sleep:

class Program
{
    static void Main(string[] args)
    {
        Task delay = asyncTask();
        syncCode();
        delay.Wait();
        Console.ReadLine();
    }

    static async Task asyncTask()
    {
        var sw = new Stopwatch();
        sw.Start();
        Console.WriteLine("async: Starting");
        Task delay = Task.Delay(5000);
        Console.WriteLine("async: Running for {0} seconds", sw.Elapsed.TotalSeconds);
        await delay;
        Console.WriteLine("async: Running for {0} seconds", sw.Elapsed.TotalSeconds);
        Console.WriteLine("async: Done");
    }

    static void syncCode()
    {
        var sw = new Stopwatch();
        sw.Start();
        Console.WriteLine("sync: Starting");
        Thread.Sleep(5000);
        Console.WriteLine("sync: Running for {0} seconds", sw.Elapsed.TotalSeconds);
        Console.WriteLine("sync: Done");
    }
}

Tente prever o que isso imprimirá ...

assíncrono: Iniciando
assíncrono: executando por 0,0070048 segundos de
sincronização: Iniciando
assíncrono: executando por 5,0119008 segundos
assíncrono: concluído
sincronizado: executando por 5,0020168 segundos
sincronizado: concluído

Além disso, é interessante notar que Thread.Sleepé muito mais preciso, a precisão da ms não é realmente um problema, enquanto Task.Delaypode demorar 15 a 30 ms no mínimo. A sobrecarga em ambas as funções é mínima em comparação com a precisão de ms que elas possuem (use StopwatchClasse se precisar de algo mais preciso). Thread.Sleepainda amarra seu thread, Task.Delaysolte-o para fazer outro trabalho enquanto espera.

se o encadeamento atual for eliminado e você o usar Thread.Sleepe estiver em execução, poderá obter um ThreadAbortException. Com Task.Delayvocê, você sempre pode fornecer um token de cancelamento e matá-lo normalmente. Essa é uma razão que eu escolheria Task.Delay. consulte http://social.technet.microsoft.com/wiki/contents/articles/21177.visual-c-thread-sleep-vs-task-delay.aspx

Também concordo que a eficiência não é fundamental neste caso.

Eu quero adicionar algo. Na verdade, Task.Delayé um mecanismo de espera baseado em timer. Se você olhar para a fonte , encontrará uma referência a uma Timerclasse responsável pelo atraso. Por outro lado, Thread.Sleepna verdade, o encadeamento atual é interrompido, dessa maneira você está apenas bloqueando e desperdiçando um encadeamento. No modelo de programação assíncrona, você sempre deve usar Task.Delay()se desejar que algo (continuação) aconteça após algum atraso.