Teilen über


Task.Delay Methode

Definition

Erstellt eine Aufgabe, die nach einer Zeitverzögerung abgeschlossen wird.

Überlädt

Delay(Int32)

Erstellt eine Aufgabe, die nach einer angegebenen Anzahl von Millisekunden abgeschlossen wird.

Delay(TimeSpan)

Erstellt eine Aufgabe, die nach einem angegebenen Zeitintervall abgeschlossen wird.

Delay(Int32, CancellationToken)

Erstellt einen abbruchfähigen Vorgang, der nach einer angegebenen Anzahl von Millisekunden abgeschlossen wird.

Delay(TimeSpan, CancellationToken)

Erstellt einen abbruchfähigen Vorgang, der nach einem angegebenen Zeitintervall abgeschlossen wird.

Delay(TimeSpan, TimeProvider)

Erstellt eine Aufgabe, die nach einem angegebenen Zeitintervall abgeschlossen wird.

Delay(TimeSpan, TimeProvider, CancellationToken)

Erstellt einen abbruchfähigen Vorgang, der nach einem angegebenen Zeitintervall abgeschlossen wird.

Delay(Int32)

Quelle:
Task.cs
Quelle:
Task.cs
Quelle:
Task.cs

Erstellt eine Aufgabe, die nach einer angegebenen Anzahl von Millisekunden abgeschlossen wird.

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

Parameter

millisecondsDelay
Int32

Die Anzahl der Millisekunden, die gewartet werden sollen, bevor der zurückgegebene Vorgang abgeschlossen wird, oder -1 auf unbestimmte Zeit warten.

Gibt zurück

Eine Aufgabe, die die Zeitverzögerung darstellt.

Ausnahmen

Das argument millisecondsDelay ist kleiner als -1.

Beispiele

Das folgende Beispiel zeigt eine einfache Verwendung der Delay-Methode.

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

Hinweise

Die Delay-Methode wird in der Regel verwendet, um den Vorgang aller oder eines Teils eines Vorgangs für ein bestimmtes Zeitintervall zu verzögern. Am häufigsten wird die Zeitverzögerung eingeführt:

  • Am Anfang des Vorgangs, wie im folgenden Beispiel gezeigt.

    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
    
  • Einige Zeit während der Ausführung der Aufgabe. In diesem Fall wird der Aufruf der Delay-Methode als untergeordnete Aufgabe innerhalb einer Aufgabe ausgeführt, wie im folgenden Beispiel gezeigt. Da die Aufgabe, die die Delay-Methode aufruft, asynchron ausgeführt wird, muss die übergeordnete Aufgabe warten, bis sie mit dem schlüsselwort await abgeschlossen ist.

    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
    

Nach der angegebenen Zeitverzögerung wird der Vorgang im zustand RanToCompletion abgeschlossen.

Diese Methode hängt von der Systemuhr ab. Dies bedeutet, dass die Zeitverzögerung ungefähr der Auflösung der Systemuhr entspricht, wenn das argument millisecondsDelay kleiner als die Auflösung der Systemuhr ist, was ungefähr 15 Millisekunden auf Windows-Systemen ist.

Anmerkung

Die verwendete Systemuhr ist die gleiche Uhr, die von GetTickCountverwendet wird, die nicht von Änderungen betroffen ist, die mit timeBeginPeriod und timeEndPeriodvorgenommen wurden.

Gilt für:

Delay(TimeSpan)

Quelle:
Task.cs
Quelle:
Task.cs
Quelle:
Task.cs

Erstellt eine Aufgabe, die nach einem angegebenen Zeitintervall abgeschlossen wird.

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

Parameter

delay
TimeSpan

Die Zeitspanne, die gewartet werden soll, bevor die zurückgegebene Aufgabe abgeschlossen wird, oder Timeout.InfiniteTimeSpan auf unbestimmte Zeit warten.

Gibt zurück

Eine Aufgabe, die die Zeitverzögerung darstellt.

Ausnahmen

delay stellt ein anderes als Timeout.InfiniteTimeSpannegatives Zeitintervall dar.

-oder-

Die TotalMilliseconds-Eigenschaft des delay Arguments ist in .NET 6 und höheren Versionen größer als 4294967294, oder Int32.MaxValue- für alle vorherigen Versionen.

Beispiele

Das folgende Beispiel zeigt eine einfache Verwendung der Delay-Methode.

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

Hinweise

Nach der angegebenen Zeitverzögerung wird der Vorgang im zustand RanToCompletion abgeschlossen.

Nutzungsszenarien und zusätzliche Beispiele finden Sie in der Dokumentation für die Delay(Int32) Überladung.

Diese Methode hängt von der Systemuhr ab. Dies bedeutet, dass die Zeitverzögerung ungefähr der Auflösung der Systemuhr entspricht, wenn das argument delay kleiner als die Auflösung der Systemuhr ist, was ungefähr 15 Millisekunden auf Windows-Systemen ist.

Anmerkung

Die verwendete Systemuhr ist die gleiche Uhr, die von GetTickCountverwendet wird, die nicht von Änderungen betroffen ist, die mit timeBeginPeriod und timeEndPeriodvorgenommen wurden.

Gilt für:

Delay(Int32, CancellationToken)

Quelle:
Task.cs
Quelle:
Task.cs
Quelle:
Task.cs

Erstellt einen abbruchfähigen Vorgang, der nach einer angegebenen Anzahl von Millisekunden abgeschlossen wird.

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

Parameter

millisecondsDelay
Int32

Die Anzahl der Millisekunden, die gewartet werden sollen, bevor der zurückgegebene Vorgang abgeschlossen wird, oder -1 auf unbestimmte Zeit warten.

cancellationToken
CancellationToken

Ein Abbruchtoken, das beim Warten auf den Abschluss der Aufgabe beobachtet werden soll.

Gibt zurück

Eine Aufgabe, die die Zeitverzögerung darstellt.

Ausnahmen

Das argument millisecondsDelay ist kleiner als -1.

Die Aufgabe wurde abgebrochen. Diese Ausnahme wird in der zurückgegebenen Aufgabe gespeichert.

Die bereitgestellte cancellationToken wurde bereits verworfen.

Die Aufgabe wurde abgebrochen.

Beispiele

Im folgenden Beispiel wird eine Aufgabe gestartet, die einen Aufruf der Delay(Int32, CancellationToken)-Methode mit einer Verzögerung von einer Sekunde enthält. Bevor das Verzögerungsintervall verstrichen ist, wird das Token abgebrochen. Die Ausgabe aus dem Beispiel zeigt, dass ein TaskCanceledException ausgelöst wird und die Status-Eigenschaft der Vorgänge auf Canceledfestgelegt ist.

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

Hinweise

Wenn das Abbruchtoken vor der angegebenen Zeitverzögerung signalisiert wird, wird eine TaskCanceledException Ausnahme erzielt, und die Aufgabe wird im Canceled Zustand abgeschlossen. Andernfalls wird der Vorgang im zustand RanToCompletion abgeschlossen, sobald die angegebene Zeitverzögerung abgelaufen ist.

Nutzungsszenarien und zusätzliche Beispiele finden Sie in der Dokumentation für die Delay(Int32) Überladung.

Diese Methode hängt von der Systemuhr ab. Dies bedeutet, dass die Zeitverzögerung ungefähr der Auflösung der Systemuhr entspricht, wenn das argument millisecondsDelay kleiner als die Auflösung der Systemuhr ist, was ungefähr 15 Millisekunden auf Windows-Systemen ist.

Anmerkung

Die verwendete Systemuhr ist die gleiche Uhr, die von GetTickCountverwendet wird, die nicht von Änderungen betroffen ist, die mit timeBeginPeriod und timeEndPeriodvorgenommen wurden.

Gilt für:

Delay(TimeSpan, CancellationToken)

Quelle:
Task.cs
Quelle:
Task.cs
Quelle:
Task.cs

Erstellt einen abbruchfähigen Vorgang, der nach einem angegebenen Zeitintervall abgeschlossen wird.

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

Parameter

delay
TimeSpan

Die Zeitspanne, die gewartet werden soll, bevor die zurückgegebene Aufgabe abgeschlossen wird, oder Timeout.InfiniteTimeSpan auf unbestimmte Zeit warten.

cancellationToken
CancellationToken

Ein Abbruchtoken, das beim Warten auf den Abschluss der Aufgabe beobachtet werden soll.

Gibt zurück

Eine Aufgabe, die die Zeitverzögerung darstellt.

Ausnahmen

delay stellt ein anderes als Timeout.InfiniteTimeSpannegatives Zeitintervall dar.

-oder-

Die TotalMilliseconds-Eigenschaft des delay Arguments ist in .NET 6 und höheren Versionen größer als 4294967294, oder Int32.MaxValue- für alle vorherigen Versionen.

Die Aufgabe wurde abgebrochen. Diese Ausnahme wird in der zurückgegebenen Aufgabe gespeichert.

Die bereitgestellte cancellationToken wurde bereits verworfen.

Die Aufgabe wurde abgebrochen.

Beispiele

Im folgenden Beispiel wird eine Aufgabe gestartet, die einen Aufruf der Delay(TimeSpan, CancellationToken)-Methode mit einer Verzögerung von 1,5 Sekunden enthält. Bevor das Verzögerungsintervall verstrichen ist, wird das Token abgebrochen. Die Ausgabe aus dem Beispiel zeigt, dass ein TaskCanceledException ausgelöst wird und die Status-Eigenschaft der Vorgänge auf Canceledfestgelegt ist.

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

Beachten Sie, dass dieses Beispiel eine potenzielle Racebedingung enthält: Es hängt von der asynchronen Ausführung der Verzögerung ab, wenn das Token abgebrochen wird. Obwohl die Verzögerung von 1,5 Sekunden vom Aufruf an die Delay(TimeSpan, CancellationToken)-Methode diese Annahme wahrscheinlich macht, ist es dennoch möglich, dass der Aufruf der Delay(TimeSpan, CancellationToken)-Methode zurückgegeben werden kann, bevor das Token abgebrochen wird. In diesem Fall erzeugt das Beispiel die folgende Ausgabe:

Task t Status: RanToCompletion, Result: 42

Hinweise

Wenn das Abbruchtoken vor der angegebenen Zeitverzögerung signalisiert wird, wird eine TaskCanceledException Ausnahme erzielt, und die Aufgabe wird im Canceled Zustand abgeschlossen. Andernfalls wird der Vorgang im zustand RanToCompletion abgeschlossen, sobald die angegebene Zeitverzögerung abgelaufen ist.

Nutzungsszenarien und zusätzliche Beispiele finden Sie in der Dokumentation für die Delay(Int32) Überladung.

Diese Methode hängt von der Systemuhr ab. Dies bedeutet, dass die Zeitverzögerung ungefähr der Auflösung der Systemuhr entspricht, wenn das argument delay kleiner als die Auflösung der Systemuhr ist, was ungefähr 15 Millisekunden auf Windows-Systemen ist.

Anmerkung

Die verwendete Systemuhr ist die gleiche Uhr, die von GetTickCountverwendet wird, die nicht von Änderungen betroffen ist, die mit timeBeginPeriod und timeEndPeriodvorgenommen wurden.

Gilt für:

Delay(TimeSpan, TimeProvider)

Quelle:
Task.cs
Quelle:
Task.cs

Erstellt eine Aufgabe, die nach einem angegebenen Zeitintervall abgeschlossen wird.

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

Parameter

delay
TimeSpan

Die TimeSpan warten, bevor die zurückgegebene Aufgabe abgeschlossen wird, oder InfiniteTimeSpan auf unbestimmte Zeit warten.

timeProvider
TimeProvider

Die TimeProvider, mit der delayinterpretiert werden soll.

Gibt zurück

Eine Aufgabe, die die Zeitverzögerung darstellt.

Ausnahmen

delay stellt ein anderes als InfiniteTimeSpannegatives Zeitintervall dar.

-oder-

delay TotalMilliseconds Eigenschaft ist größer als 4294967294.

Das argument timeProvider ist null.

Gilt für:

Delay(TimeSpan, TimeProvider, CancellationToken)

Quelle:
Task.cs
Quelle:
Task.cs

Erstellt einen abbruchfähigen Vorgang, der nach einem angegebenen Zeitintervall abgeschlossen wird.

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

Parameter

delay
TimeSpan

Die TimeSpan warten, bevor die zurückgegebene Aufgabe abgeschlossen wird, oder InfiniteTimeSpan auf unbestimmte Zeit warten.

timeProvider
TimeProvider

Die TimeProvider, mit der delayinterpretiert werden soll.

cancellationToken
CancellationToken

Ein Abbruchtoken, das beim Warten auf den Abschluss der Aufgabe beobachtet werden soll.

Gibt zurück

Eine Aufgabe, die die Zeitverzögerung darstellt.

Ausnahmen

delay stellt ein anderes als InfiniteTimeSpannegatives Zeitintervall dar.

-oder-

delay TotalMilliseconds Eigenschaft ist größer als 4294967294.

Das argument timeProvider ist null.

Das Abbruchtoken wurde abgebrochen. Diese Ausnahme wird in der zurückgegebenen Aufgabe gespeichert.

Gilt für: