Task.Delay Metódus

Definíció

Névtér:: System.Threading.Tasks

Szerelvények:: mscorlib.dll, System.Threading.Tasks.dll

Szerelvények:: netstandard.dll, System.Runtime.dll

Szerelvény:: System.Threading.Tasks.dll

Szerelvény:: System.Runtime.dll

Szerelvény:: mscorlib.dll

Szerelvény:: netstandard.dll

Fontos

Egyes információk olyan, kiadás előtti termékekre vonatkoznak, amelyek a kiadásig még jelentősen módosulhatnak. A Microsoft nem vállal kifejezett vagy törvényi garanciát az itt megjelenő információért.

Létrehoz egy feladatot, amely egy idő után befejeződik.

Túlterhelések

Name	Description
Delay(Int32)	Létrehoz egy feladatot, amely meghatározott számú ezredmásodperc után fejeződik be.
Delay(TimeSpan)	Létrehoz egy feladatot, amely egy megadott időintervallum után fejeződik be.
Delay(Int32, CancellationToken)	Egy megszakítható feladatot hoz létre, amely meghatározott számú ezredmásodperc után fejeződik be.
Delay(TimeSpan, CancellationToken)	Egy megszakítható feladatot hoz létre, amely egy megadott időintervallum után fejeződik be.
Delay(TimeSpan, TimeProvider)	Létrehoz egy feladatot, amely egy megadott időintervallum után fejeződik be.
Delay(TimeSpan, TimeProvider, CancellationToken)	Egy megszakítható feladatot hoz létre, amely egy megadott időintervallum után fejeződik be.

Delay(Int32)

Forrás:: Task.cs

Forrás:: Task.cs

Forrás:: Task.cs

Forrás:: Task.cs

Forrás:: Task.cs

Létrehoz egy feladatot, amely meghatározott számú ezredmásodperc után fejeződik be.

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éterek

millisecondsDelay: Int32

A visszaadott feladat végrehajtása előtt várakozni kívánt ezredmásodpercek száma, vagy -1 határozatlan ideig várni.

Válaszok

Task

Az időkésésnek felel meg.

Kivételek

ArgumentOutOfRangeException

Az millisecondsDelay argumentum kisebb, mint -1.

Példák

Az alábbi példa a metódus egyszerű használatát Delay mutatja be.

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

Megjegyzések

A Delay metódust általában arra használják, hogy egy tevékenység egészének vagy egy részének műveletét késleltetje egy adott időintervallumra. Az idő késleltetése leggyakrabban a következő:

A feladat elején, ahogy az alábbi példa is mutatja.

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

Valamikor a feladat végrehajtása közben. Ebben az esetben a Delay metódus hívása gyermekfeladatként fut egy tevékenységen belül, ahogyan az az alábbi példában is látható. Vegye figyelembe, hogy mivel a metódust meghívó Delay tevékenység aszinkron módon fut, a szülő tevékenységnek meg kell várnia, amíg befejeződik a await kulcsszó használatával.

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

A megadott idő elteltével a tevékenység befejeződött az RanToCompletion állapotban.

Ez a módszer a rendszerórától függ. Ez azt jelenti, hogy az idő késleltetése körülbelül megegyezik a rendszeróra felbontásával, ha a millisecondsDelay argumentum kisebb, mint a rendszeróra felbontása, ami körülbelül 15 ezredmásodperc Windows rendszereken.

Note

A használt rendszeróra megegyezik a GetTickCount által használt órával, amelyet a timeBeginPeriod és a timeEndPeriod módosításai nem befolyásolnak.

A következőre érvényes:

Delay(TimeSpan)

Forrás:: Task.cs

Forrás:: Task.cs

Forrás:: Task.cs

Forrás:: Task.cs

Forrás:: Task.cs

Létrehoz egy feladatot, amely egy megadott időintervallum után fejeződik be.

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éterek

delay: TimeSpan

A visszaadott feladat végrehajtása előtt vagy Timeout.InfiniteTimeSpan határozatlan ideig tartó várakozási idő.

Válaszok

Task

Az időkésésnek felel meg.

Kivételek

ArgumentOutOfRangeException

delay a negatív időintervallumot jelöli, amely Timeout.InfiniteTimeSpannem a .

-vagy-

A delay argumentum TotalMilliseconds tulajdonsága nagyobb, mint 4294967294 .NET 6-os és újabb verziókban, vagy Int32.MaxValue az összes korábbi verzióban.

Példák

Az alábbi példa a metódus egyszerű használatát Delay mutatja be.

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

Megjegyzések

A megadott idő elteltével a tevékenység állapota befejeződött RanToCompletion .

Használati forgatókönyvekről és további példákról lásd a túlterhelés dokumentációját Delay(Int32) .

Ez a módszer a rendszerórától függ. Ez azt jelenti, hogy az idő késleltetése körülbelül megegyezik a rendszeróra felbontásával, ha a delay argumentum kisebb, mint a rendszeróra felbontása, ami körülbelül 15 ezredmásodperc Windows rendszereken.

Note

A használt rendszeróra megegyezik a GetTickCount által használt órával, amelyet a timeBeginPeriod és a timeEndPeriod módosításai nem befolyásolnak.

A következőre érvényes:

Delay(Int32, CancellationToken)

Forrás:: Task.cs

Forrás:: Task.cs

Forrás:: Task.cs

Forrás:: Task.cs

Forrás:: Task.cs

Egy megszakítható feladatot hoz létre, amely meghatározott számú ezredmásodperc után fejeződik be.

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éterek

millisecondsDelay: Int32

A visszaadott feladat végrehajtása előtt várakozni kívánt ezredmásodpercek száma, vagy -1 határozatlan ideig várni.

cancellationToken: CancellationToken

A tevékenység befejezésére váró lemondási jogkivonat.

Válaszok

Task

Az időkésésnek felel meg.

Kivételek

ArgumentOutOfRangeException

Az millisecondsDelay argumentum kisebb, mint -1.

OperationCanceledException

A feladat megszakadt. Ezt a kivételt a rendszer a visszaadott tevékenységben tárolja.

ObjectDisposedException

A megadottak cancellationToken már el lettek dobva.

TaskCanceledException

A feladat megszakadt.

Példák

Az alábbi példa egy olyan feladatot indít el, amely egy másodperces késéssel meghívja a Delay(Int32, CancellationToken) metódust. A késleltetési időköz eltelte előtt a jogkivonat megszakad. A példa kimenete azt mutatja, hogy ennek eredményeképpen egy TaskCanceledException lesz, és a tevékenységek tulajdonsága Status a következőre Canceledvan állítva.

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

Megjegyzések

Ha a lemondási jogkivonatot a megadott időkésés előtt jelzi a rendszer, kivétel TaskCanceledException jön létre, és a feladat az állapotban fejeződik be Canceled . Ellenkező esetben a feladat a megadott időkésés leteltét követően az állapotban RanToCompletion fejeződik be.

Használati forgatókönyvekről és további példákról lásd a túlterhelés dokumentációját Delay(Int32) .

Note

A használt rendszeróra megegyezik a GetTickCount által használt órával, amelyet a timeBeginPeriod és a timeEndPeriod módosításai nem befolyásolnak.

A következőre érvényes:

Delay(TimeSpan, CancellationToken)

Forrás:: Task.cs

Forrás:: Task.cs

Forrás:: Task.cs

Forrás:: Task.cs

Forrás:: Task.cs

Egy megszakítható feladatot hoz létre, amely egy megadott időintervallum után fejeződik be.

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éterek

delay: TimeSpan

A visszaadott feladat végrehajtása előtt vagy Timeout.InfiniteTimeSpan határozatlan ideig tartó várakozási idő.

cancellationToken: CancellationToken

A tevékenység befejezésére váró lemondási jogkivonat.

Válaszok

Task

Az időkésésnek felel meg.

Kivételek

ArgumentOutOfRangeException

delay a negatív időintervallumot jelöli, amely Timeout.InfiniteTimeSpannem a .

-vagy-

A delay argumentum TotalMilliseconds tulajdonsága nagyobb, mint 4294967294 .NET 6-os és újabb verziókban, vagy Int32.MaxValue az összes korábbi verzióban.

OperationCanceledException

A feladat megszakadt. Ezt a kivételt a rendszer a visszaadott tevékenységben tárolja.

ObjectDisposedException

A megadottak cancellationToken már el lettek dobva.

TaskCanceledException

A feladat megszakadt.

Példák

Az alábbi példa egy olyan feladatot indít el, amely 1,5 másodperces késleltetéssel meghívja a Delay(TimeSpan, CancellationToken) metódust. A késleltetési időköz eltelte előtt a jogkivonat megszakad. A példa kimenete azt mutatja, hogy ennek eredményeképpen egy TaskCanceledException lesz, és a tevékenységek tulajdonsága Status a következőre Canceledvan állítva.

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

Vegye figyelembe, hogy ez a példa tartalmaz egy lehetséges versenyfeltételt: attól függ, hogy a tevékenység aszinkron módon hajtja végre a késést a jogkivonat törlésekor. Bár a metódus felé irányuló hívás 1,5 másodperces késleltetése valószínűvé teszi ezt a Delay(TimeSpan, CancellationToken) feltételezést, mégis lehetséges, hogy a metódus hívása Delay(TimeSpan, CancellationToken) vissza tud térni a jogkivonat törlése előtt. Ebben az esetben a példa a következő kimenetet hozza létre:

Task t Status: RanToCompletion, Result: 42

Megjegyzések

Használati forgatókönyvekről és további példákról lásd a túlterhelés dokumentációját Delay(Int32) .

Note

A használt rendszeróra megegyezik a GetTickCount által használt órával, amelyet a timeBeginPeriod és a timeEndPeriod módosításai nem befolyásolnak.

A következőre érvényes:

Delay(TimeSpan, TimeProvider)

Forrás:: Task.cs

Forrás:: Task.cs

Forrás:: Task.cs

Forrás:: Task.cs

Létrehoz egy feladatot, amely egy megadott időintervallum után fejeződik be.

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éterek

delay: TimeSpan

A TimeSpan visszaadott feladat végrehajtása előtt várakozni kell, vagy InfiniteTimeSpan határozatlan ideig várni.

timeProvider: TimeProvider

Az TimeProvider , amellyel értelmezni delaykell .

Válaszok

Task

Az időkésésnek felel meg.

Kivételek

ArgumentOutOfRangeException

delay a negatív időintervallumot jelöli, amely InfiniteTimeSpannem a .

-vagy-

delay'tulajdonsága TotalMilliseconds nagyobb, mint 4294967294.

ArgumentNullException

Az timeProvider argumentum a következő null: .

A következőre érvényes:

Delay(TimeSpan, TimeProvider, CancellationToken)

Forrás:: Task.cs

Forrás:: Task.cs

Forrás:: Task.cs

Forrás:: Task.cs

Egy megszakítható feladatot hoz létre, amely egy megadott időintervallum után fejeződik be.

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éterek

delay: TimeSpan

A TimeSpan visszaadott feladat végrehajtása előtt várakozni kell, vagy InfiniteTimeSpan határozatlan ideig várni.

timeProvider: TimeProvider

Az TimeProvider , amellyel értelmezni delaykell .

cancellationToken: CancellationToken

A tevékenység befejezésére váró lemondási jogkivonat.

Válaszok

Task

Az időkésésnek felel meg.

Kivételek

ArgumentOutOfRangeException

delay a negatív időintervallumot jelöli, amely InfiniteTimeSpannem a .

-vagy-

delay'tulajdonsága TotalMilliseconds nagyobb, mint 4294967294.

ArgumentNullException

Az timeProvider argumentum a következő null: .

OperationCanceledException

A lemondási jogkivonat megszakadt. Ezt a kivételt a rendszer a visszaadott tevékenységben tárolja.

A következőre érvényes:

Visszajelzés

Hasznosnak találta ezt az oldalt?