Task 클래스

정의

비동기 작업을 나타냅니다.

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 값을 반환하지 않고 일반적으로 비동기적으로 실행되는 단일 작업을 나타냅니다. Task개체는 .NET Framework 4에 처음 도입된 작업 기반 비동기 패턴의 중앙 구성 요소 중 하나입니다. 개체에서 Task 수행하는 작업은 일반적으로 주 애플리케이션 스레드에서 동기적으로 실행되지 않고 스레드 풀 스레드에서 비동기적으로 실행되므로 , 및 IsFaulted 속성뿐만 IsCanceledIsCompleted아니라 속성을 사용하여 Status 작업의 상태를 확인할 수 있습니다. 가장 일반적으로 람다 식은 태스크가 수행할 작업을 지정하는 데 사용됩니다.

값을 반환하는 작업의 경우 클래스를 Task<TResult> 사용합니다.

이 섹션의 내용은 다음과 같습니다.

작업 인스턴스화 예제
작업 만들기 및 실행
작업 만들기 및 실행 분리
하나 이상의 작업이 완료 될 때까지 대기
작업 및 문화권
디버거 개발자용

작업 인스턴스화

다음 예제에서는 4개의 작업을 만들고 실행합니다. 세 태스크는 형식ObjectAction<T> 인수를 허용하는 라는 action대리자를 실행합니다. 네 번째 작업은 태스크 생성 메서드 호출에서 인라인으로 Action 정의된 람다 식(대리자)을 실행합니다. 각 작업은 인스턴스화되고 다른 방식으로 실행됩니다.

  • 작업은 t1 Task 클래스 생성자를 호출하여 인스턴스화되지만 태스크가 시작된 후에 t2 만 메서드를 Start() 호출하여 시작됩니다.

  • 태스크 t2 는 메서드를 호출 TaskFactory.StartNew(Action<Object>, Object) 하여 단일 메서드 호출에서 인스턴스화되고 시작됩니다.

  • 태스크 t3 는 메서드를 호출 Run(Action) 하여 단일 메서드 호출에서 인스턴스화되고 시작됩니다.

  • 작업은 t4 메서드를 호출 RunSynchronously() 하여 주 스레드에서 동기적으로 실행됩니다.

때문에 작업 t4 동기적으로 실행 애플리케이션 주 스레드에서 실행 됩니다. 나머지 작업은 일반적으로 하나 이상의 스레드 풀 스레드에서 비동기적으로 실행됩니다.

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

작업 만들기 및 실행

Task 인스턴스는 다양한 방법으로 만들 수 있습니다. .NET Framework 4.5부터 사용할 수 있는 가장 일반적인 방법은 정적 Run 메서드를 호출하는 것입니다. 메서드는 Run 추가 매개 변수 없이 기본값을 사용하여 작업을 시작하는 간단한 방법을 제공합니다. 다음 예제에서는 메서드를 Run(Action) 사용하여 루프를 시작한 다음 루프 반복 횟수를 표시하는 작업을 시작합니다.

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 메서드입니다. 속성은 Task.Factory 개체를 TaskFactory 반환합니다. 메서드의 오버로드를 TaskFactory.StartNew 사용하면 작업 만들기 옵션 및 작업 스케줄러에 전달할 매개 변수를 지정할 수 있습니다. 다음 예제에서는 메서드를 TaskFactory.StartNew 사용하여 작업을 시작합니다. 이전 예제의 코드와 기능적으로 동일합니다.

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

자세한 예제는 작업 기반 비동기 프로그래밍을 참조하세요.

작업 만들기 및 실행 분리

클래스는 Task 작업을 초기화하지만 실행을 예약하지 않는 생성자도 제공합니다. 성능상의 이유로 Task.Run 또는 TaskFactory.StartNew 메서드는 계산 작업을 만들고 예약하는 데 선호되는 메커니즘이지만 만들기 및 예약을 구분해야 하는 시나리오의 경우 생성자를 사용한 다음 메서드를 호출 Task.Start 하여 나중에 실행할 작업을 예약할 수 있습니다.

하나 이상의 작업이 완료 될 때까지 대기

태스크는 일반적으로 스레드 풀 스레드에서 비동기적으로 실행되므로 태스크를 만들고 시작하는 스레드는 태스크가 인스턴스화되는 즉시 실행을 계속합니다. 경우에 따라 호출 스레드가 주 애플리케이션 스레드인 경우 작업이 실제로 실행되기 전에 앱이 종료될 수 있습니다. 다른 작업에서는 하나 이상의 태스크가 실행을 완료한 경우에만 호출 스레드가 실행을 계속하도록 애플리케이션의 논리를 요구할 수 있습니다. 하나 이상의 작업이 완료되기를 기다리는 메서드를 호출 Wait 하여 호출 스레드의 실행과 실행이 시작되는 비동기 작업을 동기화할 수 있습니다.

단일 작업이 완료되기를 기다리려면 해당 메서드를 호출할 Task.Wait 수 있습니다. 메서드에 대한 호출은 Wait 단일 클래스 인스턴스가 실행을 완료할 때까지 호출 스레드를 차단합니다.

다음 예제에서는 매개 변수가 없는 Wait() 메서드를 호출하여 작업이 완료될 때까지 무조건 대기합니다. 작업은 2초 동안 절전 모드로 메서드를 Thread.Sleep 호출하여 작업을 시뮬레이션합니다.

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

작업이 완료되기를 조건부로 기다릴 수도 있습니다. 및 Wait(TimeSpan) 메서드는 Wait(Int32) 태스크가 완료되거나 시간 제한 간격이 경과할 때까지 호출 스레드를 차단합니다. 다음 예제에서는 2초 동안 절전 모드이지만 1초 제한 시간 값을 정의하는 작업을 시작하므로 호출 스레드는 시간 제한이 만료될 때까지 및 태스크 실행이 완료되기 전에 차단됩니다.

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(Int32, CancellationToken) 메서드를 호출하여 취소 토큰을 Wait(CancellationToken) 제공할 수도 있습니다. 메서드가 실행되는 동안 Wait 토큰의 IsCancellationRequested 속성이 이거나 truetrue 되면 메서드는 을 OperationCanceledExceptionthrow합니다.

경우에 따라 일련의 실행 태스크 중 첫 번째 작업이 완료되기를 기다릴 수 있지만 어떤 작업인지는 신경 쓰지 않습니다. 이를 위해 메서드의 오버로드 중 하나를 호출할 Task.WaitAny 수 있습니다. 다음 예제에서는 세 가지 작업을 만듭니다. 각 작업은 난수 생성기에 의해 결정되는 간격 동안 절전 모드로 유지됩니다. 메서드는 WaitAny(Task[]) 첫 번째 작업이 완료되기를 기다립니다. 그런 다음 이 예제에서는 세 작업 모두의 상태에 대한 정보를 표시합니다.

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 하여 일련의 모든 작업이 완료되기를 기다릴 수도 있습니다. 다음 예제에서는 10개의 작업을 만들고, 10개 작업이 모두 완료될 때까지 기다린 다음, 해당 상태를 표시합니다.

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 하는 스레드에서 전파됩니다. 12개의 작업을 시작하며, 그 중 3개는 정상적으로 완료되고 그 중 3개는 예외를 throw합니다. 나머지 6개 작업 중 3개는 시작하기 전에 취소되고, 3개는 실행되는 동안 취소됩니다. 예외는 메서드 호출에서 WaitAll throw되고 블록에서 try/catch 처리됩니다.

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

작업 기반 비동기 작업의 예외 처리에 대한 자세한 내용은 예외 처리를 참조하세요.

작업 및 문화권

.NET Framework 4.6을 대상으로 하는 데스크톱 앱부터 작업을 만들고 호출하는 스레드의 문화권이 스레드 컨텍스트의 일부가 됩니다. 즉, 태스크가 실행되는 스레드의 현재 문화권에 관계없이 태스크의 현재 문화권은 호출 스레드의 문화권입니다. .NET Framework 4.6 이전의 .NET Framework 버전을 대상으로 하는 앱의 경우 작업의 문화권은 태스크가 실행되는 스레드의 문화권입니다. 자세한 내용은 항목의 "문화권 및 작업 기반 비동기 작업" 섹션을 CultureInfo 참조하세요.

참고

스토어 앱은 기본 문화권을 설정하고 가져오는 Windows 런타임 따릅니다.

디버거 개발자용

사용자 지정 디버거를 구현하는 개발자의 경우 작업의 여러 내부 및 프라이빗 멤버가 유용할 수 있습니다(릴리스에서 릴리스로 변경될 수 있음). m_taskId 필드는 속성의 Id 백업 저장소 역할을 하지만 디버거에서 직접 이 필드에 액세스하는 것이 속성의 getter 메서드를 통해 동일한 값에 액세스하는 것보다 더 효율적일 수 있습니다(s_taskIdCounter카운터는 작업에 사용할 수 있는 다음 ID를 검색하는 데 사용됩니다). 마찬가지로 m_stateFlags 필드는 작업의 현재 수명 주기 단계에 대한 정보를 저장하며 속성을 통해 Status 서도 정보에 액세스할 수 있습니다. m_action 필드는 태스크의 대리자 참조를 저장하고 m_stateObject 필드는 개발자가 작업에 전달한 비동기 상태를 저장합니다. 마지막으로 스택 프레임을 구문 분석하는 디버거의 InternalWait 경우 메서드는 태스크가 대기 작업을 입력할 때 잠재적 마커를 제공합니다.

생성자

Task(Action)

지정된 작업을 사용하여 새 Task를 초기화합니다.

Task(Action, CancellationToken)

지정된 작업을 사용하여 새 TaskCancellationToken을 초기화합니다.

Task(Action, CancellationToken, TaskCreationOptions)

지정된 작업 및 만들기 옵션을 사용하여 새 Task를 초기화합니다.

Task(Action, TaskCreationOptions)

지정된 작업 및 만들기 옵션을 사용하여 새 Task를 초기화합니다.

Task(Action<Object>, Object)

지정된 작업 및 상태를 사용하여 새 Task를 초기화합니다.

Task(Action<Object>, Object, CancellationToken)

지정된 작업, 상태 및 옵션을 사용하여 새 Task를 초기화합니다.

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

지정된 작업, 상태 및 옵션을 사용하여 새 Task를 초기화합니다.

Task(Action<Object>, Object, TaskCreationOptions)

지정된 작업, 상태 및 옵션을 사용하여 새 Task를 초기화합니다.

속성

AsyncState

Task를 만들 때 제공된 상태 개체 또는 제공된 개체가 없는 경우 null을 가져옵니다.

CompletedTask

이미 성공적으로 완료된 작업을 가져옵니다.

CreationOptions

이 작업을 만드는 데 사용된 TaskCreationOptions를 가져옵니다.

CurrentId

현재 실행 중인 Task의 ID를 반환합니다.

Exception

AggregateException가 중간에 종료되도록 하는 Task을 가져옵니다. Task가 완료되었거나 예외를 아직 throw하지 않았을 경우 null을 반환합니다.

Factory

TaskTask<TResult> 인스턴스를 만들고 구성하는 팩터리 메서드에 대한 액세스를 제공합니다.

Id

Task 인스턴스에 대한 ID를 가져옵니다.

IsCanceled

Task 인스턴스가 취소되어 실행을 완료했는지 여부를 가져옵니다.

IsCompleted

작업이 완료되었는지 여부를 나타내는 값을 가져옵니다.

IsCompletedSuccessfully

작업이 완료될 때까지 실행되었는지 여부를 가져옵니다.

IsFaulted

처리되지 않은 예외로 인해 Task가 완료되었는지 여부를 가져옵니다.

Status

이 작업의 TaskStatus를 가져옵니다.

메서드

ConfigureAwait(Boolean)

Task를 기다리는 데 사용되는 awaiter를 구성합니다.

ContinueWith(Action<Task,Object>, Object)

호출자 제공 상태 정보를 받으며 대상 Task이(가) 완료되면 실행되는 연속 작업을 만듭니다.

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

대상 Task가 완료될 때 호출자 제공 상태 정보 및 취소 토큰을 받고 비동기적으로 실행되는 연속 작업을 만듭니다.

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

대상 Task가 완료될 때 호출자 제공 상태 정보 및 취소 토큰을 받고 실행되는 연속 작업을 만듭니다. 연속 작업은 지정된 조건의 집합에 따라 실행되며 지정된 스케줄러를 사용합니다.

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

호출자 제공 상태 정보를 받으며 대상 Task이(가) 완료되면 실행되는 연속 작업을 만듭니다. 연속 작업은 지정된 조건의 집합에 따라 실행됩니다.

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

호출자 제공 상태 정보를 받으며 대상 Task이(가) 완료되면 비동기적으로 실행되는 연속 작업을 만듭니다. 연속 작업은 지정된 스케줄러를 사용합니다.

ContinueWith(Action<Task>)

대상 Task가 완료될 때 비동기적으로 실행되는 연속 작업을 만듭니다.

ContinueWith(Action<Task>, CancellationToken)

대상 Task가 완료될 때 취소 토큰을 받고 비동기적으로 실행되는 연속 작업을 만듭니다.

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

지정된 TaskContinuationOptions에 따라 대상 작업이 완료되면 실행되는 연속 작업을 만듭니다. 연속 작업은 취소 토큰을 받고 지정된 스케줄러를 사용합니다.

ContinueWith(Action<Task>, TaskContinuationOptions)

지정된 TaskContinuationOptions에 따라 대상 작업이 완료되면 실행되는 연속 작업을 만듭니다.

ContinueWith(Action<Task>, TaskScheduler)

대상 Task가 완료될 때 비동기적으로 실행되는 연속 작업을 만듭니다. 연속 작업은 지정된 스케줄러를 사용합니다.

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

호출자 제공 상태 정보를 받으며 대상 Task이(가) 완료되고 값을 가져오면 비동기적으로 실행되는 연속 작업을 만듭니다.

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

대상 Task이(가) 완료되고 값을 가져오면 비동기적으로 실행되는 연속 작업을 만듭니다. 연속 작업은 호출자 제공한 상태 정보 및 취소 토큰을 받습니다.

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

대상 Task가 완료되고 값을 반환하면 지정된 작업 연속 옵션에 따라 실행되는 연속 작업을 만듭니다. 연속 작업은 호출자 제공 상태 정보 및 취소 토큰을 받고 지정된 스케줄러를 사용합니다.

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

대상 Task가 완료되면 지정된 작업 연속 옵션에 따라 실행되는 연속 작업을 만듭니다. 연속 작업은 호출자 제공 상태 정보를 받습니다.

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

대상 Task가 완료될 때 비동기적으로 실행되는 연속 작업을 만듭니다. 연속 작업은 호출자 제공 상태 정보를 받고 지정된 스케줄러를 사용합니다.

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

대상 Task<TResult>이(가) 완료되고 값을 가져오면 비동기적으로 실행되는 연속 작업을 만듭니다.

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

대상 Task이(가) 완료되고 값을 가져오면 비동기적으로 실행되는 연속 작업을 만듭니다. 연속 작업은 취소 토큰을 받습니다.

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

지정된 연속 작업 옵션에 따라 실행되고 값을 반환하는 연속 작업을 만듭니다. 연속 작업에 취소 토큰이 전달되고, 연속 작업은 지정된 스케줄러를 사용합니다.

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

지정된 연속 작업 옵션에 따라 실행되고 값을 반환하는 연속 작업을 만듭니다.

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

대상 Task이(가) 완료되고 값을 가져오면 비동기적으로 실행되는 연속 작업을 만듭니다. 연속 작업은 지정된 스케줄러를 사용합니다.

Delay(Int32)

지정된 시간(밀리초) 후에 완료되는 작업을 만듭니다.

Delay(Int32, CancellationToken)

지정된 시간(밀리초) 후에 완료되는 취소 가능한 작업을 만듭니다.

Delay(TimeSpan)

지정된 시간 간격 후 완료되는 작업을 만듭니다.

Delay(TimeSpan, CancellationToken)

지정된 시간 간격 후 완료되는 취소 가능 작업을 만듭니다.

Dispose()

Task 클래스의 현재 인스턴스에서 사용하는 모든 리소스를 해제합니다.

Dispose(Boolean)

Task를 삭제하고 관리되지 않는 해당 리소스를 모두 해제합니다.

Equals(Object)

지정된 개체가 현재 개체와 같은지 확인합니다.

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

지정된 취소 토큰을 사용하여 취소로 인해 완료된 Task를 만듭니다.

FromCanceled<TResult>(CancellationToken)

지정된 취소 토큰을 사용하여 취소로 인해 완료된 Task<TResult>를 만듭니다.

FromException(Exception)

지정된 예외를 사용하여 완료된 Task를 만듭니다.

FromException<TResult>(Exception)

지정된 예외를 사용하여 완료된 Task<TResult>을 만듭니다.

FromResult<TResult>(TResult)

지정된 결과로 성공적으로 완료되는 Task<TResult>을 만듭니다.

GetAwaiter()

Task를 기다리는 데 사용되는 awaiter를 가져옵니다.

GetHashCode()

기본 해시 함수로 작동합니다.

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

현재 인스턴스의 Type을 가져옵니다.

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

현재 Object의 단순 복사본을 만듭니다.

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

지정한 작업을 스레드 풀에서 실행하도록 큐에 대기시키고 작업을 나타내는 Task 개체를 반환합니다.

Run(Action, CancellationToken)

지정한 작업을 스레드 풀에서 실행하도록 큐에 대기시키고 작업을 나타내는 Task 개체를 반환합니다. 취소 토큰을 사용하면 작업이 아직 시작되지 않은 경우 작업을 취소할 수 있습니다.

Run(Func<Task>)

지정한 작업을 스레드 풀에서 실행하도록 큐에 대기시키고 function에서 반환된 작업에 대한 프록시를 반환합니다.

Run(Func<Task>, CancellationToken)

지정한 작업을 스레드 풀에서 실행하도록 큐에 대기시키고 function에서 반환된 작업에 대한 프록시를 반환합니다. 취소 토큰을 사용하면 작업이 아직 시작되지 않은 경우 작업을 취소할 수 있습니다.

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

지정된 작업을 스레드 풀에서 실행하도록 큐에 대기시키고 function에서 반환된 Task(TResult)에 대한 프록시를 반환합니다. 취소 토큰을 사용하면 작업이 아직 시작되지 않은 경우 작업을 취소할 수 있습니다.

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

지정된 작업을 스레드 풀에서 실행하도록 큐에 대기시키고 function에서 반환된 Task(TResult)에 대한 프록시를 반환합니다.

Run<TResult>(Func<TResult>)

지정한 작업을 스레드 풀에서 실행하도록 큐에 대기시키고 작업을 나타내는 Task<TResult> 개체를 반환합니다. 취소 토큰을 사용하면 작업이 아직 시작되지 않은 경우 작업을 취소할 수 있습니다.

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

지정한 작업을 스레드 풀에서 실행하도록 큐에 대기시키고 작업을 나타내는 Task(TResult) 개체를 반환합니다.

RunSynchronously()

현재 Task에서 TaskScheduler를 동기적으로 실행합니다.

RunSynchronously(TaskScheduler)

제공된 Task에서 TaskScheduler를 동기적으로 실행합니다.

Start()

Task를 시작하고 현재 TaskScheduler에 실행을 예약합니다.

Start(TaskScheduler)

Task를 시작하고 지정된 TaskScheduler에 실행을 예약합니다.

ToString()

현재 개체를 나타내는 문자열을 반환합니다.

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

Task의 실행이 완료되기를 기다립니다.

Wait(CancellationToken)

Task의 실행이 완료되기를 기다립니다. 작업이 완료되기 전에 취소 토큰이 취소되면 대기가 종료됩니다.

Wait(Int32)

Task가 지정된 시간(밀리초) 내에 실행을 완료할 때까지 기다립니다.

Wait(Int32, CancellationToken)

Task의 실행이 완료되기를 기다립니다. 작업이 완료되기 전에 취소 토큰이 취소되었거나 시간 제한 간격이 경과되었으면 대기가 종료됩니다.

Wait(TimeSpan)

Task가 지정된 시간 간격 내에 실행을 완료할 때까지 기다립니다.

Wait(TimeSpan, CancellationToken)

Task의 실행이 완료되기를 기다립니다.

WaitAll(Task[])

제공된 모든 Task 개체의 실행이 완료되기를 기다립니다.

WaitAll(Task[], CancellationToken)

대기가 취소되지 않는 경우 제공된 모든 Task 개체가 실행을 완료하기를 기다립니다.

WaitAll(Task[], Int32)

모든 제공된 Task 개체가 지정된 시간(밀리초) 내에 실행을 완료할 때까지 기다립니다.

WaitAll(Task[], Int32, CancellationToken)

제공된 모든 Task 개체가 지정된 시간(밀리초) 내에 실행을 완료하기를 기다리거나 대기가 취소될 때까지 기다립니다.

WaitAll(Task[], TimeSpan)

모든 제공된 취소 가능한 Task 개체가 지정된 시간 간격 내에 실행을 완료할 때까지 기다립니다.

WaitAny(Task[])

제공된 Task 개체 중 임의 개체의 실행이 완료되기를 기다립니다.

WaitAny(Task[], CancellationToken)

대기가 취소되지 않는 경우 제공된 모든 Task 개체가 실행을 완료하기를 기다립니다.

WaitAny(Task[], Int32)

모든 제공된 Task 개체가 지정된 시간(밀리초) 내에 실행을 완료할 때까지 기다립니다.

WaitAny(Task[], Int32, CancellationToken)

모든 제공된 Task 개체가 지정된 시간(밀리초) 내에 실행을 완료하기를 기다리거나 취소 토큰이 취소될 때까지 기다립니다.

WaitAny(Task[], TimeSpan)

모든 제공된 Task 개체가 지정된 시간 간격 내에 실행을 완료할 때까지 기다립니다.

WaitAsync(CancellationToken)

TaskTask 작업이 완료되거나 지정된 에 취소가 요청되었을 때 완료될 을 CancellationToken 가져옵니다.

WaitAsync(TimeSpan)

TaskTask 작업이 완료되거나 지정된 시간 제한이 만료될 때 완료되는 을 가져옵니다.

WaitAsync(TimeSpan, CancellationToken)

TaskTask 작업이 완료될 때, 지정된 시간 제한이 만료되거나 지정된 에 취소가 요청된 경우 완료되는 을 CancellationToken 가져옵니다.

WhenAll(IEnumerable<Task>)

열거 가능한 컬렉션의 모든 Task 개체가 완료되면 완료될 작업을 만듭니다.

WhenAll(Task[])

배열의 모든 Task 개체가 완료되면 완료될 작업을 만듭니다.

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

열거 가능한 컬렉션의 모든 Task<TResult> 개체가 완료되면 완료될 작업을 만듭니다.

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

배열의 모든 Task<TResult> 개체가 완료되면 완료될 작업을 만듭니다.

WhenAny(IEnumerable<Task>)

제공된 작업을 모두 완료했을 때 완료할 작업을 만듭니다.

WhenAny(Task, Task)

제공된 작업 중 하나가 완료했을 때 완료할 작업을 만듭니다.

WhenAny(Task[])

제공된 작업을 모두 완료했을 때 완료할 작업을 만듭니다.

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

제공된 작업을 모두 완료했을 때 완료할 작업을 만듭니다.

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

제공된 작업 중 하나가 완료했을 때 완료할 작업을 만듭니다.

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

제공된 작업을 모두 완료했을 때 완료할 작업을 만듭니다.

Yield()

대기할 때 현재 컨텍스트로 비동기적으로 전환되는 awaitable 작업을 만듭니다.

명시적 인터페이스 구현

IAsyncResult.AsyncWaitHandle

작업이 완료되기를 기다리는 데 사용할 수 있는 WaitHandle을 가져옵니다.

IAsyncResult.CompletedSynchronously

작업이 동기적으로 완료되었는지 여부를 나타내는 표시를 가져옵니다.

확장 메서드

DispatcherOperationWait(Task)

기본 DispatcherOperation이 완료되기를 무기한 기다립니다.

DispatcherOperationWait(Task, TimeSpan)

그런 다음 지정된 시간 동안 기본 DispatcherOperation이 완료되기를 기다립니다.

IsDispatcherOperationTask(Task)

TaskDispatcherOperation과 연결되어 있는지 여부를 나타내는 값을 반환합니다.

AsAsyncAction(Task)

시작된 작업을 나타내는 Windows 런타임 비동기 작업을 반환합니다.

적용 대상

스레드 보안

를 제외한 Dispose()Task모든 멤버는 스레드로부터 안전하며 여러 스레드에서 동시에 사용할 수 있습니다.

추가 정보