Task.Delay Méthode

Référence

Définition

Espace de noms:: System.Threading.Tasks

Assembly:: System.Runtime.dll

Assembly:: System.Threading.Tasks.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Important

Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.

Crée une tâche qui ne se termine qu'après un certain délai.

Surcharges

Delay(TimeSpan, TimeProvider, CancellationToken)	Crée une tâche pouvant être annulée qui se termine après un intervalle de temps spécifié.
Delay(TimeSpan, CancellationToken)	Crée une tâche pouvant être annulée qui se termine après un intervalle de temps spécifié.
Delay(TimeSpan, TimeProvider)	Crée une tâche qui se termine après un intervalle de temps spécifié.
Delay(TimeSpan)	Crée une tâche qui se termine après un intervalle de temps spécifié.
Delay(Int32)	Crée une tâche qui se termine après un nombre spécifié de millisecondes.
Delay(Int32, CancellationToken)	Crée une tâche pouvant être annulée qui se termine après un nombre spécifié de millisecondes.

Delay(TimeSpan, TimeProvider, CancellationToken)

Crée une tâche pouvant être annulée qui se termine après un intervalle de temps spécifié.

public:
 static System::Threading::Tasks::Task ^ Delay(TimeSpan delay, TimeProvider ^ timeProvider, System::Threading::CancellationToken cancellationToken);

public static System.Threading.Tasks.Task Delay (TimeSpan delay, TimeProvider timeProvider, System.Threading.CancellationToken cancellationToken);

static member Delay : TimeSpan * TimeProvider * System.Threading.CancellationToken -> System.Threading.Tasks.Task

Public Shared Function Delay (delay As TimeSpan, timeProvider As TimeProvider, cancellationToken As CancellationToken) As Task

Paramètres

delay: TimeSpan

TimeSpan à attendre avant d’effectuer la tâche retournée, ou InfiniteTimeSpan à attendre indéfiniment.

timeProvider: TimeProvider

TimeProvider avec lequel interpréter delay.

cancellationToken: CancellationToken

Jeton d’annulation à observer en attendant que la tâche se termine.

Retours

Task

Tâche qui représente le délai.

Exceptions

ArgumentOutOfRangeException

delay représente un intervalle de temps négatif autre que InfiniteTimeSpan.

- ou -

delayest TotalMilliseconds supérieur à 4294967294.

ArgumentNullException

L'argument timeProvider a la valeur null.

S’applique à

Delay(TimeSpan, CancellationToken)

Crée une tâche pouvant être annulée qui se termine après un intervalle de temps spécifié.

public:
 static System::Threading::Tasks::Task ^ Delay(TimeSpan delay, System::Threading::CancellationToken cancellationToken);

public static System.Threading.Tasks.Task Delay (TimeSpan delay, System.Threading.CancellationToken cancellationToken);

static member Delay : TimeSpan * System.Threading.CancellationToken -> System.Threading.Tasks.Task

Public Shared Function Delay (delay As TimeSpan, cancellationToken As CancellationToken) As Task

Paramètres

delay: TimeSpan

Intervalle de temps à attendre avant la fin de la tâche retournée ou Timeout.InfiniteTimeSpan pour attendre indéfiniment.

cancellationToken: CancellationToken

Jeton d’annulation à observer en attendant que la tâche se termine.

Retours

Task

Tâche qui représente le délai.

Exceptions

ArgumentOutOfRangeException

delay représente un intervalle de temps négatif autre que Timeout.InfiniteTimeSpan.

- ou -

La delay propriété de l’argument TotalMilliseconds est supérieure à 4294967294 sur .NET 6 et versions ultérieures, ou à Int32.MaxValue sur toutes les versions précédentes.

TaskCanceledException

La tâche a été annulée.

ObjectDisposedException

Le cancellationToken fourni a déjà été supprimé.

Exemples

L’exemple suivant lance une tâche qui inclut un appel à la Delay(TimeSpan, CancellationToken) méthode avec un délai de 1,5 seconde. Avant l’expiration de l’intervalle de délai, le jeton est annulé. La sortie de l’exemple montre que, par conséquent, un TaskCanceledException est levée et que la propriété des Status tâches a la valeur Canceled.

using System;
using System.Threading;
using System.Threading.Tasks;

public class Example
{
   public static void Main()
   {
      CancellationTokenSource source = new CancellationTokenSource();

      var t = Task.Run(async delegate
              {
                 await Task.Delay(TimeSpan.FromSeconds(1.5), source.Token);
                 return 42;
              });
      source.Cancel();
      try {
         t.Wait();
      }
      catch (AggregateException ae) {
         foreach (var e in ae.InnerExceptions)
            Console.WriteLine("{0}: {1}", e.GetType().Name, e.Message);
      }
      Console.Write("Task t Status: {0}", t.Status);
      if (t.Status == TaskStatus.RanToCompletion)
         Console.Write(", Result: {0}", t.Result);
      source.Dispose();
   }
}
// The example displays output like the following:
//       TaskCanceledException: A task was canceled.
//       Task t Status: Canceled

open System
open System.Threading
open System.Threading.Tasks

let source = new CancellationTokenSource()

let t =
    Task.Run<int>(fun () ->
        task {

            do! Task.Delay(TimeSpan.FromSeconds(1.5), source.Token)
            return 42
        })

source.Cancel()

try
    t.Wait()

with :? AggregateException as ae ->
    for e in ae.InnerExceptions do
        printfn $"{e.GetType().Name}: {e.Message}"

printf $"Task t Status: {t.Status}"

if t.Status = TaskStatus.RanToCompletion then
    printf $", Result: {t.Result}"

source.Dispose()

// The example displays output like the following:
//       TaskCanceledException: A task was canceled.
//       Task t Status: Canceled

Imports System.Threading
Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      Dim source As New CancellationTokenSource()
      
      Dim t = Task.Run(Async Function()
                                Await Task.Delay(TimeSpan.FromSeconds(1.5),
                                                 source.Token)
                                Return 42
                       End Function)
      source.Cancel()
      Try
         t.Wait()
      Catch ae As AggregateException
         For Each e In ae.InnerExceptions
            Console.WriteLine("{0}: {1}", e.GetType().Name, e.Message)
         Next
      End Try
      Console.Write("Task t Status: {0}", t.Status)
      If t.Status = TaskStatus.RanToCompletion Then
         Console.Write(", Result: {0}", t.Result)
      End If
      source.Dispose()
   End Sub
End Module
' The example displays output like the following:
'       TaskCanceledException: A task was canceled.
'       Task t Status: Canceled

Notez que cet exemple inclut une condition de concurrence potentielle : elle dépend de l’exécution asynchrone par la tâche du délai d’annulation du jeton. Bien que le délai de 1,5 seconde entre l’appel à la Delay(TimeSpan, CancellationToken) méthode rend cette hypothèse probable, il est néanmoins possible que l’appel à la Delay(TimeSpan, CancellationToken) méthode puisse retourner avant l’annulation du jeton. Dans ce cas, l’exemple produit la sortie suivante :

Task t Status: RanToCompletion, Result: 42

Remarques

Si le jeton d’annulation est signalé avant le délai spécifié, une TaskCanceledException exception se produit et la tâche est terminée dans l’état Canceled . Sinon, la tâche est terminée dans l’état RanToCompletion une fois le délai spécifié écoulé.

Pour obtenir des scénarios d’utilisation et des exemples supplémentaires, consultez la documentation relative à la Delay(Int32) surcharge.

Cette méthode dépend de l’horloge système. Cela signifie que le délai est approximativement égal à la résolution de l’horloge système si l’argument delay est inférieur à la résolution de l’horloge système, qui est d’environ 15 millisecondes sur les systèmes Windows.

Notes

L’horloge système utilisée est la même horloge que celle utilisée par GetTickCount, qui n’est pas affectée par les modifications apportées avec timeBeginPeriod et timeEndPeriod.

S’applique à

Delay(TimeSpan, TimeProvider)

Crée une tâche qui se termine après un intervalle de temps spécifié.

public:
 static System::Threading::Tasks::Task ^ Delay(TimeSpan delay, TimeProvider ^ timeProvider);

public static System.Threading.Tasks.Task Delay (TimeSpan delay, TimeProvider timeProvider);

static member Delay : TimeSpan * TimeProvider -> System.Threading.Tasks.Task

Public Shared Function Delay (delay As TimeSpan, timeProvider As TimeProvider) As Task

Paramètres

delay: TimeSpan

TimeSpan à attendre avant d’effectuer la tâche retournée, ou InfiniteTimeSpan à attendre indéfiniment.

timeProvider: TimeProvider

TimeProvider avec lequel interpréter delay.

Retours

Task

Tâche qui représente le délai.

Exceptions

ArgumentOutOfRangeException

delay représente un intervalle de temps négatif autre que InfiniteTimeSpan.

- ou -

delayest TotalMilliseconds supérieur à 4294967294.

ArgumentNullException

L'argument timeProvider a la valeur null.

S’applique à

Delay(TimeSpan)

Crée une tâche qui se termine après un intervalle de temps spécifié.

public:
 static System::Threading::Tasks::Task ^ Delay(TimeSpan delay);

public static System.Threading.Tasks.Task Delay (TimeSpan delay);

static member Delay : TimeSpan -> System.Threading.Tasks.Task

Public Shared Function Delay (delay As TimeSpan) As Task

Paramètres

delay: TimeSpan

Intervalle de temps à attendre avant la fin de la tâche retournée ou Timeout.InfiniteTimeSpan pour attendre indéfiniment.

Retours

Task

Tâche qui représente le délai.

Exceptions

ArgumentOutOfRangeException

delay représente un intervalle de temps négatif autre que Timeout.InfiniteTimeSpan.

- ou -

La delay propriété de l’argument TotalMilliseconds est supérieure à 4294967294 sur .NET 6 et versions ultérieures, ou à Int32.MaxValue sur toutes les versions précédentes.

Exemples

L’exemple suivant illustre une utilisation simple de la Delay méthode .

using System;
using System.Threading.Tasks;

public class Example
{
   public static void Main()
   {
      var t = Task.Run(async delegate
              {
                 await Task.Delay(TimeSpan.FromSeconds(1.5));
                 return 42;
              });
      t.Wait();
      Console.WriteLine("Task t Status: {0}, Result: {1}",
                        t.Status, t.Result);
   }
}
// The example displays the following output:
//        Task t Status: RanToCompletion, Result: 42

open System
open System.Threading.Tasks

let t =
    Task.Run<int>(fun () ->
        task {
            do! Task.Delay(TimeSpan.FromSeconds 1.5)
            return 42
        })

t.Wait()
printfn $"Task t Status: {t.Status}, Result: {t.Result}"

// The example displays the following output:
//        Task t Status: RanToCompletion, Result: 42

Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      Dim t = Task.Run(Async Function()
                                Await Task.Delay(TimeSpan.FromSeconds(1.5))
                                Return 42
                       End Function)
      t.Wait()
      Console.WriteLine("Task t Status: {0}, Result: {1}",
                        t.Status, t.Result)
   End Sub
End Module
' The example displays the following output:
'       Task t Status: RanToCompletion, Result: 42

Remarques

Après le délai spécifié, la tâche est terminée dans RanToCompletion l’état .

Pour obtenir des scénarios d’utilisation et des exemples supplémentaires, consultez la documentation relative à la Delay(Int32) surcharge.

Notes

L’horloge système utilisée est la même horloge que celle utilisée par GetTickCount, qui n’est pas affectée par les modifications apportées avec timeBeginPeriod et timeEndPeriod.

S’applique à

Delay(Int32)

Crée une tâche qui se termine après un nombre spécifié de millisecondes.

public:
 static System::Threading::Tasks::Task ^ Delay(int millisecondsDelay);

public static System.Threading.Tasks.Task Delay (int millisecondsDelay);

static member Delay : int -> System.Threading.Tasks.Task

Public Shared Function Delay (millisecondsDelay As Integer) As Task

Paramètres

millisecondsDelay: Int32

Nombre de millisecondes à attendre avant la fin de la tâche retournée ou -1 pour attendre indéfiniment.

Retours

Task

Tâche qui représente le délai.

Exceptions

ArgumentOutOfRangeException

L’argument millisecondsDelay est inférieur à -1.

Exemples

L’exemple suivant illustre une utilisation simple de la Delay méthode .

using System;
using System.Threading.Tasks;

public class Example
{
   public static void Main()
   {
      var t = Task.Run(async delegate
              {
                 await Task.Delay(1000);
                 return 42;
              });
      t.Wait();
      Console.WriteLine("Task t Status: {0}, Result: {1}",
                        t.Status, t.Result);
   }
}
// The example displays the following output:
//        Task t Status: RanToCompletion, Result: 42

open System.Threading.Tasks

let t =
    Task.Run<int>(fun () ->
        task {
            do! Task.Delay 1000
            return 42
        })

t.Wait()
printfn $"Task t Status: {t.Status}, Result: {t.Result}"

// The example displays the following output:
//        Task t Status: RanToCompletion, Result: 42

Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      Dim t = Task.Run(Async Function()
                                Await Task.Delay(1000)
                                Return 42
                       End Function)
      t.Wait()
      Console.WriteLine("Task t Status: {0}, Result: {1}",
                        t.Status, t.Result)
   End Sub
End Module
' The example displays the following output:
'       Task t Status: RanToCompletion, Result: 42

Remarques

La Delay méthode est généralement utilisée pour retarder l’opération de la totalité ou d’une partie d’une tâche pendant un intervalle de temps spécifié. Le plus souvent, le délai est introduit :

Au début de la tâche, comme le montre l’exemple suivant.

Stopwatch sw = Stopwatch.StartNew();
var delay = Task.Delay(1000).ContinueWith(_ =>
                           { sw.Stop();
                             return sw.ElapsedMilliseconds; } );

Console.WriteLine("Elapsed milliseconds: {0}", delay.Result);
// The example displays output like the following:
//        Elapsed milliseconds: 1013

    let sw = Stopwatch.StartNew()

    let delay =
        Task
            .Delay(1000)
            .ContinueWith(fun _ ->
                sw.Stop()
                sw.ElapsedMilliseconds)

    printfn $"Elapsed milliseconds: {delay.Result}"
// The example displays output like the following:
//        Elapsed milliseconds: 1013

Dim sw As Stopwatch = Stopwatch.StartNew()
Dim delay1 = Task.Delay(1000)
Dim delay2 = delay1.ContinueWith( Function(antecedent)
                        sw.Stop()
                        Return sw.ElapsedMilliseconds
                      End Function)

Console.WriteLine("Elapsed milliseconds: {0}", delay2.Result)
' The example displays output like the following:
'        Elapsed milliseconds: 1013

Parfois pendant l’exécution de la tâche. Dans ce cas, l’appel à la Delay méthode s’exécute en tant que tâche enfant au sein d’une tâche, comme le montre l’exemple suivant. Notez que, étant donné que la tâche qui appelle la Delay méthode s’exécute de façon asynchrone, la tâche parente doit attendre qu’elle se termine à l’aide de la await mot clé.

var delay = Task.Run( async () => { Stopwatch sw = Stopwatch.StartNew();
                                    await Task.Delay(2500);
                                    sw.Stop();
                                    return sw.ElapsedMilliseconds; });

Console.WriteLine("Elapsed milliseconds: {0}", delay.Result);
// The example displays output like the following:
//        Elapsed milliseconds: 2501

    let delay =
        Task.Run<int64>(fun () ->
            task {
                let sw = Stopwatch.StartNew()
                do! Task.Delay 2500
                sw.Stop()
                return sw.ElapsedMilliseconds
            })

    printfn $"Elapsed milliseconds: {delay.Result}"
// The example displays output like the following:
//        Elapsed milliseconds: 2501

Dim delay = Task.Run( Async Function()
                         Dim sw As Stopwatch = Stopwatch.StartNew()
                         Await Task.Delay(2500)
                         sw.Stop()
                         Return sw.ElapsedMilliseconds
                      End Function )

Console.WriteLine("Elapsed milliseconds: {0}", delay.Result)
' The example displays output like the following:
'        Elapsed milliseconds: 2501

Après le délai spécifié, la tâche est terminée dans l’état RanToCompletion .

Cette méthode dépend de l’horloge système. Cela signifie que le délai est approximativement égal à la résolution de l’horloge système si l’argument millisecondsDelay est inférieur à la résolution de l’horloge système, qui est d’environ 15 millisecondes sur les systèmes Windows.

Notes

L’horloge système utilisée est la même horloge que celle utilisée par GetTickCount, qui n’est pas affectée par les modifications apportées avec timeBeginPeriod et timeEndPeriod.

S’applique à

Delay(Int32, CancellationToken)

Crée une tâche pouvant être annulée qui se termine après un nombre spécifié de millisecondes.

public:
 static System::Threading::Tasks::Task ^ Delay(int millisecondsDelay, System::Threading::CancellationToken cancellationToken);

public static System.Threading.Tasks.Task Delay (int millisecondsDelay, System.Threading.CancellationToken cancellationToken);

static member Delay : int * System.Threading.CancellationToken -> System.Threading.Tasks.Task

Public Shared Function Delay (millisecondsDelay As Integer, cancellationToken As CancellationToken) As Task

Paramètres

millisecondsDelay: Int32

Nombre de millisecondes à attendre avant la fin de la tâche retournée ou -1 pour attendre indéfiniment.

cancellationToken: CancellationToken

Jeton d’annulation à observer en attendant que la tâche se termine.

Retours

Task

Tâche qui représente le délai.

Exceptions

ArgumentOutOfRangeException

L’argument millisecondsDelay est inférieur à -1.

TaskCanceledException

La tâche a été annulée.

ObjectDisposedException

Le cancellationToken fourni a déjà été supprimé.

Exemples

L’exemple suivant lance une tâche qui inclut un appel à la Delay(Int32, CancellationToken) méthode avec un délai d’une seconde. Avant l’expiration de l’intervalle de délai, le jeton est annulé. La sortie de l’exemple montre que, par conséquent, un TaskCanceledException est levée et que la propriété des Status tâches a la valeur Canceled.

using System;
using System.Threading;
using System.Threading.Tasks;

public class Example
{
   public static void Main()
   {
      CancellationTokenSource source = new CancellationTokenSource();

      var t = Task.Run(async delegate
              {
                 await Task.Delay(1000, source.Token);
                 return 42;
              });
      source.Cancel();
      try {
         t.Wait();
      }
      catch (AggregateException ae) {
         foreach (var e in ae.InnerExceptions)
            Console.WriteLine("{0}: {1}", e.GetType().Name, e.Message);
      }
      Console.Write("Task t Status: {0}", t.Status);
      if (t.Status == TaskStatus.RanToCompletion)
         Console.Write(", Result: {0}", t.Result);
      source.Dispose();
   }
}
// The example displays the following output:
//       TaskCanceledException: A task was canceled.
//       Task t Status: Canceled

open System
open System.Threading
open System.Threading.Tasks

let source = new CancellationTokenSource()

let t =
    Task.Run<int>(fun () ->
        task {
            do! Task.Delay(1000, source.Token)
            return 42
        })

source.Cancel()

try
    t.Wait()

with :? AggregateException as ae ->
    for e in ae.InnerExceptions do
        printfn $"{e.GetType().Name}: {e.Message}"

printf $"Task t Status: {t.Status}"

if t.Status = TaskStatus.RanToCompletion then
    printf $", Result: {t.Result}"

source.Dispose()


// The example displays the following output:
//       TaskCanceledException: A task was canceled.
//       Task t Status: Canceled

Imports System.Threading
Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      Dim source As New CancellationTokenSource()
      
      Dim t = Task.Run(Async Function()
                                Await Task.Delay(1000, source.Token)
                                Return 42
                       End Function)
      source.Cancel()
      Try
         t.Wait()
      Catch ae As AggregateException
         For Each e In ae.InnerExceptions
            Console.WriteLine("{0}: {1}", e.GetType().Name, e.Message)
         Next
      End Try
      Console.Write("Task t Status: {0}", t.Status)
      If t.Status = TaskStatus.RanToCompletion Then
         Console.Write(", Result: {0}", t.Result)
      End If
      source.Dispose()
   End Sub
End Module
' The example displays the following output:
'       TaskCanceledException: A task was canceled.
'       Task t Status: Canceled

Remarques

Pour obtenir des scénarios d’utilisation et des exemples supplémentaires, consultez la documentation relative à la Delay(Int32) surcharge.

Notes

L’horloge système utilisée est la même horloge que celle utilisée par GetTickCount, qui n’est pas affectée par les modifications apportées avec timeBeginPeriod et timeEndPeriod.

S’applique à

Task.Delay Méthode

Définition

Surcharges

Delay(TimeSpan, TimeProvider, CancellationToken)

Paramètres

Retours

Exceptions

S’applique à

Delay(TimeSpan, CancellationToken)

Paramètres

Retours

Exceptions

Exemples

Remarques

S’applique à

Delay(TimeSpan, TimeProvider)

Paramètres

Retours

Exceptions

S’applique à

Delay(TimeSpan)

Paramètres

Retours

Exceptions

Exemples

Remarques

S’applique à

Delay(Int32)

Paramètres

Retours

Exceptions

Exemples

Remarques

S’applique à

Delay(Int32, CancellationToken)

Paramètres

Retours

Exceptions

Exemples

Remarques

S’applique à

Ressources supplémentaires