Task Task Task Task Class

정의

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

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

설명

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

다음 예제에서는 만들고 4 개의 작업을 실행 합니다.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.NET Framework 4.5, 정적 호출 하는 것 Run 메서드.The most common approach, which is available starting with the .NET Framework 4.5.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.NET Framework 4에 정적 TaskFactory.StartNew 메서드.An alternative, and the most common method to start a task in .NET Framework 4.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 any 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 has 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 determine 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

하나 이상의 작업이 완료 되기를 기다릴 때 호출 하는 스레드에서 실행 중인 작업에서 throw 된 예외 전파는 참고를 Wait 메서드를 다음 예제와 같이 합니다.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. 정상적으로 완료 중 3 개는 12 작업 및 세 가지 예외는 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.NET Framework 4.6, 스레드 컨텍스트의 일부가 만들고 작업을 호출 하는 스레드의 문화권입니다.Starting with desktop apps that target the .NET Framework 4.6.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의 버전을 대상으로 하는 앱에 대 한는 .NET Framework 4.6.NET Framework 4.6, 작업의 문화권은 태스크가 실행 하는 스레드의 문화권입니다.For apps that target versions of the .NET Framework prior to the .NET Framework 4.6.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(Action) Task(Action) Task(Action)

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

Task(Action, CancellationToken) Task(Action, CancellationToken) Task(Action, CancellationToken) Task(Action, CancellationToken)

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

Task(Action, CancellationToken, TaskCreationOptions) Task(Action, CancellationToken, TaskCreationOptions) Task(Action, CancellationToken, TaskCreationOptions) Task(Action, CancellationToken, TaskCreationOptions)

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

Task(Action, TaskCreationOptions) Task(Action, TaskCreationOptions) Task(Action, TaskCreationOptions) Task(Action, TaskCreationOptions)

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

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

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

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

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

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

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

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

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

속성

AsyncState AsyncState AsyncState AsyncState

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

CompletedTask CompletedTask CompletedTask CompletedTask

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

CreationOptions CreationOptions CreationOptions CreationOptions

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

CurrentId CurrentId CurrentId CurrentId

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

Exception Exception Exception 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 Factory Factory Factory

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

Id Id Id Id

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

IsCanceled IsCanceled IsCanceled IsCanceled

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

IsCompleted IsCompleted IsCompleted IsCompleted

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

IsCompletedSuccessfully IsCompletedSuccessfully IsCompletedSuccessfully IsCompletedSuccessfully

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

IsFaulted IsFaulted IsFaulted IsFaulted

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

Status Status Status Status

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

메서드

ConfigureAwait(Boolean) ConfigureAwait(Boolean) ConfigureAwait(Boolean) ConfigureAwait(Boolean)

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

ContinueWith(Action<Task,Object>, Object) ContinueWith(Action<Task,Object>, Object) ContinueWith(Action<Task,Object>, Object) 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) ContinueWith(Action<Task,Object>, Object, CancellationToken) ContinueWith(Action<Task,Object>, Object, CancellationToken) 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) ContinueWith(Action<Task,Object>, Object, CancellationToken, TaskContinuationOptions, TaskScheduler) ContinueWith(Action<Task,Object>, Object, CancellationToken, TaskContinuationOptions, TaskScheduler) 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) ContinueWith(Action<Task,Object>, Object, TaskContinuationOptions) ContinueWith(Action<Task,Object>, Object, TaskContinuationOptions) 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) ContinueWith(Action<Task,Object>, Object, TaskScheduler) ContinueWith(Action<Task,Object>, Object, TaskScheduler) 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>) ContinueWith(Action<Task>) ContinueWith(Action<Task>) ContinueWith(Action<Task>)

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

ContinueWith(Action<Task>, CancellationToken) ContinueWith(Action<Task>, CancellationToken) ContinueWith(Action<Task>, CancellationToken) 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) ContinueWith(Action<Task>, CancellationToken, TaskContinuationOptions, TaskScheduler) ContinueWith(Action<Task>, CancellationToken, TaskContinuationOptions, TaskScheduler) 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) ContinueWith(Action<Task>, TaskContinuationOptions) ContinueWith(Action<Task>, TaskContinuationOptions) ContinueWith(Action<Task>, TaskContinuationOptions)

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

ContinueWith(Action<Task>, TaskScheduler) ContinueWith(Action<Task>, TaskScheduler) ContinueWith(Action<Task>, TaskScheduler) 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) ContinueWith<TResult>(Func<Task,Object,TResult>, Object) ContinueWith<TResult>(Func<Task,Object,TResult>, Object) 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) ContinueWith<TResult>(Func<Task,Object,TResult>, Object, CancellationToken) ContinueWith<TResult>(Func<Task,Object,TResult>, Object, CancellationToken) 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) ContinueWith<TResult>(Func<Task,Object,TResult>, Object, CancellationToken, TaskContinuationOptions, TaskScheduler) ContinueWith<TResult>(Func<Task,Object,TResult>, Object, CancellationToken, TaskContinuationOptions, TaskScheduler) 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) ContinueWith<TResult>(Func<Task,Object,TResult>, Object, TaskContinuationOptions) ContinueWith<TResult>(Func<Task,Object,TResult>, Object, TaskContinuationOptions) 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) ContinueWith<TResult>(Func<Task,Object,TResult>, Object, TaskScheduler) ContinueWith<TResult>(Func<Task,Object,TResult>, Object, TaskScheduler) 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>) ContinueWith<TResult>(Func<Task,TResult>) ContinueWith<TResult>(Func<Task,TResult>) 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) ContinueWith<TResult>(Func<Task,TResult>, CancellationToken) ContinueWith<TResult>(Func<Task,TResult>, CancellationToken) 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) ContinueWith<TResult>(Func<Task,TResult>, CancellationToken, TaskContinuationOptions, TaskScheduler) ContinueWith<TResult>(Func<Task,TResult>, CancellationToken, TaskContinuationOptions, TaskScheduler) 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) ContinueWith<TResult>(Func<Task,TResult>, TaskContinuationOptions) ContinueWith<TResult>(Func<Task,TResult>, TaskContinuationOptions) 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) ContinueWith<TResult>(Func<Task,TResult>, TaskScheduler) ContinueWith<TResult>(Func<Task,TResult>, TaskScheduler) 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) Delay(Int32) Delay(Int32) Delay(Int32)

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

Delay(Int32, CancellationToken) Delay(Int32, CancellationToken) Delay(Int32, CancellationToken) Delay(Int32, CancellationToken)

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

Delay(TimeSpan) Delay(TimeSpan) Delay(TimeSpan) Delay(TimeSpan)

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

Delay(TimeSpan, CancellationToken) Delay(TimeSpan, CancellationToken) Delay(TimeSpan, CancellationToken) Delay(TimeSpan, CancellationToken)

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

Dispose() Dispose() Dispose() Dispose()

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

Dispose(Boolean) Dispose(Boolean) Dispose(Boolean) Dispose(Boolean)

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

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

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

(Inherited from Object)
FromCanceled(CancellationToken) FromCanceled(CancellationToken) FromCanceled(CancellationToken) FromCanceled(CancellationToken)

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

FromCanceled<TResult>(CancellationToken) FromCanceled<TResult>(CancellationToken) FromCanceled<TResult>(CancellationToken) FromCanceled<TResult>(CancellationToken)

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

FromException(Exception) FromException(Exception) FromException(Exception) FromException(Exception)

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

FromException<TResult>(Exception) FromException<TResult>(Exception) FromException<TResult>(Exception) FromException<TResult>(Exception)

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

FromResult<TResult>(TResult) FromResult<TResult>(TResult) FromResult<TResult>(TResult) FromResult<TResult>(TResult)

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

GetAwaiter() GetAwaiter() GetAwaiter() GetAwaiter()

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

GetHashCode() GetHashCode() GetHashCode() GetHashCode()

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

(Inherited from Object)
GetType() GetType() GetType() GetType()

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

(Inherited from Object)
MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone()

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

(Inherited from Object)
Run(Action) Run(Action) Run(Action) 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) Run(Action, CancellationToken) Run(Action, CancellationToken) 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.

Run(Func<Task>) Run(Func<Task>) Run(Func<Task>) 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) Run(Func<Task>, CancellationToken) Run(Func<Task>, CancellationToken) 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.

Run<TResult>(Func<Task<TResult>>) Run<TResult>(Func<Task<TResult>>) Run<TResult>(Func<Task<TResult>>) 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.

Run<TResult>(Func<Task<TResult>>, CancellationToken) Run<TResult>(Func<Task<TResult>>, CancellationToken) Run<TResult>(Func<Task<TResult>>, CancellationToken) 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>) Run<TResult>(Func<TResult>) Run<TResult>(Func<TResult>) 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.

Run<TResult>(Func<TResult>, CancellationToken) Run<TResult>(Func<TResult>, CancellationToken) Run<TResult>(Func<TResult>, CancellationToken) 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. 취소 토큰으로 작업을 취소할 수 있습니다.A cancellation token allows the work to be cancelled.

RunSynchronously() RunSynchronously() RunSynchronously() RunSynchronously()

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

RunSynchronously(TaskScheduler) RunSynchronously(TaskScheduler) RunSynchronously(TaskScheduler) RunSynchronously(TaskScheduler)

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

Start() Start() Start() Start()

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

Start(TaskScheduler) Start(TaskScheduler) Start(TaskScheduler) Start(TaskScheduler)

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

ToString() ToString() ToString() ToString()

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

(Inherited from Object)
Wait() Wait() Wait() Wait()

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

Wait(CancellationToken) Wait(CancellationToken) Wait(CancellationToken) 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) Wait(Int32) Wait(Int32) Wait(Int32)

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

Wait(Int32, CancellationToken) Wait(Int32, CancellationToken) Wait(Int32, CancellationToken) 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) Wait(TimeSpan) Wait(TimeSpan) Wait(TimeSpan)

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

WaitAll(Task[]) WaitAll(Task[]) WaitAll(Task[]) WaitAll(Task[])

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

WaitAll(Task[], CancellationToken) WaitAll(Task[], CancellationToken) WaitAll(Task[], CancellationToken) WaitAll(Task[], CancellationToken)

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

WaitAll(Task[], Int32) WaitAll(Task[], Int32) WaitAll(Task[], Int32) 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) WaitAll(Task[], Int32, CancellationToken) WaitAll(Task[], Int32, CancellationToken) 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) WaitAll(Task[], TimeSpan) WaitAll(Task[], TimeSpan) WaitAll(Task[], TimeSpan)

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

WaitAny(Task[]) WaitAny(Task[]) WaitAny(Task[]) WaitAny(Task[])

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

WaitAny(Task[], CancellationToken) WaitAny(Task[], CancellationToken) WaitAny(Task[], CancellationToken) WaitAny(Task[], CancellationToken)

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

WaitAny(Task[], Int32) WaitAny(Task[], Int32) WaitAny(Task[], Int32) 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) WaitAny(Task[], Int32, CancellationToken) WaitAny(Task[], Int32, CancellationToken) 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) WaitAny(Task[], TimeSpan) WaitAny(Task[], TimeSpan) WaitAny(Task[], TimeSpan)

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

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

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

WhenAll(Task[]) WhenAll(Task[]) WhenAll(Task[]) 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>>) WhenAll<TResult>(IEnumerable<Task<TResult>>) WhenAll<TResult>(IEnumerable<Task<TResult>>) 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>[]) WhenAll<TResult>(Task<TResult>[]) WhenAll<TResult>(Task<TResult>[]) 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>) WhenAny(IEnumerable<Task>) WhenAny(IEnumerable<Task>) WhenAny(IEnumerable<Task>)

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

WhenAny(Task[]) WhenAny(Task[]) WhenAny(Task[]) WhenAny(Task[])

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

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

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

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

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

Yield() Yield() Yield() Yield()

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

명시적 인터페이스 구현

IAsyncResult.AsyncWaitHandle IAsyncResult.AsyncWaitHandle IAsyncResult.AsyncWaitHandle IAsyncResult.AsyncWaitHandle

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

IAsyncResult.CompletedSynchronously IAsyncResult.CompletedSynchronously IAsyncResult.CompletedSynchronously IAsyncResult.CompletedSynchronously

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

확장 메서드

DispatcherOperationWait(Task) DispatcherOperationWait(Task) DispatcherOperationWait(Task) DispatcherOperationWait(Task)

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

DispatcherOperationWait(Task, TimeSpan) DispatcherOperationWait(Task, TimeSpan) DispatcherOperationWait(Task, TimeSpan) DispatcherOperationWait(Task, TimeSpan)

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

IsDispatcherOperationTask(Task) IsDispatcherOperationTask(Task) IsDispatcherOperationTask(Task) IsDispatcherOperationTask(Task)

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

AsAsyncAction(Task) AsAsyncAction(Task) AsAsyncAction(Task) 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.

추가 정보