Task.Delay Metod

Definition

Namnområde:: System.Threading.Tasks

Sammansättningar:: mscorlib.dll, System.Threading.Tasks.dll

Sammansättningar:: netstandard.dll, System.Runtime.dll

Sammansättning:: System.Threading.Tasks.dll

Sammansättning:: System.Runtime.dll

Sammansättning:: mscorlib.dll

Sammansättning:: netstandard.dll

Viktigt

En del information gäller för förhandsversionen av en produkt och kan komma att ändras avsevärt innan produkten blir allmänt tillgänglig. Microsoft lämnar inga garantier, uttryckliga eller underförstådda, avseende informationen som visas här.

Skapar en uppgift som ska slutföras efter en tidsfördröjning.

Överlagringar

Name	Description
Delay(Int32)	Skapar en uppgift som slutförs efter ett angivet antal millisekunder.
Delay(TimeSpan)	Skapar en aktivitet som slutförs efter ett angivet tidsintervall.
Delay(Int32, CancellationToken)	Skapar en cancellable-uppgift som slutförs efter ett angivet antal millisekunder.
Delay(TimeSpan, CancellationToken)	Skapar en cancellable-uppgift som slutförs efter ett angivet tidsintervall.
Delay(TimeSpan, TimeProvider)	Skapar en aktivitet som slutförs efter ett angivet tidsintervall.
Delay(TimeSpan, TimeProvider, CancellationToken)	Skapar en cancellable-uppgift som slutförs efter ett angivet tidsintervall.

Delay(Int32)

Källa:: Task.cs

Källa:: Task.cs

Källa:: Task.cs

Källa:: Task.cs

Källa:: Task.cs

Skapar en uppgift som slutförs efter ett angivet antal millisekunder.

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

Parametrar

millisecondsDelay: Int32

Antalet millisekunder som ska vänta innan den returnerade aktiviteten slutförs eller -1 vänta på obestämd tid.

Returer

Task

En uppgift som representerar tidsfördröjningen.

Undantag

ArgumentOutOfRangeException

Argumentet millisecondsDelay är mindre än -1.

Exempel

I följande exempel visas en enkel användning av Delay metoden.

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

Kommentarer

Metoden Delay används vanligtvis för att fördröja åtgärden för hela eller delar av en aktivitet under ett angivet tidsintervall. Oftast introduceras tidsfördröjningen:

I början av aktiviteten, som i följande exempel visas.

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ågon gång medan uppgiften körs. I det här fallet körs anropet till metoden som en underordnad Delay uppgift i en aktivitet, som i följande exempel visas. Observera att eftersom aktiviteten som anropar Delay metoden körs asynkront måste den överordnade aktiviteten vänta tills den har slutförts med hjälp av nyckelordet 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

Efter den angivna tidsfördröjningen slutförs aktiviteten i tillståndet RanToCompletion .

Den här metoden beror på systemklockan. Det innebär att tidsfördröjningen ungefär motsvarar systemklockans upplösning om argumentet millisecondsDelay är mindre än systemklockans upplösning, vilket är cirka 15 millisekunder på Windows system.

Note

Systemklockan som används är samma klocka som används av GetTickCount, som inte påverkas av ändringar som gjorts med timeBeginPeriod och timeEndPeriod.

Gäller för

Delay(TimeSpan)

Källa:: Task.cs

Källa:: Task.cs

Källa:: Task.cs

Källa:: Task.cs

Källa:: Task.cs

Skapar en aktivitet som slutförs efter ett angivet tidsintervall.

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

Parametrar

delay: TimeSpan

Tidsintervallet för att vänta innan den returnerade aktiviteten slutförs eller Timeout.InfiniteTimeSpan för att vänta på obestämd tid.

Returer

Task

En uppgift som representerar tidsfördröjningen.

Undantag

ArgumentOutOfRangeException

delay representerar ett annat negativt tidsintervall än Timeout.InfiniteTimeSpan.

-eller-

Argumentet delayTotalMilliseconds är större än 4294967294 på .NET 6 och senare versioner, eller Int32.MaxValue på alla tidigare versioner.

Exempel

I följande exempel visas en enkel användning av Delay metoden.

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

Kommentarer

Efter den angivna tidsfördröjningen slutförs aktiviteten i RanToCompletion tillståndet .

Information om användningsscenarier och ytterligare exempel finns i dokumentationen för överlagringen Delay(Int32) .

Den här metoden beror på systemklockan. Det innebär att tidsfördröjningen ungefär motsvarar systemklockans upplösning om argumentet delay är mindre än systemklockans upplösning, vilket är cirka 15 millisekunder på Windows system.

Note

Systemklockan som används är samma klocka som används av GetTickCount, som inte påverkas av ändringar som gjorts med timeBeginPeriod och timeEndPeriod.

Gäller för

Delay(Int32, CancellationToken)

Källa:: Task.cs

Källa:: Task.cs

Källa:: Task.cs

Källa:: Task.cs

Källa:: Task.cs

Skapar en cancellable-uppgift som slutförs efter ett angivet antal millisekunder.

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

Parametrar

millisecondsDelay: Int32

Antalet millisekunder som ska vänta innan den returnerade aktiviteten slutförs eller -1 vänta på obestämd tid.

cancellationToken: CancellationToken

En annulleringstoken som ska observeras i väntan på att aktiviteten ska slutföras.

Returer

Task

En uppgift som representerar tidsfördröjningen.

Undantag

ArgumentOutOfRangeException

Argumentet millisecondsDelay är mindre än -1.

OperationCanceledException

Uppgiften har avbrutits. Det här undantaget lagras i den returnerade aktiviteten.

ObjectDisposedException

Den angivna cancellationToken har redan tagits bort.

TaskCanceledException

Uppgiften har avbrutits.

Exempel

I följande exempel startas en uppgift som innehåller ett anrop till Delay(Int32, CancellationToken) metoden med en sekunds fördröjning. Innan fördröjningsintervallet förflutit avbryts token. Utdata från exemplet visar att som ett resultat genereras en TaskCanceledException och uppgiftens Status egenskap är inställd på 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

Kommentarer

Om annulleringstoken signaleras före den angivna tidsfördröjningen resulterar ett TaskCanceledException undantag och aktiviteten slutförs i tillståndet Canceled . Annars slutförs aktiviteten i RanToCompletion tillståndet när den angivna tidsfördröjningen har förflutit.

Information om användningsscenarier och ytterligare exempel finns i dokumentationen för överlagringen Delay(Int32) .

Note

Systemklockan som används är samma klocka som används av GetTickCount, som inte påverkas av ändringar som gjorts med timeBeginPeriod och timeEndPeriod.

Gäller för

Delay(TimeSpan, CancellationToken)

Källa:: Task.cs

Källa:: Task.cs

Källa:: Task.cs

Källa:: Task.cs

Källa:: Task.cs

Skapar en cancellable-uppgift som slutförs efter ett angivet tidsintervall.

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

Parametrar

delay: TimeSpan

Tidsintervallet för att vänta innan den returnerade aktiviteten slutförs eller Timeout.InfiniteTimeSpan för att vänta på obestämd tid.

cancellationToken: CancellationToken

En annulleringstoken som ska observeras i väntan på att aktiviteten ska slutföras.

Returer

Task

En uppgift som representerar tidsfördröjningen.

Undantag

ArgumentOutOfRangeException

delay representerar ett annat negativt tidsintervall än Timeout.InfiniteTimeSpan.

-eller-

Argumentet delayTotalMilliseconds är större än 4294967294 på .NET 6 och senare versioner, eller Int32.MaxValue på alla tidigare versioner.

OperationCanceledException

Uppgiften har avbrutits. Det här undantaget lagras i den returnerade aktiviteten.

ObjectDisposedException

Den angivna cancellationToken har redan tagits bort.

TaskCanceledException

Uppgiften har avbrutits.

Exempel

I följande exempel startas en uppgift som innehåller ett anrop till Delay(TimeSpan, CancellationToken) metoden med en fördröjning på 1,5 sekunder. Innan fördröjningsintervallet förflutit avbryts token. Utdata från exemplet visar att som ett resultat genereras en TaskCanceledException och uppgiftens Status egenskap är inställd på 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

Observera att det här exemplet innehåller ett potentiellt konkurrenstillstånd: det beror på att aktiviteten asynkront kör fördröjningen när token avbryts. Även om fördröjningen på 1,5 sekunder från anropet Delay(TimeSpan, CancellationToken) till metoden gör det antagandet troligt, är det ändå möjligt att anropet Delay(TimeSpan, CancellationToken) till metoden kan returneras innan token avbryts. I så fall genererar exemplet följande utdata:

Task t Status: RanToCompletion, Result: 42

Kommentarer

Information om användningsscenarier och ytterligare exempel finns i dokumentationen för överlagringen Delay(Int32) .

Note

Systemklockan som används är samma klocka som används av GetTickCount, som inte påverkas av ändringar som gjorts med timeBeginPeriod och timeEndPeriod.

Gäller för

Delay(TimeSpan, TimeProvider)

Källa:: Task.cs

Källa:: Task.cs

Källa:: Task.cs

Källa:: Task.cs

Skapar en aktivitet som slutförs efter ett angivet tidsintervall.

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

Parametrar

delay: TimeSpan

Att TimeSpan vänta innan den returnerade uppgiften slutförs eller InfiniteTimeSpan att vänta på obestämd tid.

timeProvider: TimeProvider

Med TimeProvider vilken du ska tolka delay.

Returer

Task

En uppgift som representerar tidsfördröjningen.

Undantag

ArgumentOutOfRangeException

delay representerar ett annat negativt tidsintervall än InfiniteTimeSpan.

-eller-

delayegenskapen TotalMilliseconds är större än 4294967294.

ArgumentNullException

Argumentet timeProvider är null.

Gäller för

Delay(TimeSpan, TimeProvider, CancellationToken)

Källa:: Task.cs

Källa:: Task.cs

Källa:: Task.cs

Källa:: Task.cs

Skapar en cancellable-uppgift som slutförs efter ett angivet tidsintervall.

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

Parametrar

delay: TimeSpan

Att TimeSpan vänta innan den returnerade uppgiften slutförs eller InfiniteTimeSpan att vänta på obestämd tid.

timeProvider: TimeProvider

Med TimeProvider vilken du ska tolka delay.

cancellationToken: CancellationToken

En annulleringstoken som ska observeras i väntan på att aktiviteten ska slutföras.

Returer

Task

En uppgift som representerar tidsfördröjningen.

Undantag

ArgumentOutOfRangeException

delay representerar ett annat negativt tidsintervall än InfiniteTimeSpan.

-eller-

delayegenskapen TotalMilliseconds är större än 4294967294.

ArgumentNullException

Argumentet timeProvider är null.

OperationCanceledException

Annulleringstoken avbröts. Det här undantaget lagras i den returnerade aktiviteten.

Gäller för

Feedback

Var den här sidan till hjälp?