Task.Delay Metoda

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

Parametry

Návraty

Úkol, který představuje časové zpoždění.

Výjimky

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

Parametry

Návraty

Úkol, který představuje časové zpoždění.

Výjimky

Příklady

Následující příklad spustí úlohu, která obsahuje volání Delay(TimeSpan, CancellationToken) metody se zpožděním 1,5 sekundy. Před uplynutím intervalu zpoždění se token zruší. Výstup z příkladu ukazuje, že se v důsledku toho TaskCanceledException vyvolá objekt a vlastnost tasks je Status nastavená na Canceledhodnotu .

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

Všimněte si, že tento příklad zahrnuje potenciální konflikt časování: závisí na úkolu, který asynchronně spustí zpoždění při zrušení tokenu. Ačkoli zpoždění 1,5 sekundy od volání Delay(TimeSpan, CancellationToken) metody činí tento předpoklad pravděpodobný, je však možné, že volání Delay(TimeSpan, CancellationToken) metody může vrátit před zrušením tokenu. V takovém případě tento příklad vytvoří následující výstup:

Task t Status: RanToCompletion, Result: 42

Poznámky

Pokud se token zrušení signalizoval před určeným časovým zpožděním, dojde k výjimce TaskCanceledException a úloha se dokončí ve Canceled stavu . V opačném případě je úkol dokončen ve RanToCompletion stavu po uplynutí zadaného časového zpoždění.

Scénáře použití a další příklady najdete v dokumentaci k Delay(Int32) přetížení.

Tato metoda závisí na systémových hodinách. To znamená, že časové zpoždění bude přibližně odpovídat rozlišení systémových hodin, pokud delay je argument menší než rozlišení systémových hodin, což je v systémech Windows přibližně 15 milisekund.

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

Parametry

Návraty

Úkol, který představuje časové zpoždění.

Výjimky

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

Parametry

Návraty

Úkol, který představuje časové zpoždění.

Výjimky

Příklady

Následující příklad ukazuje jednoduché použití Delay metody .

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

Poznámky

Po uplynutí zadaného časového zpoždění je úkol dokončen ve RanToCompletion stavu .

Scénáře použití a další příklady najdete v dokumentaci k Delay(Int32) přetížení.

Tato metoda závisí na systémových hodinách. To znamená, že časové zpoždění bude přibližně odpovídat rozlišení systémových hodin, pokud delay je argument menší než rozlišení systémových hodin, což je v systémech Windows přibližně 15 milisekund.

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

Parametry

Návraty

Úkol, který představuje časové zpoždění.

Výjimky

Příklady

Následující příklad ukazuje jednoduché použití Delay metody .

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

Poznámky

Metoda se Delay obvykle používá ke zpoždění operace celé úlohy nebo její části o zadaný časový interval. Nejčastěji se časové zpoždění zavádí:

• Na začátku úlohy, jak ukazuje následující příklad.

  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
  

• Někdy během provádění úlohy. V tomto případě se Delay volání metody provede jako podřízená úloha v rámci úlohy, jak ukazuje následující příklad. Všimněte si, že vzhledem k tomu, že úloha, která volá metodu Delay , provádí asynchronně, musí nadřazená úloha čekat na dokončení pomocí klíčového await slova .

  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
  

Po uplynutí zadaného časového zpoždění se úkol dokončí ve RanToCompletion stavu .

Tato metoda závisí na systémových hodinách. To znamená, že časové zpoždění bude přibližně odpovídat rozlišení systémových hodin, pokud millisecondsDelay je argument menší než rozlišení systémových hodin, což je v systémech Windows přibližně 15 milisekund.

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

Parametry

Návraty

Úkol, který představuje časové zpoždění.

Výjimky

Příklady

Následující příklad spustí úlohu, která obsahuje volání Delay(Int32, CancellationToken) metody s jednosekundovým zpožděním. Před uplynutím intervalu zpoždění se token zruší. Výstup z příkladu ukazuje, že se v důsledku toho TaskCanceledException vyvolá objekt a vlastnost tasks je Status nastavená na Canceledhodnotu .

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

Poznámky

Pokud se token zrušení signalizoval před určeným časovým zpožděním, dojde k výjimce TaskCanceledException a úloha se dokončí ve Canceled stavu . V opačném případě je úkol dokončen ve RanToCompletion stavu po uplynutí zadaného časového zpoždění.

Scénáře použití a další příklady najdete v dokumentaci k Delay(Int32) přetížení.

Tato metoda závisí na systémových hodinách. To znamená, že časové zpoždění se bude přibližně rovnat rozlišení systémových hodin, pokud millisecondsDelay je argument menší než rozlišení systémových hodin, což je v systémech Windows přibližně 15 milisekund.