Task.Delay Metodo

Riferimento

Definizione

Spazio dei nomi:: System.Threading.Tasks

Assembly:: System.Threading.Tasks.dll

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Importante

Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.

Crea un'attività che verrà completata dopo un ritardo di tempo.

Overload

Delay(Int32)	Crea un'attività che viene completata dopo un numero specificato di millisecondi.
Delay(TimeSpan)	Crea un'attività che viene completata dopo un intervallo di tempo specificato.
Delay(Int32, CancellationToken)	Crea un'attività annullabile che viene completata dopo un numero specificato di millisecondi.
Delay(TimeSpan, CancellationToken)	Crea un'attività annullabile che viene completata dopo un intervallo di tempo specificato.
Delay(TimeSpan, TimeProvider)	Crea un'attività che viene completata dopo un intervallo di tempo specificato.
Delay(TimeSpan, TimeProvider, CancellationToken)	Crea un'attività annullabile che viene completata dopo un intervallo di tempo specificato.

Delay(Int32)

Origine:: Task.cs

Origine:: Task.cs

Origine:: Task.cs

Crea un'attività che viene completata dopo un numero specificato di millisecondi.

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

Parametri

millisecondsDelay: Int32

Numero di millisecondi di attesa prima di completare l'attività restituita o -1 attendere per un periodo illimitato.

Restituisce

Task

Attività che rappresenta il ritardo di tempo.

Eccezioni

ArgumentOutOfRangeException

L'argomento millisecondsDelay è minore di -1.

Esempio

Nell'esempio seguente viene illustrato un semplice utilizzo del metodo 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

Commenti

Il metodo Delay viene in genere usato per ritardare l'operazione di tutte o parte di un'attività per un intervallo di tempo specificato. Più comunemente, viene introdotto il ritardo di tempo:

All'inizio dell'attività, come illustrato nell'esempio seguente.

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

Tempo durante l'esecuzione dell'attività. In questo caso, la chiamata al metodo Delay viene eseguita come attività figlio all'interno di un'attività, come illustrato nell'esempio seguente. Si noti che poiché l'attività che chiama il metodo Delay viene eseguita in modo asincrono, l'attività padre deve attendere il completamento usando la parola chiave 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

Dopo il ritardo di tempo specificato, l'attività viene completata nello stato RanToCompletion.

Questo metodo dipende dall'orologio di sistema. Ciò significa che il ritardo di tempo sarà approssimativamente uguale alla risoluzione dell'orologio di sistema se l'argomento millisecondsDelay è minore della risoluzione dell'orologio di sistema, che è di circa 15 millisecondi nei sistemi Windows.

Nota

L'orologio di sistema utilizzato è lo stesso orologio usato da GetTickCount, che non è interessato dalle modifiche apportate con timeBeginPeriod e timeEndPeriod.

Si applica a

Delay(TimeSpan)

Origine:: Task.cs

Origine:: Task.cs

Origine:: Task.cs

Crea un'attività che viene completata dopo un intervallo di tempo specificato.

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

Parametri

delay: TimeSpan

Intervallo di tempo di attesa prima di completare l'attività restituita o Timeout.InfiniteTimeSpan attendere per un periodo illimitato.

Restituisce

Task

Attività che rappresenta il ritardo di tempo.

Eccezioni

ArgumentOutOfRangeException

delay rappresenta un intervallo di tempo negativo diverso da Timeout.InfiniteTimeSpan.

-o-

La proprietà TotalMilliseconds dell'argomento delay è maggiore di 4294967294 in .NET 6 e versioni successive oppure Int32.MaxValue in tutte le versioni precedenti.

Esempio

Nell'esempio seguente viene illustrato un semplice utilizzo del metodo 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

Commenti

Dopo il ritardo di tempo specificato, l'attività viene completata nello stato RanToCompletion.

Per gli scenari di utilizzo e altri esempi, vedere la documentazione relativa all'overload Delay(Int32).

Questo metodo dipende dall'orologio di sistema. Ciò significa che il ritardo di tempo sarà approssimativamente uguale alla risoluzione dell'orologio di sistema se l'argomento delay è minore della risoluzione dell'orologio di sistema, che è di circa 15 millisecondi nei sistemi Windows.

Nota

L'orologio di sistema utilizzato è lo stesso orologio usato da GetTickCount, che non è interessato dalle modifiche apportate con timeBeginPeriod e timeEndPeriod.

Si applica a

Delay(Int32, CancellationToken)

Origine:: Task.cs

Origine:: Task.cs

Origine:: Task.cs

Crea un'attività annullabile che viene completata dopo un numero specificato di millisecondi.

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

Parametri

millisecondsDelay: Int32

Numero di millisecondi di attesa prima di completare l'attività restituita o -1 attendere per un periodo illimitato.

cancellationToken: CancellationToken

Token di annullamento da osservare durante l'attesa del completamento dell'attività.

Restituisce

Task

Attività che rappresenta il ritardo di tempo.

Eccezioni

ArgumentOutOfRangeException

L'argomento millisecondsDelay è minore di -1.

OperationCanceledException

L'attività è stata annullata. Questa eccezione viene archiviata nell'attività restituita.

ObjectDisposedException

Il cancellationToken specificato è già stato eliminato.

TaskCanceledException

L'attività è stata annullata.

Esempio

Nell'esempio seguente viene avviata un'attività che include una chiamata al metodo Delay(Int32, CancellationToken) con un secondo ritardo. Prima della scadenza dell'intervallo di ritardo, il token viene annullato. L'output dell'esempio mostra che, di conseguenza, viene generata una TaskCanceledException e la proprietà Status delle attività viene impostata su 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

Commenti

Se il token di annullamento viene segnalato prima del ritardo di tempo specificato, viene restituita un'eccezione TaskCanceledException e l'attività viene completata nello stato Canceled. In caso contrario, l'attività viene completata nello stato RanToCompletion una volta trascorso il ritardo di tempo specificato.

Per gli scenari di utilizzo e altri esempi, vedere la documentazione relativa all'overload Delay(Int32).

Nota

L'orologio di sistema utilizzato è lo stesso orologio usato da GetTickCount, che non è interessato dalle modifiche apportate con timeBeginPeriod e timeEndPeriod.

Si applica a

Delay(TimeSpan, CancellationToken)

Origine:: Task.cs

Origine:: Task.cs

Origine:: Task.cs

Crea un'attività annullabile che viene completata dopo un intervallo di tempo specificato.

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

Parametri

delay: TimeSpan

Intervallo di tempo di attesa prima di completare l'attività restituita o Timeout.InfiniteTimeSpan attendere per un periodo illimitato.

cancellationToken: CancellationToken

Token di annullamento da osservare durante l'attesa del completamento dell'attività.

Restituisce

Task

Attività che rappresenta il ritardo di tempo.

Eccezioni

ArgumentOutOfRangeException

delay rappresenta un intervallo di tempo negativo diverso da Timeout.InfiniteTimeSpan.

-o-

La proprietà TotalMilliseconds dell'argomento delay è maggiore di 4294967294 in .NET 6 e versioni successive oppure Int32.MaxValue in tutte le versioni precedenti.

OperationCanceledException

L'attività è stata annullata. Questa eccezione viene archiviata nell'attività restituita.

ObjectDisposedException

Il cancellationToken specificato è già stato eliminato.

TaskCanceledException

L'attività è stata annullata.

Esempio

Nell'esempio seguente viene avviata un'attività che include una chiamata al metodo Delay(TimeSpan, CancellationToken) con un ritardo di 1,5 secondi. Prima della scadenza dell'intervallo di ritardo, il token viene annullato. L'output dell'esempio mostra che, di conseguenza, viene generata una TaskCanceledException e la proprietà Status delle attività viene impostata su 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

Si noti che questo esempio include una potenziale race condition: dipende dall'attività che esegue in modo asincrono il ritardo quando il token viene annullato. Anche se il ritardo di 1,5 secondi dalla chiamata al metodo Delay(TimeSpan, CancellationToken) rende probabile tale presupposto, è tuttavia possibile che la chiamata al metodo Delay(TimeSpan, CancellationToken) possa restituire prima che il token venga annullato. In tal caso, l'esempio produce l'output seguente:

Task t Status: RanToCompletion, Result: 42

Commenti

Per gli scenari di utilizzo e altri esempi, vedere la documentazione relativa all'overload Delay(Int32).

Questo metodo dipende dall'orologio di sistema. Ciò significa che il ritardo di tempo sarà approssimativamente uguale alla risoluzione dell'orologio di sistema se l'argomento delay è minore della risoluzione dell'orologio di sistema, che è di circa 15 millisecondi nei sistemi Windows.

Nota

L'orologio di sistema utilizzato è lo stesso orologio usato da GetTickCount, che non è interessato dalle modifiche apportate con timeBeginPeriod e timeEndPeriod.

Si applica a

Delay(TimeSpan, TimeProvider)

Origine:: Task.cs

Origine:: Task.cs

Crea un'attività che viene completata dopo un intervallo di tempo specificato.

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

Parametri

delay: TimeSpan

Il TimeSpan di attesa prima di completare l'attività restituita o InfiniteTimeSpan attendere per un periodo illimitato.

timeProvider: TimeProvider

TimeProvider con cui interpretare delay.

Restituisce

Task

Attività che rappresenta il ritardo di tempo.

Eccezioni

ArgumentOutOfRangeException

delay rappresenta un intervallo di tempo negativo diverso da InfiniteTimeSpan.

-o-

la proprietà TotalMilliseconds di delayè maggiore di 4294967294.

ArgumentNullException

L'argomento timeProvider è null.

Si applica a

Delay(TimeSpan, TimeProvider, CancellationToken)

Origine:: Task.cs

Origine:: Task.cs

Crea un'attività annullabile che viene completata dopo un intervallo di tempo specificato.

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

Parametri

delay: TimeSpan

Il TimeSpan di attesa prima di completare l'attività restituita o InfiniteTimeSpan attendere per un periodo illimitato.

timeProvider: TimeProvider

TimeProvider con cui interpretare delay.

cancellationToken: CancellationToken

Token di annullamento da osservare durante l'attesa del completamento dell'attività.

Restituisce

Task

Attività che rappresenta il ritardo di tempo.

Eccezioni

ArgumentOutOfRangeException

delay rappresenta un intervallo di tempo negativo diverso da InfiniteTimeSpan.

-o-

la proprietà TotalMilliseconds di delayè maggiore di 4294967294.

ArgumentNullException

L'argomento timeProvider è null.

OperationCanceledException

Il token di annullamento è stato annullato. Questa eccezione viene archiviata nell'attività restituita.

Si applica a

Condividi tramite

Task.Delay Metodo

Definizione

Overload

Delay(Int32)

Parametri

Restituisce

Eccezioni

Esempio

Commenti

Si applica a

Delay(TimeSpan)

Parametri

Restituisce

Eccezioni

Esempio

Commenti

Si applica a

Delay(Int32, CancellationToken)

Parametri

Restituisce

Eccezioni

Esempio

Commenti

Si applica a

Delay(TimeSpan, CancellationToken)

Parametri

Restituisce

Eccezioni

Esempio

Commenti

Si applica a

Delay(TimeSpan, TimeProvider)

Parametri

Restituisce

Eccezioni

Si applica a

Delay(TimeSpan, TimeProvider, CancellationToken)

Parametri

Restituisce

Eccezioni

Si applica a

Commenti e suggerimenti

Risorse aggiuntive