Task 생성자

참조

정의

네임스페이스:: System.Threading.Tasks

어셈블리:: System.Threading.Tasks.dll

어셈블리:: System.Runtime.dll

어셈블리:: mscorlib.dll

어셈블리:: netstandard.dll

중요

일부 정보는 릴리스되기 전에 상당 부분 수정될 수 있는 시험판 제품과 관련이 있습니다. Microsoft는 여기에 제공된 정보에 대해 어떠한 명시적이거나 묵시적인 보증도 하지 않습니다.

새 Task를 초기화합니다.

오버로드

Task(Action)	지정된 작업을 사용하여 새 Task를 초기화합니다.
Task(Action, CancellationToken)	지정된 작업을 사용하여 새 Task 및 CancellationToken을 초기화합니다.
Task(Action, TaskCreationOptions)	지정된 작업 및 만들기 옵션을 사용하여 새 Task를 초기화합니다.
Task(Action<Object>, Object)	지정된 작업 및 상태를 사용하여 새 Task를 초기화합니다.
Task(Action, CancellationToken, TaskCreationOptions)	지정된 작업 및 만들기 옵션을 사용하여 새 Task를 초기화합니다.
Task(Action<Object>, Object, CancellationToken)	지정된 작업, 상태 및 CancellationToken를 사용하여 새 Task 를 초기화합니다.
Task(Action<Object>, Object, TaskCreationOptions)	지정된 작업, 상태 및 옵션을 사용하여 새 Task를 초기화합니다.
Task(Action<Object>, Object, CancellationToken, TaskCreationOptions)	지정된 작업, 상태 및 옵션을 사용하여 새 Task를 초기화합니다.

Task(Action)

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

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

public:
 Task(Action ^ action);

public Task (Action action);

new System.Threading.Tasks.Task : Action -> System.Threading.Tasks.Task

Public Sub New (action As Action)

매개 변수

action: Action

작업에서 실행할 코드를 나타내는 대리자입니다.

예외

ArgumentNullException

action 인수가 null인 경우

예제

다음 예제에서는 생성자를 사용하여 Task(Action) 지정된 디렉터리에서 파일 이름을 검색하는 작업을 만듭니다. 모든 작업은 파일 이름을 단일 ConcurrentBag<T> 개체에 씁니다. 그런 다음, 메서드를 WaitAll(Task[]) 호출하여 모든 작업이 완료되었는지 확인하고 개체에 기록 ConcurrentBag<T> 된 총 파일 이름 수를 표시합니다.

using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.IO;
using System.Threading.Tasks;

public class Example
{
   public static async Task Main()
   {
      var list = new ConcurrentBag<string>();
      string[] dirNames = { ".", ".." };
      List<Task> tasks = new List<Task>();
      foreach (var dirName in dirNames) {
         Task t = new Task( () => { foreach(var path in Directory.GetFiles(dirName))
                                    list.Add(path); }  );
         tasks.Add(t);
         t.Start();
      }
      await Task.WhenAll(tasks.ToArray());
      foreach (Task t in tasks)
         Console.WriteLine("Task {0} Status: {1}", t.Id, t.Status);
         
      Console.WriteLine("Number of files read: {0}", list.Count);
   }
}
// The example displays output like the following:
//       Task 1 Status: RanToCompletion
//       Task 2 Status: RanToCompletion
//       Number of files read: 23

open System.Collections.Concurrent
open System.IO
open System.Threading.Tasks

let main =
    task {
        let list = ConcurrentBag<string>()
        let dirNames = [ "."; ".." ]
        let tasks = ResizeArray()

        for dirName in dirNames do
            let t =
                new Task(fun () ->
                    for path in Directory.GetFiles dirName do
                        list.Add path)

            tasks.Add t
            t.Start()

        do! tasks.ToArray() |> Task.WhenAll

        for t in tasks do
            printfn $"Task {t.Id} Status: {t.Status}"

        printfn $"Number of files read: {list.Count}"
    }

// The example displays output like the following:
//       Task 1 Status: RanToCompletion
//       Task 2 Status: RanToCompletion
//       Number of files read: 23

Imports System.Collections.Concurrent
Imports System.Collections.Generic
Imports System.IO
Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      Dim list As New ConcurrentBag(Of String)()
      Dim dirNames() As String = { ".", ".." }
      Dim tasks As New List(Of Task)()
      For Each dirName In dirNames 
         Dim t As New Task( Sub()
                               For Each path In Directory.GetFiles(dirName)
                                  list.Add(path)
                               Next
                            End Sub  )
         tasks.Add(t)
         t.Start()
      Next
      Task.WaitAll(tasks.ToArray())
      For Each t In tasks
         Console.WriteLine("Task {0} Status: {1}", t.Id, t.Status)
      Next   
      Console.WriteLine("Number of files read: {0}", list.Count)
   End Sub
End Module
' The example displays output like the following:
'       Task 1 Status: RanToCompletion
'       Task 2 Status: RanToCompletion
'       Number of files read: 23

다음 예제는 단일 작업에서 작업을 인스턴스화하고 실행하는 데 메서드를 사용했다 Run(Action) 는 점을 제외하고 동일합니다. 메서드는 작업을 나타내는 개체를 반환 Task 합니다.

using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.IO;
using System.Threading.Tasks;

public class Example
{
   public static void Main()
   {
      var list = new ConcurrentBag<string>();
      string[] dirNames = { ".", ".." };
      List<Task> tasks = new List<Task>();
      foreach (var dirName in dirNames) {
         Task t = Task.Run( () => { foreach(var path in Directory.GetFiles(dirName)) 
                                       list.Add(path); }  );
         tasks.Add(t);
      }
      Task.WaitAll(tasks.ToArray());
      foreach (Task t in tasks)
         Console.WriteLine("Task {0} Status: {1}", t.Id, t.Status);
         
      Console.WriteLine("Number of files read: {0}", list.Count);
   }
}
// The example displays output like the following:
//       Task 1 Status: RanToCompletion
//       Task 2 Status: RanToCompletion
//       Number of files read: 23

open System.Collections.Concurrent
open System.IO
open System.Threading.Tasks

let list = ConcurrentBag<string>()
let dirNames = [ "."; ".." ]
let tasks = ResizeArray()

for dirName in dirNames do
    let t =
        Task.Run(fun () ->
            for path in Directory.GetFiles dirName do
                list.Add path)

    tasks.Add t

tasks.ToArray() |> Task.WaitAll

for t in tasks do
    printfn $"Task {t.Id} Status: {t.Status}"

printfn $"Number of files read: {list.Count}"

// The example displays output like the following:
//       Task 1 Status: RanToCompletion
//       Task 2 Status: RanToCompletion
//       Number of files read: 23

Imports System.Collections.Concurrent
Imports System.Collections.Generic
Imports System.IO
Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      Dim list As New ConcurrentBag(Of String)()
      Dim dirNames() As String = { ".", ".." }
      Dim tasks As New List(Of Task)()
      For Each dirName In dirNames 
         Dim t As Task = Task.Run( Sub()
                                      For Each path In Directory.GetFiles(dirName) 
                                         list.Add(path)
                                      Next
                                   End Sub  )
         tasks.Add(t)
      Next
      Task.WaitAll(tasks.ToArray())
      For Each t In tasks
         Console.WriteLine("Task {0} Status: {1}", t.Id, t.Status)
      Next   
      Console.WriteLine("Number of files read: {0}", list.Count)
   End Sub
End Module
' The example displays output like the following:
'       Task 1 Status: RanToCompletion
'       Task 2 Status: RanToCompletion
'       Number of files read: 23

설명

이 생성자는 작업을 만들고 시작해야 하는 고급 시나리오에서만 사용해야 합니다.

이 생성자를 호출하는 대신 개체를 인스턴스화 Task 하고 작업을 시작하는 가장 일반적인 방법은 정적 Task.Run(Action) 또는 TaskFactory.StartNew(Action) 메서드를 호출하는 것입니다.

API 소비자가 대기할 항목을 갖기 위해서만 작업이 없는 작업이 필요한 경우 을 TaskCompletionSource<TResult> 사용해야 합니다.

추가 정보

Run(Action)

적용 대상

Task(Action, CancellationToken)

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

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

public:
 Task(Action ^ action, System::Threading::CancellationToken cancellationToken);

public Task (Action action, System.Threading.CancellationToken cancellationToken);

new System.Threading.Tasks.Task : Action * System.Threading.CancellationToken -> System.Threading.Tasks.Task

Public Sub New (action As Action, cancellationToken As CancellationToken)

매개 변수

action: Action

작업에서 실행할 코드를 나타내는 대리자입니다.

cancellationToken: CancellationToken

새 작업이 관찰할 CancellationToken입니다.

예외

ObjectDisposedException

제공된 CancellationToken가 이미 삭제된 경우

ArgumentNullException

action 인수가 null입니다.

예제

다음 예제에서는 생성자를 호출 Task(Action, CancellationToken) 하여 C:\Windows\System32 디렉터리에 파일을 반복하는 작업을 만듭니다. 람다 식은 메서드를 Parallel.ForEach 호출하여 개체에 각 파일에 List<T> 대한 정보를 추가합니다. 루프에서 호출된 Parallel.ForEach 분리된 각 중첩 작업은 취소 토큰의 상태를 확인하고 취소가 요청되면 메서드를 호출합니다 CancellationToken.ThrowIfCancellationRequested . 메서드는 CancellationToken.ThrowIfCancellationRequested 호출 스레드가 메서드를 OperationCanceledExceptioncatch 호출할 때 블록에서 처리되는 예외를 Task.Wait throw합니다. Start 그런 다음 메서드가 호출되어 작업을 시작합니다.

using System;
using System.Collections.Generic;
using System.IO;
using System.Threading;
using System.Threading.Tasks;

public class Example
{
   public static async Task Main()
   {
      var tokenSource = new CancellationTokenSource();
      var token = tokenSource.Token;
      var files = new List<Tuple<string, string, long, DateTime>>();
      
      var t = new Task(() => { string dir = "C:\\Windows\\System32\\";
                               object obj = new Object();
                               if (Directory.Exists(dir)) {
                                  Parallel.ForEach(Directory.GetFiles(dir),
                                  f => {
                                          if (token.IsCancellationRequested)
                                             token.ThrowIfCancellationRequested();
                                          var fi = new FileInfo(f);
                                          lock(obj) {
                                             files.Add(Tuple.Create(fi.Name, fi.DirectoryName, fi.Length, fi.LastWriteTimeUtc));          
                                          }
                                     });
                                }
                              } , token);
      t.Start();
      tokenSource.Cancel();
      try {
         await t; 
         Console.WriteLine("Retrieved information for {0} files.", files.Count);
      }
      catch (AggregateException e) {
         Console.WriteLine("Exception messages:");
         foreach (var ie in e.InnerExceptions)
            Console.WriteLine("   {0}: {1}", ie.GetType().Name, ie.Message);

         Console.WriteLine("\nTask status: {0}", t.Status);       
      }
      finally {
         tokenSource.Dispose();
      }
   }
}
// The example displays the following output:
//       Exception messages:
//          TaskCanceledException: A task was canceled.
//       
//       Task status: Canceled

open System
open System.IO
open System.Threading
open System.Threading.Tasks

let main =
    task {
        use tokenSource = new CancellationTokenSource()
        let token = tokenSource.Token
        let files = ResizeArray()

        let t =
            new Task(
                (fun () ->
                    let dir = @"C:\Windows\System32\"
                    let obj = obj ()

                    if Directory.Exists dir then
                        Parallel.ForEach(
                            Directory.GetFiles dir,
                            fun f ->
                                if token.IsCancellationRequested then
                                    token.ThrowIfCancellationRequested()

                                let fi = FileInfo f
                                lock obj (fun () -> files.Add(fi.Name, fi.DirectoryName, fi.Length, fi.LastWriteTimeUtc))
                        )
                        |> ignore),
                token
            )

        t.Start()
        tokenSource.Cancel()

        try
            do! t
            printfn $"Retrieved information for {files.Count} files."

        with :? AggregateException as e ->
            printfn "Exception messages:"

            for ie in e.InnerExceptions do
                printfn $"   {ie.GetType().Name}: {ie.Message}"

            printfn $"Task status: {t.Status}"
    }

main.Wait()

// The example displays the following output:
//       Exception messages:
//          TaskCanceledException: A task was canceled.
//
//       Task status: Canceled

Imports System.Collections.Generic
Imports System.IO
Imports System.Threading
Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      Dim tokenSource As New CancellationTokenSource()
      Dim token As CancellationToken = tokenSource.Token
      Dim files As New List(Of Tuple(Of String, String, Long, Date))()
      Dim t As New Task(Sub()
                           Dim dir As String = "C:\Windows\System32\"
                           Dim obj As New Object()
                           If Directory.Exists(dir)Then
                              Parallel.ForEach(Directory.GetFiles(dir), 
                                 Sub(f)
                                    If token.IsCancellationRequested Then
                                       token.ThrowIfCancellationRequested()
                                    End If  
                                    Dim fi As New FileInfo(f)
                                    SyncLock(obj)
                                       files.Add(Tuple.Create(fi.Name, fi.DirectoryName, fi.Length, fi.LastWriteTimeUtc))          
                                    End SyncLock
                                 End Sub)
                           End If
                        End Sub, token)
      t.Start()
      tokenSource.Cancel()
      Try
         t.Wait() 
         Console.WriteLine("Retrieved information for {0} files.", files.Count)
      Catch e As AggregateException
         Console.WriteLine("Exception messages:")
         For Each ie As Exception In e.InnerExceptions
            Console.WriteLine("   {0}:{1}", ie.GetType().Name, ie.Message)
         Next
         Console.WriteLine()
         Console.WriteLine("Task status: {0}", t.Status)       
      Finally
         tokenSource.Dispose()
      End Try
   End Sub
End Module
' The example displays the following output:
'       Exception messages:
'          TaskCanceledException: A task was canceled.
'       
'       Task status: Canceled

설명

이 생성자를 호출하는 대신 개체를 인스턴스화 Task 하고 작업을 시작하는 가장 일반적인 방법은 정적 Task.Run(Action, CancellationToken) 및 TaskFactory.StartNew(Action, CancellationToken) 메서드를 호출하는 것입니다. 이 생성자가 제공하는 유일한 이점은 개체 인스턴스화를 작업 호출과 분리할 수 있다는 것입니다.

자세한 내용은 작업 병렬 처리(작업 병렬 라이브러리) 및 관리되는 스레드의 취소를 참조하세요.

적용 대상

Task(Action, TaskCreationOptions)

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

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

public:
 Task(Action ^ action, System::Threading::Tasks::TaskCreationOptions creationOptions);

public Task (Action action, System.Threading.Tasks.TaskCreationOptions creationOptions);

new System.Threading.Tasks.Task : Action * System.Threading.Tasks.TaskCreationOptions -> System.Threading.Tasks.Task

Public Sub New (action As Action, creationOptions As TaskCreationOptions)

매개 변수

action: Action

작업에서 실행할 코드를 나타내는 대리자입니다.

creationOptions: TaskCreationOptions

작업의 동작을 사용자 지정하는 데 사용할 TaskCreationOptions입니다.

예외

ArgumentNullException

action 인수가 null입니다.

ArgumentOutOfRangeException

creationOptions 인수는 TaskCreationOptions에 대해 잘못된 값을 지정합니다.

설명

이 생성자를 호출하는 대신 개체를 인스턴스화 Task 하고 작업을 시작하는 가장 일반적인 방법은 정적 TaskFactory.StartNew(Action, TaskCreationOptions) 메서드를 호출하는 것입니다. 이 생성자가 제공하는 유일한 이점은 개체 인스턴스화를 작업 호출과 분리할 수 있다는 것입니다.

적용 대상

Task(Action<Object>, Object)

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

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

public:
 Task(Action<System::Object ^> ^ action, System::Object ^ state);

public Task (Action<object> action, object state);

public Task (Action<object?> action, object? state);

new System.Threading.Tasks.Task : Action<obj> * obj -> System.Threading.Tasks.Task

Public Sub New (action As Action(Of Object), state As Object)

매개 변수

action: Action<Object>

작업에서 실행할 코드를 나타내는 대리자입니다.

state: Object

동작에서 사용할 데이터를 나타내는 개체입니다.

예외

ArgumentNullException

action 인수가 null입니다.

예제

다음 예제에서는 6자 단어의 배열을 정의합니다. 그런 다음 각 단어가 생성자에 인수 Task(Action<Object>, Object) 로 전달되며, 대리 Action<T> 자는 단어의 문자를 스크램블한 다음 원래 단어와 해당 스크램블 버전을 표시합니다.

using System;
using System.Collections.Generic;
using System.Threading.Tasks;

public class Example
{
   public static async Task Main()
   {
      var tasks = new List<Task>();
      Random rnd = new Random();
      Object lockObj = new Object();
      String[] words6 = { "reason", "editor", "rioter", "rental",
                          "senior", "regain", "ordain", "rained" };

      foreach (var word6 in words6) {
         Task t = new Task( (word) => { Char[] chars = word.ToString().ToCharArray();
                                        double[] order = new double[chars.Length];
                                        lock (lockObj) {
                                           for (int ctr = 0; ctr < order.Length; ctr++)
                                              order[ctr] = rnd.NextDouble();
                                           }
                                        Array.Sort(order, chars);
                                        Console.WriteLine("{0} --> {1}", word,
                                                          new String(chars));
                                      }, word6);
         t.Start();
         tasks.Add(t);
      }
      await Task.WhenAll(tasks.ToArray());
   }
}
// The example displays output like the following:
//    regain --> irnaeg
//    ordain --> rioadn
//    reason --> soearn
//    rained --> rinade
//    rioter --> itrore
//    senior --> norise
//    rental --> atnerl
//    editor --> oteird

open System
open System.Threading.Tasks

let main =
    task {
        let tasks = ResizeArray()
        let rnd = Random()
        let lockObj = obj ()

        let words6 =
            [ "reason"
              "editor"
              "rioter"
              "rental"
              "senior"
              "regain"
              "ordain"
              "rained" ]

        for word6 in words6 do
            let t =
                new Task(
                    (fun word ->
                        let chars = (string word).ToCharArray()
                        let order = Array.zeroCreate<double> chars.Length

                        lock lockObj (fun () ->
                            for i = 0 to order.Length - 1 do
                                order[i] <- rnd.NextDouble())

                        Array.Sort(order, chars)
                        printfn $"{word} --> {new String(chars)}"),
                    word6
                )

            t.Start()
            tasks.Add t

        do! tasks.ToArray() |> Task.WhenAll
    }

main.Wait()

// The example displays output like the following:
//    regain --> irnaeg
//    ordain --> rioadn
//    reason --> soearn
//    rained --> rinade
//    rioter --> itrore
//    senior --> norise
//    rental --> atnerl
//    editor --> oteird

Imports System.Collections.Generic
Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      Dim tasks As New List(Of Task)()
      Dim rnd As New Random()
      Dim lockObj As New Object()
      Dim words6() As String = { "reason", "editor", "rioter", "rental",
                                 "senior", "regain", "ordain", "rained" }

      For Each word6 in words6
         Dim t As New Task( Sub(word)
                               Dim chars() As Char = word.ToString().ToCharArray()
                               Dim order(chars.Length - 1) As Double
                               SyncLock lockObj
                                  For ctr As Integer = 0 To order.Length - 1
                                     order(ctr) = rnd.NextDouble()
                                  Next
                               End SyncLock
                               Array.Sort(order, chars)
                               Console.WriteLine("{0} --> {1}", word,
                                                 New String(chars))
                            End Sub, word6)
         t.Start()
         tasks.Add(t)
      Next
      Task.WaitAll(tasks.ToArray())
   End Sub
End Module
' The example displays output like the following:
'       regain --> irnaeg
'       ordain --> rioadn
'       reason --> soearn
'       rained --> rinade
'       rioter --> itrore
'       senior --> norise
'       rental --> atnerl
'       editor --> oteird

설명

이 생성자를 호출하는 대신 개체를 인스턴스화 Task 하고 작업을 시작하는 가장 일반적인 방법은 정적 TaskFactory.StartNew(Action<Object>, Object) 메서드를 호출하는 것입니다. 이 생성자가 제공하는 유일한 이점은 개체 인스턴스화를 작업 호출과 분리할 수 있다는 것입니다.

추가 정보

StartNew(Action<Object>, Object)

적용 대상

Task(Action, CancellationToken, TaskCreationOptions)

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

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

public:
 Task(Action ^ action, System::Threading::CancellationToken cancellationToken, System::Threading::Tasks::TaskCreationOptions creationOptions);

public Task (Action action, System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskCreationOptions creationOptions);

new System.Threading.Tasks.Task : Action * System.Threading.CancellationToken * System.Threading.Tasks.TaskCreationOptions -> System.Threading.Tasks.Task

Public Sub New (action As Action, cancellationToken As CancellationToken, creationOptions As TaskCreationOptions)

매개 변수

action: Action

작업에서 실행할 코드를 나타내는 대리자입니다.

cancellationToken: CancellationToken

새 작업이 관찰할 CancellationToken입니다.

creationOptions: TaskCreationOptions

작업의 동작을 사용자 지정하는 데 사용할 TaskCreationOptions입니다.

예외

ObjectDisposedException

cancellationToken을 만든 CancellationTokenSource가 이미 삭제되었습니다.

ArgumentNullException

action 인수가 null입니다.

ArgumentOutOfRangeException

creationOptions 인수는 TaskCreationOptions에 대해 잘못된 값을 지정합니다.

설명

이 생성자를 호출하는 대신 개체를 인스턴스화 Task 하고 작업을 시작하는 가장 일반적인 방법은 정적 TaskFactory.StartNew(Action, CancellationToken, TaskCreationOptions, TaskScheduler) 메서드를 호출하는 것입니다. 이 생성자가 제공하는 유일한 이점은 개체 인스턴스화를 작업 호출과 분리할 수 있다는 것입니다.

자세한 내용은 작업 병렬 처리(작업 병렬 라이브러리) 및 작업 취소를 참조하세요.

적용 대상

Task(Action<Object>, Object, CancellationToken)

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

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

public:
 Task(Action<System::Object ^> ^ action, System::Object ^ state, System::Threading::CancellationToken cancellationToken);

public Task (Action<object> action, object state, System.Threading.CancellationToken cancellationToken);

public Task (Action<object?> action, object? state, System.Threading.CancellationToken cancellationToken);

new System.Threading.Tasks.Task : Action<obj> * obj * System.Threading.CancellationToken -> System.Threading.Tasks.Task

Public Sub New (action As Action(Of Object), state As Object, cancellationToken As CancellationToken)

매개 변수

action: Action<Object>

작업에서 실행할 코드를 나타내는 대리자입니다.

state: Object

동작에서 사용할 데이터를 나타내는 개체입니다.

cancellationToken: CancellationToken

새 작업이 관찰할 CancellationToken입니다.

예외

ObjectDisposedException

cancellationToken을 만든 CancellationTokenSource가 이미 삭제되었습니다.

ArgumentNullException

action 인수가 null입니다.

설명

이 생성자를 호출하는 대신 개체를 인스턴스화 Task 하고 작업을 시작하는 가장 일반적인 방법은 정적 TaskFactory.StartNew(Action<Object>, Object, CancellationToken) 메서드를 호출하는 것입니다. 이 생성자가 제공하는 유일한 이점은 개체 인스턴스화를 작업 호출과 분리할 수 있다는 것입니다.

적용 대상

Task(Action<Object>, Object, TaskCreationOptions)

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

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

public:
 Task(Action<System::Object ^> ^ action, System::Object ^ state, System::Threading::Tasks::TaskCreationOptions creationOptions);

public Task (Action<object> action, object state, System.Threading.Tasks.TaskCreationOptions creationOptions);

public Task (Action<object?> action, object? state, System.Threading.Tasks.TaskCreationOptions creationOptions);

new System.Threading.Tasks.Task : Action<obj> * obj * System.Threading.Tasks.TaskCreationOptions -> System.Threading.Tasks.Task

Public Sub New (action As Action(Of Object), state As Object, creationOptions As TaskCreationOptions)

매개 변수

action: Action<Object>

작업에서 실행할 코드를 나타내는 대리자입니다.

state: Object

동작에서 사용할 데이터를 나타내는 개체입니다.

creationOptions: TaskCreationOptions

작업의 동작을 사용자 지정하는 데 사용할 TaskCreationOptions입니다.

예외

ArgumentNullException

action 인수가 null입니다.

ArgumentOutOfRangeException

creationOptions 인수는 TaskCreationOptions에 대해 잘못된 값을 지정합니다.

설명

이 생성자를 호출하는 대신 개체를 인스턴스화 Task 하고 작업을 시작하는 가장 일반적인 방법은 정적 TaskFactory.StartNew(Action<Object>, Object, TaskCreationOptions) 메서드를 호출하는 것입니다. 이 생성자가 제공하는 유일한 이점은 개체 인스턴스화를 작업 호출과 분리할 수 있다는 것입니다.

적용 대상

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

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

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

public:
 Task(Action<System::Object ^> ^ action, System::Object ^ state, System::Threading::CancellationToken cancellationToken, System::Threading::Tasks::TaskCreationOptions creationOptions);

public Task (Action<object> action, object state, System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskCreationOptions creationOptions);

public Task (Action<object?> action, object? state, System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskCreationOptions creationOptions);

new System.Threading.Tasks.Task : Action<obj> * obj * System.Threading.CancellationToken * System.Threading.Tasks.TaskCreationOptions -> System.Threading.Tasks.Task

Public Sub New (action As Action(Of Object), state As Object, cancellationToken As CancellationToken, creationOptions As TaskCreationOptions)

매개 변수

action: Action<Object>

작업에서 실행할 코드를 나타내는 대리자입니다.

state: Object

동작에서 사용할 데이터를 나타내는 개체입니다.

cancellationToken: CancellationToken

새 작업이 관찰할 CancellationToken입니다.

creationOptions: TaskCreationOptions

작업의 동작을 사용자 지정하는 데 사용할 TaskCreationOptions입니다.

예외

ObjectDisposedException

cancellationToken을 만든 CancellationTokenSource가 이미 삭제되었습니다.

ArgumentNullException

action 인수가 null입니다.

ArgumentOutOfRangeException

creationOptions 인수는 TaskCreationOptions에 대해 잘못된 값을 지정합니다.

설명

이 생성자를 호출하는 대신 개체를 인스턴스화 Task 하고 작업을 시작하는 가장 일반적인 방법은 정적 TaskFactory.StartNew(Action<Object>, Object, CancellationToken, TaskCreationOptions, TaskScheduler) 메서드를 호출하는 것입니다. 이 생성자가 제공하는 유일한 이점은 개체 인스턴스화를 작업 호출과 분리할 수 있다는 것입니다.

적용 대상

다음을 통해 공유

Task 생성자

정의

오버로드

Task(Action)

매개 변수

예외

예제

설명

추가 정보

적용 대상

Task(Action, CancellationToken)

매개 변수

예외

예제

설명

적용 대상

Task(Action, TaskCreationOptions)

매개 변수

예외

설명

적용 대상

Task(Action<Object>, Object)

매개 변수

예외

예제

설명

추가 정보

적용 대상

Task(Action, CancellationToken, TaskCreationOptions)

매개 변수

예외

설명

적용 대상

Task(Action<Object>, Object, CancellationToken)

매개 변수

예외

설명

적용 대상

Task(Action<Object>, Object, TaskCreationOptions)

매개 변수

예외

설명

적용 대상

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

매개 변수

예외

설명

적용 대상

추가 리소스