Task.Delay 方法

参考

定义

命名空间:: System.Threading.Tasks

程序集:: System.Runtime.dll

程序集:: System.Threading.Tasks.dll

程序集:: mscorlib.dll

程序集:: netstandard.dll

重要

一些信息与预发行产品相关，相应产品在发行之前可能会进行重大修改。对于此处提供的信息，Microsoft 不作任何明示或暗示的担保。

创建将在时间延迟后完成的任务。

重载

Delay(TimeSpan, TimeProvider, CancellationToken)	创建一个在指定的时间间隔后完成的可取消任务。
Delay(TimeSpan, CancellationToken)	创建一个在指定的时间间隔后完成的可取消任务。
Delay(TimeSpan, TimeProvider)	创建一个在指定的时间间隔后完成的任务。
Delay(TimeSpan)	创建一个在指定的时间间隔后完成的任务。
Delay(Int32)	创建一个在指定的毫秒数后完成的任务。
Delay(Int32, CancellationToken)	创建一个在指定的毫秒数后完成的可取消任务。

Delay(TimeSpan, TimeProvider, CancellationToken)

Source:: Task.cs

Source:: Task.cs

创建一个在指定的时间间隔后完成的可取消任务。

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

参数

delay: TimeSpan

在 TimeSpan 完成返回的任务之前要等待的，或 InfiniteTimeSpan 无限期等待的。

timeProvider: TimeProvider

用于 TimeProvider 解释 delay的。

cancellationToken: CancellationToken

等待任务完成期间要观察的取消标记。

Task

表示时间延迟的任务。

例外

ArgumentOutOfRangeException

delay 表示除 InfiniteTimeSpan 以外的负时间间隔。

- 或 -

delayTotalMilliseconds的属性大于 4294967294。

ArgumentNullException

timeProvider 参数为 null。

OperationCanceledException

取消令牌已取消。此异常存储在返回的任务中。

适用于

Delay(TimeSpan, CancellationToken)

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

创建一个在指定的时间间隔后完成的可取消任务。

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

参数

delay: TimeSpan

在完成返回的任务前等待的时间跨度；如果无限期等待，则为 Timeout.InfiniteTimeSpan。

cancellationToken: CancellationToken

等待任务完成期间要观察的取消标记。

Task

表示时间延迟的任务。

例外

ArgumentOutOfRangeException

delay 表示除 Timeout.InfiniteTimeSpan 以外的负时间间隔。

- 或 -

参数 delay 的 TotalMilliseconds 属性在 .NET 6 及更高版本上大于 4294967294，或在所有早期版本上大于 Int32.MaxValue 。

OperationCanceledException

该任务已取消。此异常存储在返回的任务中。

ObjectDisposedException

已释放提供的 cancellationToken。

示例

以下示例启动一个任务，该任务包括对 Delay(TimeSpan, CancellationToken) 方法的调用，延迟为 1.5 秒。在延迟间隔过前，将取消令牌。该示例的输出显示，因此 TaskCanceledException ，将引发，并且任务的 Status 属性设置为 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

请注意，此示例包含一个潜在的争用条件：它取决于任务在取消令牌时异步执行延迟。尽管从调用 Delay(TimeSpan, CancellationToken) 方法开始的 1.5 秒延迟使得这一假设成为可能，但对方法的调用 Delay(TimeSpan, CancellationToken) 可能会在取消令牌之前返回。在这种情况下，该示例生成以下输出：

Task t Status: RanToCompletion, Result: 42

注解

如果在指定的时间延迟之前发出取消标记信号，则 TaskCanceledException 会导致异常，并且任务处于 Canceled 完成状态。否则，在指定的时间延迟过后，任务以状态完成 RanToCompletion 。

有关使用方案和其他示例，请参阅重载的文档 Delay(Int32) 。

此方法取决于系统时钟。这意味着，如果 delay 参数小于系统时钟的分辨率（在 Windows 系统上大约为 15 毫秒），则时间延迟大约等于系统时钟的分辨率。

注意

所使用的系统时钟与 GetTickCount 使用的时钟相同，不受 timeBeginPeriod 和 timeEndPeriod 所做的更改的影响。

适用于

Delay(TimeSpan, TimeProvider)

Source:: Task.cs

Source:: Task.cs

创建一个在指定的时间间隔后完成的任务。

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

参数

delay: TimeSpan

在 TimeSpan 完成返回的任务之前要等待的，或 InfiniteTimeSpan 无限期等待的。

timeProvider: TimeProvider

用于 TimeProvider 解释 delay的。

Task

表示时间延迟的任务。

例外

ArgumentOutOfRangeException

delay 表示除 InfiniteTimeSpan 以外的负时间间隔。

- 或 -

delayTotalMilliseconds的属性大于 4294967294。

ArgumentNullException

timeProvider 参数为 null。

适用于

Delay(TimeSpan)

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

创建一个在指定的时间间隔后完成的任务。

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

参数

delay: TimeSpan

在完成返回的任务前等待的时间跨度；如果无限期等待，则为 Timeout.InfiniteTimeSpan。

Task

表示时间延迟的任务。

例外

ArgumentOutOfRangeException

delay 表示除 Timeout.InfiniteTimeSpan 以外的负时间间隔。

- 或 -

参数 delay 的 TotalMilliseconds 属性在 .NET 6 及更高版本上大于 4294967294，或在所有早期版本上大于 Int32.MaxValue 。

示例

以下示例演示方法的 Delay 简单用法。

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

注解

在指定的时间延迟后，任务处于 RanToCompletion 完成状态。

有关使用方案和其他示例，请参阅重载的文档 Delay(Int32) 。

注意

所使用的系统时钟与 GetTickCount 使用的时钟相同，不受 timeBeginPeriod 和 timeEndPeriod 所做的更改的影响。

适用于

Delay(Int32)

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

创建一个在指定的毫秒数后完成的任务。

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

参数

millisecondsDelay: Int32

在完成返回的任务前要等待的毫秒数；如果无限期等待，则为 -1。

Task

表示时间延迟的任务。

例外

ArgumentOutOfRangeException

millisecondsDelay 参数小于 -1。

示例

以下示例演示方法的 Delay 简单用法。

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

注解

方法 Delay 通常用于在指定的时间间隔内延迟全部或部分任务的操作。最常见的是引入时间延迟：

在任务开始时，如以下示例所示。

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

任务正在执行的某个时间。在这种情况下，对 Delay 方法的调用将作为任务中的子任务执行，如以下示例所示。请注意，由于调用 Delay 方法的任务以异步方式执行，因此父任务必须使用关键字 (keyword) 等待它完成await。

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

在指定的时间延迟后，任务以状态 RanToCompletion 完成。

此方法取决于系统时钟。这意味着，如果 millisecondsDelay 参数小于系统时钟的分辨率（在 Windows 系统上大约为 15 毫秒），则时间延迟大约等于系统时钟的分辨率。

注意

所使用的系统时钟与 GetTickCount 使用的时钟相同，不受 timeBeginPeriod 和 timeEndPeriod 所做的更改的影响。

适用于

Delay(Int32, CancellationToken)

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

创建一个在指定的毫秒数后完成的可取消任务。

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

参数

millisecondsDelay: Int32

在完成返回的任务前要等待的毫秒数；如果无限期等待，则为 -1。

cancellationToken: CancellationToken

等待任务完成期间要观察的取消标记。

Task

表示时间延迟的任务。

例外

ArgumentOutOfRangeException

millisecondsDelay 参数小于 -1。

OperationCanceledException

该任务已取消。此异常存储在返回的任务中。

ObjectDisposedException

已释放提供的 cancellationToken。

示例

以下示例启动一个任务，该任务包含对 Delay(Int32, CancellationToken) 方法的调用，但延迟为一秒。在延迟间隔过前，将取消令牌。该示例的输出显示，因此 TaskCanceledException ，将引发，并且任务的 Status 属性设置为 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

注解

有关使用方案和其他示例，请参阅重载的文档 Delay(Int32) 。

此方法取决于系统时钟。这意味着，如果 millisecondsDelay 参数小于系统时钟的分辨率（在 Windows 系统上大约为 15 毫秒），则时间延迟将大致等于系统时钟的分辨率。

注意

所使用的系统时钟与 GetTickCount 使用的时钟相同，不受 timeBeginPeriod 和 timeEndPeriod 所做的更改的影响。

适用于

Task.Delay 方法

定义

重载

Delay(TimeSpan, TimeProvider, CancellationToken)

参数

返回

例外

适用于

Delay(TimeSpan, CancellationToken)

参数

返回

例外

示例

注解

适用于

Delay(TimeSpan, TimeProvider)

参数

返回

例外

适用于

Delay(TimeSpan)

参数

返回

例外

示例

注解

适用于

Delay(Int32)

参数

返回

例外

示例

注解

适用于

Delay(Int32, CancellationToken)

参数

返回

例外

示例

注解

适用于

反馈

其他资源