Task 클래스

정의

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

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

설명

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

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

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

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

작업 인스턴스화Task instantiation

다음 예제에서는 만들고 4 개의 작업을 실행 합니다.The following example creates and executes four tasks. 세 가지 작업은 Object형식의 인수를 허용 하는 action이라는 Action<T> 대리자를 실행 합니다.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는 작업 클래스 생성자를 호출 하 여 인스턴스화되고 작업 t2 시작 된 후에만 Start() 메서드를 호출 하 여 시작 됩니다.Task t1 is instantiated by calling a Task class constructor, but is started by calling its Start() method only after task t2 has started.

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

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

  • 작업 t4RunSynchronously() 메서드를 호출 하 여 주 스레드에서 동기적으로 실행 됩니다.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. Wait 메서드가 실행 되는 동안 토큰의 IsCancellationRequested 속성이 true 되거나 true 되 면 메서드는 OperationCanceledException을 throw 합니다.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

하나 이상의 작업이 완료 될 때까지 대기 하는 경우 다음 예제와 같이 Wait 메서드를 호출 하는 스레드에서 실행 중인 작업에서 throw 되는 모든 예외가 전파 됩니다.Note that when you wait for one or more tasks to complete, any exceptions thrown in the running tasks are propagated on the thread that calls the Wait method, as the following example shows. 정상적으로 완료 중 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. 예외는 WaitAll 메서드 호출에서 throw 되며 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 4.6.NET Framework 4.6전에 .NET Framework 버전을 대상으로 하는 앱의 경우 작업의 문화권은 태스크가 실행 되는 스레드의 문화권입니다.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를 초기화합니다.Initializes a new Task with the specified action.

Task(Action, CancellationToken)

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

Task(Action, CancellationToken, TaskCreationOptions)

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

Task(Action, TaskCreationOptions)

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

Task(Action<Object>, Object)

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

Task(Action<Object>, Object, CancellationToken)

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

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

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

Task(Action<Object>, Object, TaskCreationOptions)

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

속성

AsyncState

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

CompletedTask

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

CreationOptions

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

CurrentId

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

Exception

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

Factory

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

Id

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

IsCanceled

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

IsCompleted

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

IsCompletedSuccessfully

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

IsFaulted

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

Status

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

메서드

ConfigureAwait(Boolean)

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

ContinueWith(Action<Task,Object>, Object)

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

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

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

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

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

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

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

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

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

ContinueWith(Action<Task>)

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

ContinueWith(Action<Task>, CancellationToken)

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

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

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

ContinueWith(Action<Task>, TaskContinuationOptions)

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

ContinueWith(Action<Task>, TaskScheduler)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Delay(Int32)

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

Delay(Int32, CancellationToken)

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

Delay(TimeSpan)

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

Delay(TimeSpan, CancellationToken)

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

Dispose()

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

Dispose(Boolean)

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

Equals(Object)

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

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

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

FromCanceled<TResult>(CancellationToken)

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

FromException(Exception)

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

FromException<TResult>(Exception)

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

FromResult<TResult>(TResult)

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

GetAwaiter()

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

GetHashCode()

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

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

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

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

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

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

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

Run(Action, CancellationToken)

지정한 작업을 스레드 풀에서 실행하도록 큐에 대기시키고 작업을 나타내는 Task 개체를 반환합니다.Queues the specified work to run on the thread pool and returns a Task object that represents that work. 취소 토큰으로 작업을 취소할 수 있습니다.A cancellation token allows the work to be cancelled.

Run(Func<Task>)

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

Run(Func<Task>, CancellationToken)

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

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)

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

Run<TResult>(Func<TResult>)

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

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()

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

RunSynchronously(TaskScheduler)

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

Start()

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

Start(TaskScheduler)

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

ToString()

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

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

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

Wait(CancellationToken)

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

Wait(Int32)

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

Wait(Int32, CancellationToken)

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

Wait(TimeSpan)

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

WaitAll(Task[])

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

WaitAll(Task[], CancellationToken)

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

WaitAll(Task[], Int32)

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

WaitAll(Task[], Int32, CancellationToken)

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

WaitAll(Task[], TimeSpan)

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

WaitAny(Task[])

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

WaitAny(Task[], CancellationToken)

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

WaitAny(Task[], Int32)

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

WaitAny(Task[], Int32, CancellationToken)

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

WaitAny(Task[], TimeSpan)

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

WhenAll(IEnumerable<Task>)

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

WhenAll(Task[])

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

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

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

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

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

WhenAny(IEnumerable<Task>)

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

WhenAny(Task[])

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

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

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

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

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

Yield()

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

명시적 인터페이스 구현

IAsyncResult.AsyncWaitHandle

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

IAsyncResult.CompletedSynchronously

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

확장 메서드

DispatcherOperationWait(Task)

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

DispatcherOperationWait(Task, TimeSpan)

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

IsDispatcherOperationTask(Task)

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

AsAsyncAction(Task)

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

적용 대상

스레드 보안

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

추가 정보