Task 클래스

정의

비동기 작업을 나타냅니다.Represents an asynchronous operation.

public ref class Task : IAsyncResult
public ref class Task : IAsyncResult, IDisposable
public class Task : IAsyncResult
public class Task : IAsyncResult, IDisposable
type Task = class
    interface IAsyncResult
type Task = class
    interface IAsyncResult
    interface IDisposable
Public Class Task
Implements IAsyncResult
Public Class Task
Implements IAsyncResult, IDisposable
상속
Task
파생
구현

설명

Task클래스는 값을 반환 하지 않고 비동기적으로 실행 되는 단일 작업을 나타냅니다.The Task class represents a single operation that does not return a value and that usually executes asynchronously. Task 개체는 .NET Framework 4에서 처음 도입 된 작업 기반 비동기 패턴 의 중심 구성 요소 중 하나입니다.Task objects are one of the central components of the task-based asynchronous pattern first introduced in the .NET Framework 4. 작업을 수행 하므로 Task 개체 일반적으로 비동기적으로 실행 스레드 풀 스레드에서 동기적으로 주 애플리케이션 스레드에서 사용할 수 있습니다 것이 아니라 합니다 Status 속성인 뿐만 IsCanceled, IsCompleted, 및 IsFaulted 속성에는 작업의 상태를 확인 합니다.Because the work performed by a Task object typically executes asynchronously on a thread pool thread rather than synchronously on the main application thread, you can use the Status property, as well as the IsCanceled, IsCompleted, and IsFaulted properties, to determine the state of a task. 가장 일반적으로 람다 식은 태스크에서 수행할 작업을 지정 하는 데 사용 됩니다.Most commonly, a lambda expression is used to specify the work that the task is to perform.

값을 반환 하는 작업의 경우 클래스를 사용 Task<TResult> 합니다.For operations that return values, you use the Task<TResult> class.

이 섹션의 내용은 다음과 같습니다.In this section:

작업 인스턴스화 예제 Task instantiation examples
작업 만들기 및 실행 Creating and executing a task
작업 만들기 및 실행 분리 Separating task creation and execution
하나 이상의 작업이 완료 될 때까지 기다리는 중 Waiting for one or more tasks to complete
작업 및 문화권 Tasks and culture
디버거 개발자 용For debugger developers

작업 인스턴스화Task instantiation

다음 예에서는 네 가지 작업을 만들고 실행 합니다.The following example creates and executes four tasks. 세 개의 작업은 Action<T> action 형식의 인수를 허용 하는 라는 대리자를 실행 Object 합니다.Three tasks execute an Action<T> delegate named action, which accepts an argument of type Object. 네 번째 작업은 Action 작업 생성 메서드에 대 한 호출에서 인라인으로 정의 된 람다 식 (대리자)을 실행 합니다.A fourth task executes a lambda expression (an Action delegate) that is defined inline in the call to the task creation method. 각 태스크는 다른 방식으로 인스턴스화되고 실행 됩니다.Each task is instantiated and run in a different way:

  • 작업은 작업 t1 클래스 생성자를 호출 하 여 인스턴스화되고 작업을 Start() 시작한 후에만 메서드를 호출 하 여 시작 됩니다 t2 .Task t1 is instantiated by calling a Task class constructor, but is started by calling its Start() method only after task t2 has started.

  • 작업 t2 은 메서드를 호출 하 여 단일 메서드 호출에서 인스턴스화되어 시작 됩니다 TaskFactory.StartNew(Action<Object>, Object) .Task t2 is instantiated and started in a single method call by calling the TaskFactory.StartNew(Action<Object>, Object) method.

  • 작업 t3 은 메서드를 호출 하 여 단일 메서드 호출에서 인스턴스화되어 시작 됩니다 Run(Action) .Task t3 is instantiated and started in a single method call by calling the Run(Action) method.

  • 작업 t4 은 메서드를 호출 하 여 주 스레드에서 동기적으로 실행 됩니다 RunSynchronously() .Task t4 is executed synchronously on the main thread by calling the RunSynchronously() method.

때문에 작업 t4 동기적으로 실행 애플리케이션 주 스레드에서 실행 됩니다.Because task t4 executes synchronously, it executes on the main application thread. 나머지 작업은 일반적으로 하나 이상의 스레드 풀 스레드에서 비동기적으로 실행 됩니다.The remaining tasks execute asynchronously typically on one or more thread pool threads.

using System;
using System.Threading;
using System.Threading.Tasks;

class Example
{
    static void Main()
    {
        Action<object> action = (object obj) =>
                                {
                                   Console.WriteLine("Task={0}, obj={1}, Thread={2}",
                                   Task.CurrentId, obj,
                                   Thread.CurrentThread.ManagedThreadId);
                                };

        // Create a task but do not start it.
        Task t1 = new Task(action, "alpha");

        // Construct a started task
        Task t2 = Task.Factory.StartNew(action, "beta");
        // Block the main thread to demonstrate that t2 is executing
        t2.Wait();

        // Launch t1 
        t1.Start();
        Console.WriteLine("t1 has been launched. (Main Thread={0})",
                          Thread.CurrentThread.ManagedThreadId);
        // Wait for the task to finish.
        t1.Wait();

        // Construct a started task using Task.Run.
        String taskData = "delta";
        Task t3 = Task.Run( () => {Console.WriteLine("Task={0}, obj={1}, Thread={2}",
                                                     Task.CurrentId, taskData,
                                                      Thread.CurrentThread.ManagedThreadId);
                                   });
        // Wait for the task to finish.
        t3.Wait();

        // Construct an unstarted task
        Task t4 = new Task(action, "gamma");
        // Run it synchronously
        t4.RunSynchronously();
        // Although the task was run synchronously, it is a good practice
        // to wait for it in the event exceptions were thrown by the task.
        t4.Wait();
    }
}
// The example displays output like the following:
//       Task=1, obj=beta, Thread=3
//       t1 has been launched. (Main Thread=1)
//       Task=2, obj=alpha, Thread=4
//       Task=3, obj=delta, Thread=3
//       Task=4, obj=gamma, Thread=1
Imports System.Threading
Imports System.Threading.Tasks

Module Example
    Public Sub Main()
        Dim action As Action(Of Object) = 
              Sub(obj As Object)
                 Console.WriteLine("Task={0}, obj={1}, Thread={2}", 
                 Task.CurrentId, obj,
                 Thread.CurrentThread.ManagedThreadId)
              End Sub

        ' Construct an unstarted task
        Dim t1 As New Task(action, "alpha")

        ' Construct a started task
        Dim t2 As Task = Task.Factory.StartNew(action, "beta")
        ' Block the main thread to demonstrate that t2 is executing
        t2.Wait()

        ' Launch t1 
        t1.Start()
        Console.WriteLine("t1 has been launched. (Main Thread={0})",
                          Thread.CurrentThread.ManagedThreadId)
        ' Wait for the task to finish.
        t1.Wait()

        ' Construct a started task using Task.Run.
        Dim taskData As String = "delta"
        Dim t3 As Task = Task.Run(Sub()
                                     Console.WriteLine("Task={0}, obj={1}, Thread={2}",
                                     Task.CurrentId, taskData,
                                     Thread.CurrentThread.ManagedThreadId)
                                  End Sub)
        ' Wait for the task to finish.
        t3.Wait()
        
        ' Construct an unstarted task
        Dim t4 As New Task(action, "gamma")
        ' Run it synchronously
        t4.RunSynchronously()
        ' Although the task was run synchronously, it is a good practice
        ' to wait for it in the event exceptions were thrown by the task.
        t4.Wait()
    End Sub
End Module
' The example displays output like the following:
'       Task=1, obj=beta, Thread=3
'       t1 has been launched. (Main Thread=1)
'       Task=2, obj=alpha, Thread=3
'       Task=3, obj=delta, Thread=3
'       Task=4, obj=gamma, Thread=1

작업 만들기 및 실행Creating and executing a task

Task 인스턴스는 다양 한 방법으로 만들 수 있습니다.Task instances may be created in a variety of ways. .NET Framework 4.5부터 사용할 수 있는 가장 일반적인 방법은 정적 메서드를 호출 하는 것입니다 Run .The most common approach, which is available starting with the .NET Framework 4.5, is to call the static Run method. Run메서드는 기본 값을 사용 하 고 추가 매개 변수를 요구 하지 않고 작업을 시작 하는 간단한 방법을 제공 합니다.The Run method provides a simple way to start a task using default values and without requiring additional parameters. 다음 예제에서는 메서드를 사용 하 여 루프를 Run(Action) 시작 하 고 루프 반복 횟수를 표시 하는 작업을 시작 합니다.The following example uses the Run(Action) method to start a task that loops and then displays the number of loop iterations:

using System;
using System.Threading.Tasks;

public class Example
{
   public static async Task Main()
   {
      await Task.Run( () => {
                                  // Just loop.
                                  int ctr = 0;
                                  for (ctr = 0; ctr <= 1000000; ctr++)
                                  {}
                                  Console.WriteLine("Finished {0} loop iterations",
                                                    ctr);
                               } );
   }
}
// The example displays the following output:
//        Finished 1000001 loop iterations
Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      Dim t As Task = Task.Run(Sub()
                                  ' Just loop.
                                  Dim ctr As Integer = 0
                                  For ctr = 0 to 1000000
                                  Next
                                  Console.WriteLine("Finished {0} loop iterations",
                                                    ctr)
                               End Sub)
      t.Wait()
   End Sub
End Module
' The example displays the following output:
'       Finished 1000001 loop iterations

대신 .NET Framework 4에서 작업을 시작 하는 가장 일반적인 방법은 정적 TaskFactory.StartNew 메서드입니다.An alternative, and the most common method to start a task in .NET Framework 4, is the static TaskFactory.StartNew method. Task.Factory속성은 개체를 반환 합니다 TaskFactory .The Task.Factory property returns a TaskFactory object. 메서드의 오버 로드를 사용 하 여 TaskFactory.StartNew 작업 만들기 옵션 및 작업 스케줄러에 전달할 매개 변수를 지정할 수 있습니다.Overloads of the TaskFactory.StartNew method let you specify parameters to pass to the task creation options and a task scheduler. 다음 예제에서는 메서드를 사용 하 여 TaskFactory.StartNew 작업을 시작 합니다.The following example uses the TaskFactory.StartNew method to start a task. 이전 예제의 코드와 기능적으로 동일 합니다.It is functionally equivalent to the code in the previous example.

using System;
using System.Threading.Tasks;

public class Example
{
   public static void Main()
   {
      Task t = Task.Factory.StartNew( () => {
                                  // Just loop.
                                  int ctr = 0;
                                  for (ctr = 0; ctr <= 1000000; ctr++)
                                  {}
                                  Console.WriteLine("Finished {0} loop iterations",
                                                    ctr);
                               } );
      t.Wait();
   }
}
// The example displays the following output:
//        Finished 1000001 loop iterations
Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      Dim t As Task = Task.Factory.StartNew(Sub()
                                  ' Just loop.
                                  Dim ctr As Integer = 0
                                  For ctr = 0 to 1000000
                                  Next
                                  Console.WriteLine("Finished {0} loop iterations",
                                                    ctr)
                               End Sub)
      t.Wait()
   End Sub
End Module
' The example displays the following output:
'       Finished 1000001 loop iterations

전체 예제는 작업 기반 비동기 프로그래밍을 참조 하세요.For more complete examples, see Task-based Asynchronous Programming.

작업 만들기 및 실행 분리Separating task creation and execution

Task또한 클래스는 작업을 초기화 하지만 실행을 예약 하지 않는 생성자를 제공 합니다.The Task class also provides constructors that initialize the task but that do not schedule it for execution. 성능상의 이유로 Task.Run 또는 메서드는 TaskFactory.StartNew 계산 작업을 만들고 예약 하는 기본 메커니즘 이지만 생성 및 예약을 구분 해야 하는 시나리오의 경우 생성자를 사용한 다음 메서드를 호출 하 여 나중에 Task.Start 실행할 작업을 예약할 수 있습니다.For performance reasons, the Task.Run or TaskFactory.StartNew method is the preferred mechanism for creating and scheduling computational tasks, but for scenarios where creation and scheduling must be separated, you can use the constructors and then call the Task.Start method to schedule the task for execution at a later time.

하나 이상의 작업이 완료 될 때까지 기다리는 중Waiting for one or more tasks to complete

작업은 일반적으로 스레드 풀 스레드에서 비동기적으로 실행 되기 때문에 작업을 만들고 시작 하는 스레드는 태스크가 인스턴스화된 직후에 실행을 계속 합니다.Because tasks typically run asynchronously on a thread pool thread, the thread that creates and starts the task continues execution as soon as the task has been instantiated. 경우에 따라 호출 스레드가 주 응용 프로그램 스레드인 경우 작업이 실제로 실행 되기 전에 앱이 종료 될 수 있습니다.In some cases, when the calling thread is the main application thread, the app may terminate before the task actually begins execution. 응용 프로그램의 논리에서 하나 이상의 작업 실행이 완료 된 경우에만 호출 스레드가 계속 실행 되도록 요구할 수 있습니다.In others, your application's logic may require that the calling thread continue execution only when one or more tasks have completed execution. Wait하나 이상의 작업이 완료 될 때까지 대기 하는 메서드를 호출 하 여 호출 스레드 및 실행 중인 비동기 작업의 실행을 동기화 할 수 있습니다.You can synchronize the execution of the calling thread and the asynchronous tasks it launches by calling a Wait method to wait for one or more tasks to complete.

단일 작업이 완료 될 때까지 대기 하려면 해당 메서드를 호출 하면 Task.Wait 됩니다.To wait for a single task to complete, you can call its Task.Wait method. 메서드를 호출 하면 Wait 단일 클래스 인스턴스의 실행이 완료 될 때까지 호출 스레드가 차단 됩니다.A call to the Wait method blocks the calling thread until the single class instance has completed execution.

다음 예제에서는 매개 변수가 없는 Wait() 메서드를 호출 하 여 작업이 완료 될 때까지 무조건 대기 합니다.The following example calls the parameterless Wait() method to wait unconditionally until a task completes. 작업은 Thread.Sleep 메서드를 2 초 동안 중지 하도록 호출 하 여 작업을 시뮬레이트합니다.The task simulates work by calling the Thread.Sleep method to sleep for two seconds.

using System;   
using System.Threading;
using System.Threading.Tasks;

class Program
{
    static Random rand = new Random();

    static void Main()
    {
        // Wait on a single task with no timeout specified.
        Task taskA = Task.Run( () => Thread.Sleep(2000));
        Console.WriteLine("taskA Status: {0}", taskA.Status);
        try {
          taskA.Wait();
          Console.WriteLine("taskA Status: {0}", taskA.Status);
       } 
       catch (AggregateException) {
          Console.WriteLine("Exception in taskA.");
       }   
    }    
}
// The example displays output like the following:
//     taskA Status: WaitingToRun
//     taskA Status: RanToCompletion
Imports System.Threading
Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      ' Wait on a single task with no timeout specified.
      Dim taskA = Task.Run( Sub() Thread.Sleep(2000))
      Console.WriteLine("taskA Status: {0}", taskA.Status)
      Try
        taskA.Wait()
        Console.WriteLine("taskA Status: {0}", taskA.Status)
      Catch e As AggregateException
         Console.WriteLine("Exception in taskA.")
      End Try
   End Sub
End Module
' The example displays output like the following:
'     taskA Status: WaitingToRun
'     taskA Status: RanToCompletion

작업이 완료 될 때까지 조건부로 기다릴 수도 있습니다.You can also conditionally wait for a task to complete. Wait(Int32)Wait(TimeSpan) 메서드는 작업이 완료 되거나 시간 제한 간격이 경과할 때까지 (둘 중 먼저 도달 하는 경우) 호출 스레드를 차단 합니다.The Wait(Int32) and Wait(TimeSpan) methods block the calling thread until the task finishes or a timeout interval elapses, whichever comes first. 다음 예제에서는 2 초 동안 대기 하지만 1 초 제한 시간 값을 정의 하는 작업을 시작 하므로, 호출 스레드는 제한 시간이 만료 될 때까지 차단 되 고 작업 실행이 완료 되기 전까지 차단 됩니다.Since the following example launches a task that sleeps for two seconds but defines a one-second timeout value, the calling thread blocks until the timeout expires and before the task has completed execution.

using System;
using System.Threading;
using System.Threading.Tasks;

public class Example
{
   public static void Main()
   {
      // Wait on a single task with a timeout specified.
      Task taskA = Task.Run( () => Thread.Sleep(2000));
      try {
        taskA.Wait(1000);       // Wait for 1 second.
        bool completed = taskA.IsCompleted;
        Console.WriteLine("Task A completed: {0}, Status: {1}",
                         completed, taskA.Status);
        if (! completed)
           Console.WriteLine("Timed out before task A completed.");                 
       }
       catch (AggregateException) {
          Console.WriteLine("Exception in taskA.");
       }   
   }
}
// The example displays output like the following:
//     Task A completed: False, Status: Running
//     Timed out before task A completed.
Imports System.Threading
Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      ' Wait on a single task with a timeout specified.
      Dim taskA As Task = Task.Run( Sub() Thread.Sleep(2000))
      Try
         taskA.Wait(1000)        ' Wait for 1 second.
         Dim completed As Boolean = taskA.IsCompleted
         Console.WriteLine("Task.Completed: {0}, Status: {1}",
                           completed, taskA.Status)
         If Not completed Then 
            Console.WriteLine("Timed out before task A completed.")
         End If                     
      Catch e As AggregateException
         Console.WriteLine("Exception in taskA.")
      End Try
   End Sub
End Module
' The example displays the following output:
'     Task A completed: False, Status: Running
'     Timed out before task A completed.

및 메서드를 호출 하 여 취소 토큰을 제공할 수도 있습니다 Wait(CancellationToken) Wait(Int32, CancellationToken) .You can also supply a cancellation token by calling the Wait(CancellationToken) and Wait(Int32, CancellationToken) methods. IsCancellationRequested true 메서드가 실행 되는 동안 토큰의 속성이 이거나 이면 true Wait 메서드는을 throw OperationCanceledException 합니다.If the token's IsCancellationRequested property is true or becomes true while the Wait method is executing, the method throws an OperationCanceledException.

일부 경우에는 실행 중인 일련의 작업이 완료 될 때까지 기다릴 수 있지만 어떤 작업을 수행 하지 않아도 됩니다.In some cases, you may want to wait for the first of a series of executing tasks to complete, but don't care which task it is. 이러한 목적을 위해 메서드의 오버 로드 중 하나를 호출할 수 있습니다 Task.WaitAny .For this purpose, you can call one of the overloads of the Task.WaitAny method. 다음 예에서는 각각 난수 생성기에 의해 결정 되는 간격으로 대기 하는 세 개의 작업을 만듭니다.The following example creates three tasks, each of which sleeps for an interval determined by a random number generator. WaitAny(Task[])메서드는 첫 번째 작업이 완료 될 때까지 대기 합니다.The WaitAny(Task[]) method waits for the first task to complete. 그런 다음이 예제에서는 세 가지 작업의 상태에 대 한 정보를 표시 합니다.The example then displays information about the status of all three tasks.

using System;
using System.Threading;
using System.Threading.Tasks;

public class Example
{
   public static void Main()
   {
      var tasks = new Task[3];
      var rnd = new Random();
      for (int ctr = 0; ctr <= 2; ctr++)
         tasks[ctr] = Task.Run( () => Thread.Sleep(rnd.Next(500, 3000)));

      try {
         int index = Task.WaitAny(tasks);
         Console.WriteLine("Task #{0} completed first.\n", tasks[index].Id);
         Console.WriteLine("Status of all tasks:");
         foreach (var t in tasks)
            Console.WriteLine("   Task #{0}: {1}", t.Id, t.Status);
      }
      catch (AggregateException) {
         Console.WriteLine("An exception occurred.");
      }
   }
}
// The example displays output like the following:
//     Task #1 completed first.
//     
//     Status of all tasks:
//        Task #3: Running
//        Task #1: RanToCompletion
//        Task #4: Running
Imports System.Threading
Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      Dim tasks(2) As Task
      Dim rnd As New Random()
      For ctr As Integer = 0 To 2
         tasks(ctr) = Task.Run( Sub()  Thread.Sleep(rnd.Next(500, 3000)))
      Next
      
      Try 
         Dim index As Integer= Task.WaitAny(tasks)
         Console.WriteLine("Task #{0} completed first.", tasks(index).Id)
         Console.WriteLine()
         Console.WriteLine("Status of all tasks:")
         For Each t in tasks
            Console.WriteLine("   Task #{0}: {1}", t.Id, t.Status)
         Next   
      Catch e As AggregateException
         Console.WriteLine("An exception occurred.")
      End Try
   End Sub
End Module
' The example displays output like the following:
'     Task #1 completed first.
'     
'     Status of all tasks:
'        Task #3: Running
'        Task #1: RanToCompletion
'        Task #4: Running

메서드를 호출 하 여 일련의 작업이 모두 완료 될 때까지 기다릴 수도 있습니다 WaitAll .You can also wait for all of a series of tasks to complete by calling the WaitAll method. 다음 예제에서는 10 개의 작업을 만들고, 10 개 모두 완료 될 때까지 대기한 다음, 상태를 표시 합니다.The following example creates ten tasks, waits for all ten to complete, and then displays their status.

using System;
using System.Threading;
using System.Threading.Tasks;

public class Example
{
   public static void Main()
   {
      // Wait for all tasks to complete.
      Task[] tasks = new Task[10];
      for (int i = 0; i < 10; i++)
      {
          tasks[i] = Task.Run(() => Thread.Sleep(2000));
      }
      try {
         Task.WaitAll(tasks);
      }
      catch (AggregateException ae) {
         Console.WriteLine("One or more exceptions occurred: ");
         foreach (var ex in ae.Flatten().InnerExceptions)
            Console.WriteLine("   {0}", ex.Message);
      }   

      Console.WriteLine("Status of completed tasks:");
      foreach (var t in tasks)
         Console.WriteLine("   Task #{0}: {1}", t.Id, t.Status);
   }
}
// The example displays the following output:
//     Status of completed tasks:
//        Task #2: RanToCompletion
//        Task #1: RanToCompletion
//        Task #3: RanToCompletion
//        Task #4: RanToCompletion
//        Task #6: RanToCompletion
//        Task #5: RanToCompletion
//        Task #7: RanToCompletion
//        Task #8: RanToCompletion
//        Task #9: RanToCompletion
//        Task #10: RanToCompletion
Imports System.Threading
Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      ' Wait for all tasks to complete.
      Dim tasks(9) As Task
      For i As Integer = 0 To 9
          tasks(i) = Task.Run( Sub() Thread.Sleep(2000) )
      Next
      Try 
         Task.WaitAll(tasks)
      Catch ae As AggregateException
         Console.WriteLine("One or more exceptions occurred: ")
         For Each ex In ae.Flatten().InnerExceptions
            Console.WriteLine("   {0}", ex.Message)
         Next
      End Try   

      Console.WriteLine("Status of completed tasks:")
      For Each t in tasks
         Console.WriteLine("   Task #{0}: {1}", t.Id, t.Status)
      Next   
   End Sub
End Module
' The example displays the following output:
'     Status of completed tasks:
'        Task #2: RanToCompletion
'        Task #1: RanToCompletion
'        Task #3: RanToCompletion
'        Task #4: RanToCompletion
'        Task #6: RanToCompletion
'        Task #5: RanToCompletion
'        Task #7: RanToCompletion
'        Task #8: RanToCompletion
'        Task #9: RanToCompletion
'        Task #10: RanToCompletion

하나 이상의 작업이 완료 될 때까지 대기 하는 경우 Wait 다음 예제와 같이 실행 중인 작업에서 throw 되는 모든 예외가 메서드를 호출 하는 스레드에서 전파 됩니다.Note that when you wait for one or more tasks to complete, any exceptions thrown in the running tasks are propagated on the thread that calls the Wait method, as the following example shows. 12 개 작업을 시작 합니다 .이 작업 중 3 개는 정상적으로 완료 되 고 3 개는 예외를 throw 합니다.It launches 12 tasks, three of which complete normally and three of which throw an exception. 나머지 6 개 작업 중 세 개는 시작 하기 전에 취소 되 고 3은 실행 중에 취소 됩니다.Of the remaining six tasks, three are cancelled before they start, and three are cancelled while they are executing. 예외는 메서드 호출에서 throw 되며 WaitAll 블록에 의해 처리 됩니다 try / catch .Exceptions are thrown in the WaitAll method call and are handled by a try/catch block.

using System;
using System.Threading;
using System.Threading.Tasks;

public class Example
{
   public static void Main()
   {
      // Create a cancellation token and cancel it.
      var source1 = new CancellationTokenSource();
      var token1 = source1.Token;
      source1.Cancel();
      // Create a cancellation token for later cancellation.
      var source2 = new CancellationTokenSource();
      var token2 = source2.Token;
       
      // Create a series of tasks that will complete, be cancelled, 
      // timeout, or throw an exception.
      Task[] tasks = new Task[12];
      for (int i = 0; i < 12; i++)
      {
          switch (i % 4) 
          {
             // Task should run to completion.
             case 0:
                tasks[i] = Task.Run(() => Thread.Sleep(2000));
                break;
             // Task should be set to canceled state.
             case 1:   
                tasks[i] = Task.Run( () => Thread.Sleep(2000),
                         token1);
                break;         
             case 2:
                // Task should throw an exception.
                tasks[i] = Task.Run( () => { throw new NotSupportedException(); } );
                break;
             case 3:
                // Task should examine cancellation token.
                tasks[i] = Task.Run( () => { Thread.Sleep(2000); 
                                             if (token2.IsCancellationRequested)
                                                token2.ThrowIfCancellationRequested();
                                             Thread.Sleep(500); }, token2);   
                break;
          }
      }
      Thread.Sleep(250);
      source2.Cancel();
       
      try {
         Task.WaitAll(tasks);
      }
      catch (AggregateException ae) {
          Console.WriteLine("One or more exceptions occurred:");
          foreach (var ex in ae.InnerExceptions)
             Console.WriteLine("   {0}: {1}", ex.GetType().Name, ex.Message);
       }   

      Console.WriteLine("\nStatus of tasks:");
      foreach (var t in tasks) {
         Console.WriteLine("   Task #{0}: {1}", t.Id, t.Status);
         if (t.Exception != null) {
            foreach (var ex in t.Exception.InnerExceptions)
               Console.WriteLine("      {0}: {1}", ex.GetType().Name,
                                 ex.Message);
         }
      }
   }
}
// The example displays output like the following:
//   One or more exceptions occurred:
//      TaskCanceledException: A task was canceled.
//      NotSupportedException: Specified method is not supported.
//      TaskCanceledException: A task was canceled.
//      TaskCanceledException: A task was canceled.
//      NotSupportedException: Specified method is not supported.
//      TaskCanceledException: A task was canceled.
//      TaskCanceledException: A task was canceled.
//      NotSupportedException: Specified method is not supported.
//      TaskCanceledException: A task was canceled.
//   
//   Status of tasks:
//      Task #13: RanToCompletion
//      Task #1: Canceled
//      Task #3: Faulted
//         NotSupportedException: Specified method is not supported.
//      Task #8: Canceled
//      Task #14: RanToCompletion
//      Task #4: Canceled
//      Task #6: Faulted
//         NotSupportedException: Specified method is not supported.
//      Task #7: Canceled
//      Task #15: RanToCompletion
//      Task #9: Canceled
//      Task #11: Faulted
//         NotSupportedException: Specified method is not supported.
//      Task #12: Canceled
Imports System.Threading
Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      ' Create a cancellation token and cancel it.
      Dim source1 As New CancellationTokenSource()
      Dim token1 As CancellationToken = source1.Token
      source1.Cancel()
      ' Create a cancellation token for later cancellation.
      Dim source2 As New CancellationTokenSource()
      Dim token2 As CancellationToken = source2.Token
       
      ' Create a series of tasks that will complete, be cancelled, 
      ' timeout, or throw an exception.
      Dim tasks(11) As Task
      For i As Integer = 0 To 11
          Select Case i Mod 4 
             ' Task should run to completion.
             Case 0
                tasks(i) = Task.Run( Sub() Thread.Sleep(2000))
             ' Task should be set to canceled state.
             Case 1   
                tasks(i) = Task.Run( Sub() Thread.Sleep(2000), token1)
             Case 2
                ' Task should throw an exception.
                tasks(i) = Task.Run( Sub() 
                                        Throw New NotSupportedException() 
                                     End Sub)
             Case 3
                ' Task should examine cancellation token.
                tasks(i) = Task.Run( Sub() 
                                        Thread.Sleep(2000) 
                                        If token2.IsCancellationRequested
                                           token2.ThrowIfCancellationRequested()
                                        End If
                                        Thread.Sleep(500) 
                                     End Sub, token2)   
          End Select
      Next
      Thread.Sleep(250)
      source2.Cancel()
       
      Try 
         Task.WaitAll(tasks)
      Catch ae As AggregateException
         Console.WriteLine("One or more exceptions occurred:")
         For Each ex in ae.InnerExceptions
             Console.WriteLine("   {0}: {1}", ex.GetType().Name, ex.Message)
         Next
      End Try   
      Console.WriteLine()
      
      Console.WriteLine("Status of tasks:")
      For Each t in tasks
         Console.WriteLine("   Task #{0}: {1}", t.Id, t.Status)
         If t.Exception IsNot Nothing Then
            For Each ex in t.Exception.InnerExceptions
               Console.WriteLine("      {0}: {1}", ex.GetType().Name,
                                 ex.Message)
            Next
         End If
      Next
   End Sub
End Module
' The example displays output like the following:
'   One or more exceptions occurred:
'      TaskCanceledException: A task was canceled.
'      NotSupportedException: Specified method is not supported.
'      TaskCanceledException: A task was canceled.
'      TaskCanceledException: A task was canceled.
'      NotSupportedException: Specified method is not supported.
'      TaskCanceledException: A task was canceled.
'      TaskCanceledException: A task was canceled.
'      NotSupportedException: Specified method is not supported.
'      TaskCanceledException: A task was canceled.
'   
'   Status of tasks:
'      Task #13: RanToCompletion
'      Task #1: Canceled
'      Task #3: Faulted
'         NotSupportedException: Specified method is not supported.
'      Task #8: Canceled
'      Task #14: RanToCompletion
'      Task #4: Canceled
'      Task #6: Faulted
'         NotSupportedException: Specified method is not supported.
'      Task #7: Canceled
'      Task #15: RanToCompletion
'      Task #9: Canceled
'      Task #11: Faulted
'         NotSupportedException: Specified method is not supported.
'      Task #12: Canceled

작업 기반 비동기 작업에서 예외 처리에 대 한 자세한 내용은 예외 처리를 참조 하세요.For more information on exception handling in task-based asynchronous operations, see Exception Handling.

작업 및 문화권Tasks and culture

.NET Framework 4.6를 대상으로 하는 데스크톱 앱부터 작업을 만들고 호출 하는 스레드의 문화권이 스레드 컨텍스트의 일부가 됩니다.Starting with desktop apps that target the .NET Framework 4.6, the culture of the thread that creates and invokes a task becomes part of the thread's context. 즉, 태스크가 실행 되는 스레드의 현재 문화권에 관계 없이 작업의 현재 문화권이 호출 스레드의 문화권입니다.That is, regardless of the current culture of the thread on which the task executes, the current culture of the task is the culture of the calling thread. .NET Framework 4.6 이전의 .NET Framework 버전을 대상으로 하는 앱의 경우 작업의 문화권은 태스크가 실행 되는 스레드의 문화권입니다.For apps that target versions of the .NET Framework prior to the .NET Framework 4.6, the culture of the task is the culture of the thread on which the task executes. 자세한 내용은 항목의 "문화권 및 작업 기반 비동기 작업" 섹션을 참조 하십시오 CultureInfo .For more information, see the "Culture and task-based asynchronous operations" section in the CultureInfo topic.

참고

스토어 앱은 기본 문화권 설정 및 가져오기의 Windows 런타임 따릅니다.Store apps follow the Windows Runtime in setting and getting the default culture.

디버거 개발자 용For debugger developers

사용자 지정 디버거를 구현 하는 개발자의 경우 작업의 여러 내부 및 개인 멤버가 유용할 수 있습니다 (릴리스에서 릴리스로 변경 될 수 있음).For developers implementing custom debuggers, several internal and private members of task may be useful (these may change from release to release). m_taskId필드는 속성의 백업 저장소 역할 Id 을 하지만 디버거에서 직접이 필드에 액세스 하는 것이 속성의 getter 메서드를 통해 동일한 값에 액세스 하는 것 보다 효율적일 수 있습니다 s_taskIdCounter . 카운터는 작업에 사용 가능한 다음 ID를 검색 하는 데 사용 됩니다.The m_taskId field serves as the backing store for the Id property, however accessing this field directly from a debugger may be more efficient than accessing the same value through the property's getter method (the s_taskIdCounter counter is used to retrieve the next available ID for a task). 마찬가지로 필드는 m_stateFlags 작업의 현재 수명 주기 단계에 대 한 정보를 저장 하 고 속성을 통해서도 액세스할 수 있습니다 Status .Similarly, the m_stateFlags field stores information about the current lifecycle stage of the task, information also accessible through the Status property. m_action필드는 태스크의 대리자에 대 한 참조를 저장 하 고, m_stateObject 필드는 개발자가 작업에 전달한 비동기 상태를 저장 합니다.The m_action field stores a reference to the task's delegate, and the m_stateObject field stores the async state passed to the task by the developer. 마지막으로 스택 프레임을 구문 분석 하는 디버거의 경우 InternalWait 메서드가 대기 작업을 시작 하는 경우에 잠재적 표식을 사용 합니다.Finally, for debuggers that parse stack frames, the InternalWait method serves a potential marker for when a task is entering a wait operation.

생성자

Task(Action)

지정된 작업을 사용하여 새 Task를 초기화합니다.Initializes a new Task with the specified action.

Task(Action, CancellationToken)

지정된 작업을 사용하여 새 TaskCancellationToken을 초기화합니다.Initializes a new Task with the specified action and CancellationToken.

Task(Action, CancellationToken, TaskCreationOptions)

지정된 작업 및 만들기 옵션을 사용하여 새 Task를 초기화합니다.Initializes a new Task with the specified action and creation options.

Task(Action, TaskCreationOptions)

지정된 작업 및 만들기 옵션을 사용하여 새 Task를 초기화합니다.Initializes a new Task with the specified action and creation options.

Task(Action<Object>, Object)

지정된 작업 및 상태를 사용하여 새 Task를 초기화합니다.Initializes a new Task with the specified action and state.

Task(Action<Object>, Object, CancellationToken)

지정된 작업, 상태 및 옵션을 사용하여 새 Task를 초기화합니다.Initializes a new Task with the specified action, state, and options.

Task(Action<Object>, Object, CancellationToken, TaskCreationOptions)

지정된 작업, 상태 및 옵션을 사용하여 새 Task를 초기화합니다.Initializes a new Task with the specified action, state, and options.

Task(Action<Object>, Object, TaskCreationOptions)

지정된 작업, 상태 및 옵션을 사용하여 새 Task를 초기화합니다.Initializes a new Task with the specified action, state, and options.

속성

AsyncState

Task를 만들 때 제공된 상태 개체 또는 제공된 개체가 없는 경우 null을 가져옵니다.Gets the state object supplied when the Task was created, or null if none was supplied.

CompletedTask

이미 성공적으로 완료된 작업을 가져옵니다.Gets a task that has already completed successfully.

CreationOptions

이 작업을 만드는 데 사용된 TaskCreationOptions를 가져옵니다.Gets the TaskCreationOptions used to create this task.

CurrentId

현재 실행 중인 Task의 ID를 반환합니다.Returns the ID of the currently executing Task.

Exception

AggregateException가 중간에 종료되도록 하는 Task을 가져옵니다.Gets the AggregateException that caused the Task to end prematurely. Task가 완료되었거나 예외를 아직 throw하지 않았을 경우 null을 반환합니다.If the Task completed successfully or has not yet thrown any exceptions, this will return null.

Factory

TaskTask<TResult> 인스턴스를 만들고 구성하는 팩터리 메서드에 대한 액세스를 제공합니다.Provides access to factory methods for creating and configuring Task and Task<TResult> instances.

Id

Task 인스턴스에 대한 ID를 가져옵니다.Gets an ID for this Task instance.

IsCanceled

Task 인스턴스가 취소되어 실행을 완료했는지 여부를 가져옵니다.Gets whether this Task instance has completed execution due to being canceled.

IsCompleted

작업이 완료되었는지 여부를 나타내는 값을 가져옵니다.Gets a value that indicates whether the task has completed.

IsCompletedSuccessfully

작업이 완료될 때까지 실행되었는지 여부를 가져옵니다.Gets whether the task ran to completion.

IsFaulted

처리되지 않은 예외로 인해 Task가 완료되었는지 여부를 가져옵니다.Gets whether the Task completed due to an unhandled exception.

Status

이 작업의 TaskStatus를 가져옵니다.Gets the TaskStatus of this task.

메서드

ConfigureAwait(Boolean)

Task를 기다리는 데 사용되는 awaiter를 구성합니다.Configures an awaiter used to await this Task.

ContinueWith(Action<Task,Object>, Object)

호출자 제공 상태 정보를 받으며 대상 Task이(가) 완료되면 실행되는 연속 작업을 만듭니다.Creates a continuation that receives caller-supplied state information and executes when the target Task completes.

ContinueWith(Action<Task,Object>, Object, CancellationToken)

대상 Task가 완료될 때 호출자 제공 상태 정보 및 취소 토큰을 받고 비동기적으로 실행되는 연속 작업을 만듭니다.Creates a continuation that receives caller-supplied state information and a cancellation token and that executes asynchronously when the target Task completes.

ContinueWith(Action<Task,Object>, Object, CancellationToken, TaskContinuationOptions, TaskScheduler)

대상 Task가 완료될 때 호출자 제공 상태 정보 및 취소 토큰을 받고 실행되는 연속 작업을 만듭니다.Creates a continuation that receives caller-supplied state information and a cancellation token and that executes when the target Task completes. 연속 작업은 지정된 조건의 집합에 따라 실행되며 지정된 스케줄러를 사용합니다.The continuation executes based on a set of specified conditions and uses a specified scheduler.

ContinueWith(Action<Task,Object>, Object, TaskContinuationOptions)

호출자 제공 상태 정보를 받으며 대상 Task이(가) 완료되면 실행되는 연속 작업을 만듭니다.Creates a continuation that receives caller-supplied state information and executes when the target Task completes. 연속 작업은 지정된 조건의 집합에 따라 실행됩니다.The continuation executes based on a set of specified conditions.

ContinueWith(Action<Task,Object>, Object, TaskScheduler)

호출자 제공 상태 정보를 받으며 대상 Task이(가) 완료되면 비동기적으로 실행되는 연속 작업을 만듭니다.Creates a continuation that receives caller-supplied state information and executes asynchronously when the target Task completes. 연속 작업은 지정된 스케줄러를 사용합니다.The continuation uses a specified scheduler.

ContinueWith(Action<Task>)

대상 Task가 완료될 때 비동기적으로 실행되는 연속 작업을 만듭니다.Creates a continuation that executes asynchronously when the target Task completes.

ContinueWith(Action<Task>, CancellationToken)

대상 Task가 완료될 때 취소 토큰을 받고 비동기적으로 실행되는 연속 작업을 만듭니다.Creates a continuation that receives a cancellation token and executes asynchronously when the target Task completes.

ContinueWith(Action<Task>, CancellationToken, TaskContinuationOptions, TaskScheduler)

지정된 TaskContinuationOptions에 따라 대상 작업이 완료되면 실행되는 연속 작업을 만듭니다.Creates a continuation that executes when the target task competes according to the specified TaskContinuationOptions. 연속 작업은 취소 토큰을 받고 지정된 스케줄러를 사용합니다.The continuation receives a cancellation token and uses a specified scheduler.

ContinueWith(Action<Task>, TaskContinuationOptions)

지정된 TaskContinuationOptions에 따라 대상 작업이 완료되면 실행되는 연속 작업을 만듭니다.Creates a continuation that executes when the target task completes according to the specified TaskContinuationOptions.

ContinueWith(Action<Task>, TaskScheduler)

대상 Task가 완료될 때 비동기적으로 실행되는 연속 작업을 만듭니다.Creates a continuation that executes asynchronously when the target Task completes. 연속 작업은 지정된 스케줄러를 사용합니다.The continuation uses a specified scheduler.

ContinueWith<TResult>(Func<Task,Object,TResult>, Object)

호출자 제공 상태 정보를 받으며 대상 Task이(가) 완료되고 값을 가져오면 비동기적으로 실행되는 연속 작업을 만듭니다.Creates a continuation that receives caller-supplied state information and executes asynchronously when the target Task completes and returns a value.

ContinueWith<TResult>(Func<Task,Object,TResult>, Object, CancellationToken)

대상 Task이(가) 완료되고 값을 가져오면 비동기적으로 실행되는 연속 작업을 만듭니다.Creates a continuation that executes asynchronously when the target Task completes and returns a value. 연속 작업은 호출자 제공한 상태 정보 및 취소 토큰을 받습니다.The continuation receives caller-supplied state information and a cancellation token.

ContinueWith<TResult>(Func<Task,Object,TResult>, Object, CancellationToken, TaskContinuationOptions, TaskScheduler)

대상 Task가 완료되고 값을 반환하면 지정된 작업 연속 옵션에 따라 실행되는 연속 작업을 만듭니다.Creates a continuation that executes based on the specified task continuation options when the target Task completes and returns a value. 연속 작업은 호출자 제공 상태 정보 및 취소 토큰을 받고 지정된 스케줄러를 사용합니다.The continuation receives caller-supplied state information and a cancellation token and uses the specified scheduler.

ContinueWith<TResult>(Func<Task,Object,TResult>, Object, TaskContinuationOptions)

대상 Task가 완료되면 지정된 작업 연속 옵션에 따라 실행되는 연속 작업을 만듭니다.Creates a continuation that executes based on the specified task continuation options when the target Task completes. 연속 작업은 호출자 제공 상태 정보를 받습니다.The continuation receives caller-supplied state information.

ContinueWith<TResult>(Func<Task,Object,TResult>, Object, TaskScheduler)

대상 Task가 완료될 때 비동기적으로 실행되는 연속 작업을 만듭니다.Creates a continuation that executes asynchronously when the target Task completes. 연속 작업은 호출자 제공 상태 정보를 받고 지정된 스케줄러를 사용합니다.The continuation receives caller-supplied state information and uses a specified scheduler.

ContinueWith<TResult>(Func<Task,TResult>)

대상 Task<TResult>이(가) 완료되고 값을 가져오면 비동기적으로 실행되는 연속 작업을 만듭니다.Creates a continuation that executes asynchronously when the target Task<TResult> completes and returns a value.

ContinueWith<TResult>(Func<Task,TResult>, CancellationToken)

대상 Task이(가) 완료되고 값을 가져오면 비동기적으로 실행되는 연속 작업을 만듭니다.Creates a continuation that executes asynchronously when the target Task completes and returns a value. 연속 작업은 취소 토큰을 받습니다.The continuation receives a cancellation token.

ContinueWith<TResult>(Func<Task,TResult>, CancellationToken, TaskContinuationOptions, TaskScheduler)

지정된 연속 작업 옵션에 따라 실행되고 값을 반환하는 연속 작업을 만듭니다.Creates a continuation that executes according to the specified continuation options and returns a value. 연속 작업에 취소 토큰이 전달되고, 연속 작업은 지정된 스케줄러를 사용합니다.The continuation is passed a cancellation token and uses a specified scheduler.

ContinueWith<TResult>(Func<Task,TResult>, TaskContinuationOptions)

지정된 연속 작업 옵션에 따라 실행되고 값을 반환하는 연속 작업을 만듭니다.Creates a continuation that executes according to the specified continuation options and returns a value.

ContinueWith<TResult>(Func<Task,TResult>, TaskScheduler)

대상 Task이(가) 완료되고 값을 가져오면 비동기적으로 실행되는 연속 작업을 만듭니다.Creates a continuation that executes asynchronously when the target Task completes and returns a value. 연속 작업은 지정된 스케줄러를 사용합니다.The continuation uses a specified scheduler.

Delay(Int32)

지정된 시간(밀리초) 후에 완료되는 작업을 만듭니다.Creates a task that completes after a specified number of milliseconds.

Delay(Int32, CancellationToken)

지정된 시간(밀리초) 후에 완료되는 취소 가능한 작업을 만듭니다.Creates a cancellable task that completes after a specified number of milliseconds.

Delay(TimeSpan)

지정된 시간 간격 후 완료되는 작업을 만듭니다.Creates a task that completes after a specified time interval.

Delay(TimeSpan, CancellationToken)

지정된 시간 간격 후 완료되는 취소 가능 작업을 만듭니다.Creates a cancellable task that completes after a specified time interval.

Dispose()

Task 클래스의 현재 인스턴스에서 사용하는 모든 리소스를 해제합니다.Releases all resources used by the current instance of the Task class.

Dispose(Boolean)

Task를 삭제하고 관리되지 않는 해당 리소스를 모두 해제합니다.Disposes the Task, releasing all of its unmanaged resources.

Equals(Object)

지정된 개체가 현재 개체와 같은지 확인합니다.Determines whether the specified object is equal to the current object.

(다음에서 상속됨 Object)
FromCanceled(CancellationToken)

지정된 취소 토큰을 사용하여 취소로 인해 완료된 Task를 만듭니다.Creates a Task that's completed due to cancellation with a specified cancellation token.

FromCanceled<TResult>(CancellationToken)

지정된 취소 토큰을 사용하여 취소로 인해 완료된 Task<TResult>를 만듭니다.Creates a Task<TResult> that's completed due to cancellation with a specified cancellation token.

FromException(Exception)

지정된 예외를 사용하여 완료된 Task를 만듭니다.Creates a Task that has completed with a specified exception.

FromException<TResult>(Exception)

지정된 예외를 사용하여 완료된 Task<TResult>을 만듭니다.Creates a Task<TResult> that's completed with a specified exception.

FromResult<TResult>(TResult)

지정된 결과로 성공적으로 완료되는 Task<TResult>을 만듭니다.Creates a Task<TResult> that's completed successfully with the specified result.

GetAwaiter()

Task를 기다리는 데 사용되는 awaiter를 가져옵니다.Gets an awaiter used to await this Task.

GetHashCode()

기본 해시 함수로 작동합니다.Serves as the default hash function.

(다음에서 상속됨 Object)
GetType()

현재 인스턴스의 Type을 가져옵니다.Gets the Type of the current instance.

(다음에서 상속됨 Object)
MemberwiseClone()

현재 Object의 단순 복사본을 만듭니다.Creates a shallow copy of the current Object.

(다음에서 상속됨 Object)
Run(Action)

지정한 작업을 스레드 풀에서 실행하도록 큐에 대기시키고 작업을 나타내는 Task 개체를 반환합니다.Queues the specified work to run on the thread pool and returns a Task object that represents that work.

Run(Action, CancellationToken)

지정한 작업을 스레드 풀에서 실행하도록 큐에 대기시키고 작업을 나타내는 Task 개체를 반환합니다.Queues the specified work to run on the thread pool and returns a Task object that represents that work. 취소 토큰을 사용하면 작업이 아직 시작되지 않은 경우 작업을 취소할 수 있습니다.A cancellation token allows the work to be cancelled if it has not yet started.

Run(Func<Task>)

지정한 작업을 스레드 풀에서 실행하도록 큐에 대기시키고 function에서 반환된 작업에 대한 프록시를 반환합니다.Queues the specified work to run on the thread pool and returns a proxy for the task returned by function.

Run(Func<Task>, CancellationToken)

지정한 작업을 스레드 풀에서 실행하도록 큐에 대기시키고 function에서 반환된 작업에 대한 프록시를 반환합니다.Queues the specified work to run on the thread pool and returns a proxy for the task returned by function. 취소 토큰을 사용하면 작업이 아직 시작되지 않은 경우 작업을 취소할 수 있습니다.A cancellation token allows the work to be cancelled if it has not yet started.

Run<TResult>(Func<Task<TResult>>)

지정된 작업을 스레드 풀에서 실행하도록 큐에 대기시키고 function에서 반환된 Task(TResult)에 대한 프록시를 반환합니다.Queues the specified work to run on the thread pool and returns a proxy for the Task(TResult) returned by function. 취소 토큰을 사용하면 작업이 아직 시작되지 않은 경우 작업을 취소할 수 있습니다.A cancellation token allows the work to be cancelled if it has not yet started.

Run<TResult>(Func<Task<TResult>>, CancellationToken)

지정된 작업을 스레드 풀에서 실행하도록 큐에 대기시키고 function에서 반환된 Task(TResult)에 대한 프록시를 반환합니다.Queues the specified work to run on the thread pool and returns a proxy for the Task(TResult) returned by function.

Run<TResult>(Func<TResult>)

지정한 작업을 스레드 풀에서 실행하도록 큐에 대기시키고 작업을 나타내는 Task<TResult> 개체를 반환합니다.Queues the specified work to run on the thread pool and returns a Task<TResult> object that represents that work. 취소 토큰을 사용하면 작업이 아직 시작되지 않은 경우 작업을 취소할 수 있습니다.A cancellation token allows the work to be cancelled if it has not yet started.

Run<TResult>(Func<TResult>, CancellationToken)

지정한 작업을 스레드 풀에서 실행하도록 큐에 대기시키고 작업을 나타내는 Task(TResult) 개체를 반환합니다.Queues the specified work to run on the thread pool and returns a Task(TResult) object that represents that work.

RunSynchronously()

현재 Task에서 TaskScheduler를 동기적으로 실행합니다.Runs the Task synchronously on the current TaskScheduler.

RunSynchronously(TaskScheduler)

제공된 Task에서 TaskScheduler를 동기적으로 실행합니다.Runs the Task synchronously on the TaskScheduler provided.

Start()

Task를 시작하고 현재 TaskScheduler에 실행을 예약합니다.Starts the Task, scheduling it for execution to the current TaskScheduler.

Start(TaskScheduler)

Task를 시작하고 지정된 TaskScheduler에 실행을 예약합니다.Starts the Task, scheduling it for execution to the specified TaskScheduler.

ToString()

현재 개체를 나타내는 문자열을 반환합니다.Returns a string that represents the current object.

(다음에서 상속됨 Object)
Wait()

Task의 실행이 완료되기를 기다립니다.Waits for the Task to complete execution.

Wait(CancellationToken)

Task의 실행이 완료되기를 기다립니다.Waits for the Task to complete execution. 작업이 완료되기 전에 취소 토큰이 취소되면 대기가 종료됩니다.The wait terminates if a cancellation token is canceled before the task completes.

Wait(Int32)

Task가 지정된 시간(밀리초) 내에 실행을 완료할 때까지 기다립니다.Waits for the Task to complete execution within a specified number of milliseconds.

Wait(Int32, CancellationToken)

Task의 실행이 완료되기를 기다립니다.Waits for the Task to complete execution. 작업이 완료되기 전에 취소 토큰이 취소되었거나 시간 제한 간격이 경과되었으면 대기가 종료됩니다.The wait terminates if a timeout interval elapses or a cancellation token is canceled before the task completes.

Wait(TimeSpan)

Task가 지정된 시간 간격 내에 실행을 완료할 때까지 기다립니다.Waits for the Task to complete execution within a specified time interval.

WaitAll(Task[])

제공된 모든 Task 개체의 실행이 완료되기를 기다립니다.Waits for all of the provided Task objects to complete execution.

WaitAll(Task[], CancellationToken)

대기가 취소되지 않는 경우 제공된 모든 Task 개체가 실행을 완료하기를 기다립니다.Waits for all of the provided Task objects to complete execution unless the wait is cancelled.

WaitAll(Task[], Int32)

모든 제공된 Task 개체가 지정된 시간(밀리초) 내에 실행을 완료할 때까지 기다립니다.Waits for all of the provided Task objects to complete execution within a specified number of milliseconds.

WaitAll(Task[], Int32, CancellationToken)

제공된 모든 Task 개체가 지정된 시간(밀리초) 내에 실행을 완료하기를 기다리거나 대기가 취소될 때까지 기다립니다.Waits for all of the provided Task objects to complete execution within a specified number of milliseconds or until the wait is cancelled.

WaitAll(Task[], TimeSpan)

모든 제공된 취소 가능한 Task 개체가 지정된 시간 간격 내에 실행을 완료할 때까지 기다립니다.Waits for all of the provided cancellable Task objects to complete execution within a specified time interval.

WaitAny(Task[])

제공된 Task 개체 중 임의 개체의 실행이 완료되기를 기다립니다.Waits for any of the provided Task objects to complete execution.

WaitAny(Task[], CancellationToken)

대기가 취소되지 않는 경우 제공된 모든 Task 개체가 실행을 완료하기를 기다립니다.Waits for any of the provided Task objects to complete execution unless the wait is cancelled.

WaitAny(Task[], Int32)

모든 제공된 Task 개체가 지정된 시간(밀리초) 내에 실행을 완료할 때까지 기다립니다.Waits for any of the provided Task objects to complete execution within a specified number of milliseconds.

WaitAny(Task[], Int32, CancellationToken)

모든 제공된 Task 개체가 지정된 시간(밀리초) 내에 실행을 완료하기를 기다리거나 취소 토큰이 취소될 때까지 기다립니다.Waits for any of the provided Task objects to complete execution within a specified number of milliseconds or until a cancellation token is cancelled.

WaitAny(Task[], TimeSpan)

모든 제공된 Task 개체가 지정된 시간 간격 내에 실행을 완료할 때까지 기다립니다.Waits for any of the provided Task objects to complete execution within a specified time interval.

WhenAll(IEnumerable<Task>)

열거 가능한 컬렉션의 모든 Task 개체가 완료되면 완료될 작업을 만듭니다.Creates a task that will complete when all of the Task objects in an enumerable collection have completed.

WhenAll(Task[])

배열의 모든 Task 개체가 완료되면 완료될 작업을 만듭니다.Creates a task that will complete when all of the Task objects in an array have completed.

WhenAll<TResult>(IEnumerable<Task<TResult>>)

열거 가능한 컬렉션의 모든 Task<TResult> 개체가 완료되면 완료될 작업을 만듭니다.Creates a task that will complete when all of the Task<TResult> objects in an enumerable collection have completed.

WhenAll<TResult>(Task<TResult>[])

배열의 모든 Task<TResult> 개체가 완료되면 완료될 작업을 만듭니다.Creates a task that will complete when all of the Task<TResult> objects in an array have completed.

WhenAny(IEnumerable<Task>)

제공된 작업을 모두 완료했을 때 완료할 작업을 만듭니다.Creates a task that will complete when any of the supplied tasks have completed.

WhenAny(Task, Task)

제공된 작업 중 하나가 완료했을 때 완료할 작업을 만듭니다.Creates a task that will complete when either of the supplied tasks have completed.

WhenAny(Task[])

제공된 작업을 모두 완료했을 때 완료할 작업을 만듭니다.Creates a task that will complete when any of the supplied tasks have completed.

WhenAny<TResult>(IEnumerable<Task<TResult>>)

제공된 작업을 모두 완료했을 때 완료할 작업을 만듭니다.Creates a task that will complete when any of the supplied tasks have completed.

WhenAny<TResult>(Task<TResult>, Task<TResult>)

제공된 작업 중 하나가 완료했을 때 완료할 작업을 만듭니다.Creates a task that will complete when either of the supplied tasks have completed.

WhenAny<TResult>(Task<TResult>[])

제공된 작업을 모두 완료했을 때 완료할 작업을 만듭니다.Creates a task that will complete when any of the supplied tasks have completed.

Yield()

대기할 때 현재 컨텍스트로 비동기적으로 전환되는 awaitable 작업을 만듭니다.Creates an awaitable task that asynchronously yields back to the current context when awaited.

명시적 인터페이스 구현

IAsyncResult.AsyncWaitHandle

작업이 완료되기를 기다리는 데 사용할 수 있는 WaitHandle을 가져옵니다.Gets a WaitHandle that can be used to wait for the task to complete.

IAsyncResult.CompletedSynchronously

작업이 동기적으로 완료되었는지 여부를 나타내는 표시를 가져옵니다.Gets an indication of whether the operation completed synchronously.

확장 메서드

DispatcherOperationWait(Task)

기본 DispatcherOperation이 완료되기를 무기한 기다립니다.Waits indefinitely for the underlying DispatcherOperation to complete.

DispatcherOperationWait(Task, TimeSpan)

그런 다음 지정된 시간 동안 기본 DispatcherOperation이 완료되기를 기다립니다.Waits for the specified amount of time for the underlying DispatcherOperation to complete.

IsDispatcherOperationTask(Task)

TaskDispatcherOperation과 연결되어 있는지 여부를 나타내는 값을 반환합니다.Returns a value that indicates whether this Task is associated with a DispatcherOperation.

AsAsyncAction(Task)

시작된 작업을 나타내는 Windows 런타임 비동기 작업을 반환합니다.Returns a Windows Runtime asynchronous action that represents a started task.

적용 대상

스레드 보안

을 제외한의 모든 멤버는 Task Dispose() 스레드로부터 안전 하며 여러 스레드에서 동시에 사용할 수 있습니다.All members of Task, except for Dispose(), are thread-safe and may be used from multiple threads concurrently.

추가 정보