TaskFactory.StartNew 메서드

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

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

member this.StartNew : Action<obj> * obj * System.Threading.CancellationToken * System.Threading.Tasks.TaskCreationOptions * System.Threading.Tasks.TaskScheduler -> System.Threading.Tasks.Task

Public Function StartNew (action As Action(Of Object), state As Object, cancellationToken As CancellationToken, creationOptions As TaskCreationOptions, scheduler As TaskScheduler) As Task

매개 변수

반품

시작된 작업입니다.

예외

설명

StartNew를 호출하는 것은 해당 생성자 중 하나를 사용하여 작업을 만든 다음 실행을 예약하도록 호출 Start 하는 것과 기능적으로 동일합니다.

.NET Framework 4.5부터 Action 개체와 함께 Run 메서드를 사용하여 기본 매개 변수로 StartNew 호출할 수 있습니다. 자세한 내용 및 코드 예제는 .NET 블로그가 있는 병렬 프로그래밍에서 Task.Run vs Task.Factory.StartNew 참조하세요.

추가 정보

• TPL(작업 병렬 라이브러리)
• 연속 작업을 사용하여 작업 체이닝
• 작업 취소

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

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

member this.StartNew : Action * System.Threading.CancellationToken * System.Threading.Tasks.TaskCreationOptions * System.Threading.Tasks.TaskScheduler -> System.Threading.Tasks.Task

Public Function StartNew (action As Action, cancellationToken As CancellationToken, creationOptions As TaskCreationOptions, scheduler As TaskScheduler) As Task

매개 변수

반품

시작된 작업입니다.

예외

설명

StartNew를 호출하는 것은 해당 생성자 중 하나를 사용하여 작업을 만든 다음 실행을 예약하도록 호출 Start 하는 것과 기능적으로 동일합니다.

.NET Framework 4.5부터 Action 개체와 함께 Run 메서드를 사용하여 기본 매개 변수로 StartNew 호출할 수 있습니다. 자세한 내용 및 코드 예제는 .NET 블로그가 있는 병렬 프로그래밍에서 Task.Run vs Task.Factory.StartNew 참조하세요.

추가 정보

• TPL(작업 병렬 라이브러리)
• 연속 작업을 사용하여 작업 체이닝
• 작업 취소

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

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

member this.StartNew : Action<obj> * obj * System.Threading.Tasks.TaskCreationOptions -> System.Threading.Tasks.Task

Public Function StartNew (action As Action(Of Object), state As Object, creationOptions As TaskCreationOptions) As Task

매개 변수

반품

시작된 작업입니다.

예외

설명

StartNew를 호출하는 것은 해당 생성자 중 하나를 사용하여 작업을 만든 다음 실행을 예약하도록 호출 Start 하는 것과 기능적으로 동일합니다.

.NET Framework 4.5부터 Action 개체와 함께 Run 메서드를 사용하여 기본 매개 변수로 StartNew 호출할 수 있습니다. 자세한 내용 및 코드 예제는 .NET 블로그가 있는 병렬 프로그래밍에서 Task.Run vs Task.Factory.StartNew 참조하세요.

추가 정보

• TPL(작업 병렬 라이브러리)
• 연속 작업을 사용하여 작업 체이닝
• 작업 취소

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

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

member this.StartNew : Action<obj> * obj * System.Threading.CancellationToken -> System.Threading.Tasks.Task

Public Function StartNew (action As Action(Of Object), state As Object, cancellationToken As CancellationToken) As Task

매개 변수

반품

시작된 작업입니다.

예외

예제

다음 예제에서는 6자 단어의 배열을 정의합니다. 그런 다음 각 단어가 대리자에게 Action<T> 전달되어 단어를 스크램블링하고 원래 단어와 해당 스크램블 버전을 표시합니다.

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

public class Example
{
   public static void Main()
   {
      CancellationTokenSource cts = new CancellationTokenSource();
      CancellationToken token = cts.Token;
      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)
         tasks.Add(Task.Factory.StartNew( (word) => { Char[] chars = word.ToString().ToCharArray();
                                                      double[] order = new double[chars.Length];
                                                      token.ThrowIfCancellationRequested();
                                                      bool wasZero = false;
                                                      lock (lockObj) {
                                                         for (int ctr = 0; ctr < order.Length; ctr++) {
                                                             order[ctr] = rnd.NextDouble();
                                                             if (order[ctr] == 0) {
                                                                if (!wasZero) {
                                                                   wasZero = true;
                                                                }
                                                                else {
                                                                   cts.Cancel();
                                                                }
                                                             }
                                                         }
                                                      }
                                                      token.ThrowIfCancellationRequested();
                                                      Array.Sort(order, chars);
                                                      Console.WriteLine("{0} --> {1}", word,
                                                                        new String(chars));
                                                    }, word6, token));

      try {
         Task.WaitAll(tasks.ToArray());
      }
      catch (AggregateException e) {
         foreach (var ie in e.InnerExceptions) {
            if (ie is OperationCanceledException) {
               Console.WriteLine("The word scrambling operation has been cancelled.");
               break;
            }
            else {
               Console.WriteLine(ie.GetType().Name + ": " + ie.Message);
            }
         }
      }
      finally {
         cts.Dispose();
      }
   }
}
// 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
Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      Dim cts As New CancellationTokenSource()
      Dim token As CancellationToken = cts.Token
      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
         tasks.Add(Task.Factory.StartNew( Sub(word)
                                              Dim chars() As Char = word.ToString().ToCharArray()
                                              Dim order(chars.Length - 1) As Double
                                              Dim wasZero As Boolean = False
                                              SyncLock lockObj
                                                 For ctr As Integer = 0 To order.Length - 1
                                                    order(ctr) = rnd.NextDouble()
                                                    If order(ctr) = 0 Then
                                                       If Not wasZero Then
                                                          wasZero = True
                                                       Else
                                                          cts.Cancel()
                                                       End If
                                                    End If
                                                 Next
                                              End SyncLock
                                              token.ThrowIfCancellationRequested()
                                              Array.Sort(order, chars)
                                              Console.WriteLine("{0} --> {1}", word,
                                                                new String(chars))
                                          End Sub, word6))
      Next
      Try
         Task.WaitAll(tasks.ToArray())
      Catch e As AggregateException
         For Each ie In e.InnerExceptions
            If TypeOf ie Is OperationCanceledException
               Console.WriteLine("The word scrambling operation has been cancelled.")
               Exit For
            Else
               Console.WriteLine(ie.GetType().Name + ": " + ie.Message)
            End If
         Next
      Finally
         cts.Dispose()
      End Try
   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

이 예제에서는 잠금으로 보호되는 단일 난수 생성기를 초기화합니다. 잠금이 필요한 경우 클래스 항목에서 "System.Random 클래스 및 스레드 안전성"을 Random 참조하세요. 난수 생성기의 손상 가능성을 처리하기 위해 취소 토큰이 작업에 전달됩니다. 두 난수가 0이면 메서드는 난수 생성기가 손상되었다고 가정하고 취소 토큰을 설정합니다. 단어에 chars 6자가 포함된 배열을 정렬하기 전에 메서드는 메서드를 호출 CancellationToken.ThrowIfCancellationRequested 하여 토큰이 OperationCanceledException 취소된 경우 throw합니다.

설명

StartNew를 호출하는 것은 해당 생성자 중 하나를 사용하여 작업을 만든 다음 실행을 예약하도록 호출 Start 하는 것과 기능적으로 동일합니다.

.NET Framework 4.5부터 Action 개체와 함께 Run 메서드를 사용하여 기본 매개 변수로 StartNew 호출할 수 있습니다. 자세한 내용 및 코드 예제는 .NET 블로그가 있는 병렬 프로그래밍에서 Task.Run vs Task.Factory.StartNew 참조하세요.

추가 정보

• TPL(작업 병렬 라이브러리)
• 연속 작업을 사용하여 작업 체이닝
• 작업 취소

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

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

member this.StartNew : Action * System.Threading.CancellationToken -> System.Threading.Tasks.Task

Public Function StartNew (action As Action, cancellationToken As CancellationToken) As Task

매개 변수

반품

시작된 작업입니다.

예외

예제

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

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

public class Example
{
   public static void Main()
   {
      var tokenSource = new CancellationTokenSource();
      var token = tokenSource.Token;
      var files = new List<Tuple<string, string, long, DateTime>>();

      var t = Task.Factory.StartNew( () => { 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);
      tokenSource.Cancel();
      try {
         t.Wait(); 
         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

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 Task = Task.Factory.StartNew( 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)
      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

설명

호출 StartNew 은 해당 생성자 중 하나를 사용하여 작업을 만든 다음 실행을 예약하도록 호출 Start 하는 것과 기능적으로 동일합니다.

.NET Framework 4.5부터 Task.Run(Action, CancellationToken) 메서드를 기본 매개 변수로 StartNew(Action, CancellationToken) 호출하는 빠른 방법으로 사용할 수 있습니다. 그러나 두 메서드 Task.Run(Action, CancellationToken) 간에는 동작에 차이가 있습니다. 기본적으로 자식 작업은 현재 Task 인스턴스에 연결하는 옵션으로 TaskCreationOptions.AttachedToParent 시작하는 것을 허용하지 않지만, StartNew(Action, CancellationToken) 그렇지 않습니다. 자세한 내용 및 코드 예제는 .NET 블로그가 있는 병렬 프로그래밍에서 Task.Run vs Task.Factory.StartNew 참조하세요.

추가 정보

• TPL(작업 병렬 라이브러리)
• 연속 작업을 사용하여 작업 체이닝
• 작업 취소

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

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

member this.StartNew : Action * System.Threading.Tasks.TaskCreationOptions -> System.Threading.Tasks.Task

Public Function StartNew (action As Action, creationOptions As TaskCreationOptions) As Task

매개 변수

반품

시작된 작업입니다.

예외

설명

StartNew를 호출하는 것은 해당 생성자 중 하나를 사용하여 작업을 만든 다음 실행을 예약하도록 호출 Start 하는 것과 기능적으로 동일합니다.

.NET Framework 4.5부터 Action 개체와 함께 Run 메서드를 사용하여 기본 매개 변수로 StartNew 호출할 수 있습니다. 자세한 내용 및 코드 예제는 .NET 블로그가 있는 병렬 프로그래밍에서 Task.Run vs Task.Factory.StartNew 참조하세요.

추가 정보

• TPL(작업 병렬 라이브러리)
• 연속 작업을 사용하여 작업 체이닝
• 작업 취소

public:
 System::Threading::Tasks::Task ^ StartNew(Action ^ action);

public System.Threading.Tasks.Task StartNew(Action action);

member this.StartNew : Action -> System.Threading.Tasks.Task

Public Function StartNew (action As Action) As Task

매개 변수

반품

시작된 작업입니다.

예외

예제

다음 예제에서는 메서드를 사용하여 StartNew(Action) 난수를 생성하는 대리자를 반복적으로 호출 Action 하고, 유니코드 코드 포인트로 해석하고, UTF16으로 인코딩된 코드 단위로 변환하고, 결과 문자 또는 문자에 대한 정보를 표시합니다.

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

public class Example
{
   public static void Main()
   {
      Random rnd = new Random();
      List<Task> tasks  = new List<Task>();
      // Execute the task 10 times.
      for (int ctr = 1; ctr <= 9; ctr++) {
         tasks.Add(Task.Factory.StartNew( () => {
                                            int utf32 = 0;
                                            lock(rnd) {
                                               // Get UTF32 value.
                                               utf32 = rnd.Next(0, 0xE01F0);
                                            }
                                            // Convert it to a UTF16-encoded character.
                                            string utf16 = Char.ConvertFromUtf32(utf32);
                                            // Display information about the character.
                                            Console.WriteLine("0x{0:X8} --> '{1,2}' ({2})", 
                                                              utf32, utf16, ShowHex(utf16));
                                         }));                           
      }
      Task.WaitAll(tasks.ToArray()); 
   }

   private static string ShowHex(string value)
   {
      string hexString = null;
      // Handle only non-control characters.
      if (!Char.IsControl(value, 0)) {
         foreach (var ch in value)
            hexString += $"0x{(ushort)ch:X} ";
      }   
      return hexString.Trim();
   }
}
// The example displays the following output:
//       0x00097103 --> '򗄃' (0x55836 0x56579)
//       0x000A98A1 --> '򩢡' (0x55910 0x56481)
//       0x00050002 --> '񐀂' (0x55552 0x56322)
//       0x0000FEF1 --> 'ﻱ' (0x65265)
//       0x0008BC0A --> '򋰊' (0x55791 0x56330)
//       0x000860EA --> '򆃪' (0x55768 0x56554)
//       0x0009AC5A --> '򚱚' (0x55851 0x56410)
//       0x00053320 --> '񓌠' (0x55564 0x57120)
//       0x000874EF --> '򇓯' (0x55773 0x56559)

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

Public Module Example
   Public Sub Main()
      Dim rnd As New Random()
      Dim tasks As New List(Of Task)
      ' Execute the task 10 times.
      For ctr As Integer = 1 To 9
         tasks.Add(Task.Factory.StartNew(Sub()
                                            Dim utf32 As Integer
                                            SyncLock(rnd)
                                               ' Get UTF32 value.
                                               utf32 = rnd.Next(0, &hE01F0)
                                            End SyncLock
                                            ' Convert it to a UTF16-encoded character.
                                            Dim utf16 As String = Char.ConvertFromUtf32(utf32)
                                            ' Display information about the character.
                                            Console.WriteLine("0x{0:X8} --> '{1,2}' ({2})", 
                                                              utf32, utf16, ShowHex(utf16))
                                         End Sub))                           
      Next
      Task.WaitAll(tasks.ToArray()) 
   End Sub
   
   Private Function ShowHex(value As String) As String
      Dim hexString As String = Nothing
      ' Handle only non-control characters.
      If Not Char.IsControl(value, 0) Then
         For Each ch In value
            hexString += String.Format("0x{0} ", Convert.ToUInt16(ch))
         Next
      End If   
      Return hexString.Trim()
   End Function
End Module
' The example displays output similar to the following:
'       0x00097103 --> '򗄃' (0x55836 0x56579)
'       0x000A98A1 --> '򩢡' (0x55910 0x56481)
'       0x00050002 --> '񐀂' (0x55552 0x56322)
'       0x0000FEF1 --> 'ﻱ' (0x65265)
'       0x0008BC0A --> '򋰊' (0x55791 0x56330)
'       0x000860EA --> '򆃪' (0x55768 0x56554)
'       0x0009AC5A --> '򚱚' (0x55851 0x56410)
'       0x00053320 --> '񓌠' (0x55564 0x57120)
'       0x000874EF --> '򇓯' (0x55773 0x56559)

설명

호출 StartNew 은 해당 생성자 중 하나를 사용하여 작업을 만든 다음 메서드를 호출 Task.Start 하여 작업을 실행하도록 예약하는 것과 기능적으로 동일합니다.

.NET Framework 4.5부터 Task.Run(Action) 메서드를 기본 매개 변수로 StartNew(Action) 호출하는 빠른 방법으로 사용할 수 있습니다. 그러나 두 메서드 Task.Run(Action) 간에는 동작에 차이가 있습니다. 기본적으로 자식 작업은 현재 Task 인스턴스에 연결하는 옵션으로 TaskCreationOptions.AttachedToParent 시작하는 것을 허용하지 않지만, StartNew(Action) 그렇지 않습니다. 자세한 내용 및 코드 예제는 .NET 블로그가 있는 병렬 프로그래밍에서 Task.Run vs Task.Factory.StartNew 참조하세요.

추가 정보

• TPL(작업 병렬 라이브러리)
• 연속 작업을 사용하여 작업 체이닝
• 작업 취소

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

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

member this.StartNew : Action<obj> * obj -> System.Threading.Tasks.Task

Public Function StartNew (action As Action(Of Object), state As Object) As Task

매개 변수

반품

시작된 작업입니다.

예외

예제

다음 예제에서는 6자 단어의 배열을 정의합니다. 그런 다음 각 단어가 대리자에게 Action<T> 전달되어 단어를 스크램블링하고 원래 단어와 해당 스크램블 버전을 표시합니다.

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

public class Example
{
   public static void 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)
         tasks.Add(Task.Factory.StartNew( (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));

      Task.WaitAll(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

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
         tasks.Add(Task.Factory.StartNew( 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))
      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

이 예제에서는 잠금으로 보호되는 단일 난수 생성기를 초기화합니다. 잠금이 필요한 경우 클래스 항목에서 "System.Random 클래스 및 스레드 안전성"을 Random 참조하세요.

설명

호출 StartNew 은 해당 생성자 중 하나를 사용하여 만든 Task 다음 메서드를 호출 Start 하여 실행을 예약하는 것과 기능적으로 동일합니다.

.NET Framework 4.5부터 Action 개체와 함께 Run 메서드를 사용하여 기본 매개 변수로 StartNew 호출할 수 있습니다. 자세한 내용 및 코드 예제는 .NET 블로그가 있는 병렬 프로그래밍에서 Task.Run vs Task.Factory.StartNew 참조하세요.

추가 정보

• TPL(작업 병렬 라이브러리)
• 연속 작업을 사용하여 작업 체이닝
• 작업 취소

public:
generic <typename TResult>
 System::Threading::Tasks::Task<TResult> ^ StartNew(Func<TResult> ^ function, System::Threading::CancellationToken cancellationToken, System::Threading::Tasks::TaskCreationOptions creationOptions, System::Threading::Tasks::TaskScheduler ^ scheduler);

public System.Threading.Tasks.Task<TResult> StartNew<TResult>(Func<TResult> function, System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskCreationOptions creationOptions, System.Threading.Tasks.TaskScheduler scheduler);

member this.StartNew : Func<'Result> * System.Threading.CancellationToken * System.Threading.Tasks.TaskCreationOptions * System.Threading.Tasks.TaskScheduler -> System.Threading.Tasks.Task<'Result>

Public Function StartNew(Of TResult) (function As Func(Of TResult), cancellationToken As CancellationToken, creationOptions As TaskCreationOptions, scheduler As TaskScheduler) As Task(Of TResult)

형식 매개 변수

매개 변수

반품

시작된 작업입니다.

예외

설명

StartNew를 호출하는 것은 해당 생성자 중 하나를 사용하여 만든 Task<TResult> 다음 실행을 예약하도록 호출 Start 하는 것과 기능적으로 동일합니다.

.NET Framework 4.5부터 Action 개체와 함께 Run 메서드를 사용하여 기본 매개 변수로 StartNew 호출할 수 있습니다. 자세한 내용 및 코드 예제는 .NET 블로그가 있는 병렬 프로그래밍에서 Task.Run 및 Task.Factory.StartNew 항목을 참조하세요.

추가 정보

• TPL(작업 병렬 라이브러리)
• 연속 작업을 사용하여 작업 체이닝
• 작업 취소

public:
generic <typename TResult>
 System::Threading::Tasks::Task<TResult> ^ StartNew(Func<TResult> ^ function);

public System.Threading.Tasks.Task<TResult> StartNew<TResult>(Func<TResult> function);

member this.StartNew : Func<'Result> -> System.Threading.Tasks.Task<'Result>

Public Function StartNew(Of TResult) (function As Func(Of TResult)) As Task(Of TResult)

형식 매개 변수

매개 변수

반품

시작된 작업입니다.

예외

예제

다음 예제는 두 개의 난수를 생성하고 사용자에게 합계를 입력하라는 메시지를 표시하는 간단한 추가 앱입니다. 그런 다음 대답이 올바른지 또는 사용자의 응답이 유효한 숫자가 아닌 경우 유효한 숫자를 다시 입력하라는 메시지를 표시합니다. 추가할 StartNew 난수를 반환하는 개체를 만드는 Task<TResult> 데 사용됩니다.

using System;
using System.Threading.Tasks;

public class Example
{
   public static void Main()
   {
      Random rnd = new Random();
      Task<int>[] tasks = new Task<int>[2];
      Object obj = new Object();
      
      while (true) {
         for (int ctr = 0; ctr <= 1; ctr++)
            tasks[ctr] = Task.Factory.StartNew(() => { int i = 0;
                                                       lock(obj) {
                                                          i = rnd.Next(101);
                                                       }
                                                       return i; });

         Task.WaitAll(tasks);
         int n1 = tasks[0].Result;
         int n2 = tasks[1].Result;
         int result = n1 + n2;
         bool validInput = false;
         while (!validInput) {
            ShowMessage(n1, n2);
            string userInput = Console.ReadLine();
            // Process user input.
            if (userInput.Trim().ToUpper() == "X") return;
            int answer;
            validInput = Int32.TryParse(userInput, out answer);
            if (!validInput)
               Console.WriteLine("Invalid input. Try again, but enter only numbers. ");
            else if (answer == result)
               Console.WriteLine("Correct!");
            else
               Console.WriteLine("Incorrect. The correct answer is {0}.", result);
         }
      }
   }

   private static void ShowMessage(int n1, int n2)
   {
      Console.WriteLine("\nEnter 'x' to exit...");
      Console.Write("{0} + {1} = ", n1, n2);
   }
}
// The example displays the following output:
//       Enter 'x' to exit...
//       15 + 11 = 26
//       Correct!
//
//       Enter 'x' to exit...
//       75 + 33 = adc
//       Invalid input. Try again, but enter only numbers.
//
//       Enter 'x' to exit...
//       75 + 33 = 108
//       Correct!
//
//       Enter 'x' to exit...
//       67 + 55 = 133
//       Incorrect. The correct answer is 122.
//
//       Enter 'x' to exit...
//       92 + 51 = 133
//       Incorrect. The correct answer is 143.
//
//       Enter 'x' to exit...
//       81 + 65 = x

   
Imports System.Threading.Tasks

Module AdditionTester
   Public Sub Main()
      Dim rnd As New Random()
      Dim tasks(1) As Task(Of Integer)
      Dim obj As New Object()
      
      Do While True
         For ctr As Integer = 0 To 1
            tasks(ctr) = Task.Factory.StartNew(Function()
                                                  Dim i As Integer
                                                  SyncLock(obj)
                                                     i = rnd.Next(101)
                                                  End SyncLock
                                                  Return i
                                               End Function)
         Next
         Task.WaitAll(tasks)
         Dim n1 As Integer = tasks(0).Result
         Dim n2 As Integer = tasks(1).Result
         Dim result As Integer = n1 + n2
         Dim validInput As Boolean = False
         Do While Not validInput
            ShowMessage(n1, n2)
            Dim userInput As String = Console.ReadLine()
            ' Process user input.
            If userInput.Trim().ToUpper = "X" Then Exit Sub
            Dim answer As Integer
            validInput = Int32.TryParse(userInput, answer)
            If Not validInput Then
               Console.WriteLine("Invalid input. Try again, but enter only numbers. ")
            Else If answer = result Then
               Console.WriteLine("Correct!")
            Else
               Console.WriteLine("Incorrect. The correct answer is {0}.", result)
            End If
         Loop
      Loop
   End Sub
   
   Private Sub ShowMessage(n1 As Integer, n2 As Integer)
      Console.WriteLine()
      Console.WriteLine("Enter 'x' to exit...")
      Console.Write("{0} + {1} = ", n1, n2)
   End Sub
End Module
' The example displays output like the following:
'       Enter 'x' to exit...
'       15 + 11 = 26
'       Correct!
'
'       Enter 'x' to exit...
'       75 + 33 = adc
'       Invalid input. Try again, but enter only numbers.
'
'       Enter 'x' to exit...
'       75 + 33 = 108
'       Correct!
'
'       Enter 'x' to exit...
'       67 + 55 = 133
'       Incorrect. The correct answer is 122.
'
'       Enter 'x' to exit...
'       92 + 51 = 133
'       Incorrect. The correct answer is 143.
'
'       Enter 'x' to exit...
'       81 + 65 = x

설명

호출 StartNew 은 해당 생성자 중 하나를 사용하여 만든 Task<TResult> 다음 실행을 예약하도록 호출 Start 하는 것과 기능적으로 동일합니다.

.NET Framework 4.5부터 Task.Run<TResult>(Func<TResult>) 메서드를 호출하여 기본 매개 변수를 사용하여 StartNew 호출할 수 있습니다. 그러나 두 메서드 Task.Run<TResult>(Func<TResult>) 간에는 동작에 차이가 있습니다. 기본적으로 자식 작업은 현재 Task<TResult> 인스턴스에 연결하는 옵션으로 TaskCreationOptions.AttachedToParent 시작하는 것을 허용하지 않지만, StartNew<TResult>(Func<TResult>) 그렇지 않습니다. 자세한 내용 및 코드 예제는 .NET 블로그가 있는 병렬 프로그래밍에서 Task.Run 및 Task.Factory.StartNew 항목을 참조하세요.

추가 정보

• TPL(작업 병렬 라이브러리)
• 연속 작업을 사용하여 작업 체이닝
• 작업 취소

public:
generic <typename TResult>
 System::Threading::Tasks::Task<TResult> ^ StartNew(Func<System::Object ^, TResult> ^ function, System::Object ^ state);

public System.Threading.Tasks.Task<TResult> StartNew<TResult>(Func<object,TResult> function, object state);

member this.StartNew : Func<obj, 'Result> * obj -> System.Threading.Tasks.Task<'Result>

Public Function StartNew(Of TResult) (function As Func(Of Object, TResult), state As Object) As Task(Of TResult)

형식 매개 변수

매개 변수

반품

시작된 작업입니다.

예외

설명

StartNew를 호출하는 것은 해당 생성자 중 하나를 사용하여 만든 Task<TResult> 다음 실행을 예약하도록 호출 Start 하는 것과 기능적으로 동일합니다.

.NET Framework 4.5부터 Action 개체와 함께 Run 메서드를 사용하여 기본 매개 변수로 StartNew 호출할 수 있습니다. 자세한 내용 및 코드 예제는 .NET 블로그가 있는 병렬 프로그래밍에서 Task.Run 및 Task.Factory.StartNew 항목을 참조하세요.

추가 정보

• TPL(작업 병렬 라이브러리)
• 연속 작업을 사용하여 작업 체이닝
• 작업 취소

public:
generic <typename TResult>
 System::Threading::Tasks::Task<TResult> ^ StartNew(Func<TResult> ^ function, System::Threading::CancellationToken cancellationToken);

public System.Threading.Tasks.Task<TResult> StartNew<TResult>(Func<TResult> function, System.Threading.CancellationToken cancellationToken);

member this.StartNew : Func<'Result> * System.Threading.CancellationToken -> System.Threading.Tasks.Task<'Result>

Public Function StartNew(Of TResult) (function As Func(Of TResult), cancellationToken As CancellationToken) As Task(Of TResult)

형식 매개 변수

매개 변수

반품

시작된 작업입니다.

예외

예제

다음 예제에서는 두 개의 작업을 사용하여 F100 = F100-1 + F100-2로 끝나는 피보나치 시퀀스를 F1= 1, F2 = 1 및 F1 = 0, F2= 1로 계산합니다. 작업의 절반 정도가 작업이 실행되면 취소 토큰이 설정됩니다. 이 예제의 출력은 두 작업이 성공적으로 완료되고 토큰이 취소된 경우 결과를 보여 줍니다.

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

public class Example
{
   public static void Main()
   {
      var rnd = new Random();
      var tasks = new List<Task<BigInteger[]>>();
      var source = new CancellationTokenSource();
      var token = source.Token;
      for (int ctr = 0; ctr <= 1; ctr++) {
         int start = ctr;
         tasks.Add(Task.Run( () => { BigInteger[] sequence = new BigInteger[100];
                                     sequence[0] = start;
                                     sequence[1] = 1;
                                     for (int index = 2; index <= sequence.GetUpperBound(0); index++) {
                                        token.ThrowIfCancellationRequested();
                                        sequence[index] = sequence[index - 1] + sequence[index - 2];
                                     }
                                     return sequence;
                                   }, token));
      }
      if (rnd.Next(0, 2) == 1)
         source.Cancel();
      try {
         Task.WaitAll(tasks.ToArray());
         foreach (var t in tasks)
            Console.WriteLine("{0}, {1}...{2:N0}", t.Result[0], t.Result[1],
                              t.Result[99]);
      }
      catch (AggregateException e) {
         foreach (var ex in e.InnerExceptions)
            Console.WriteLine("{0}: {1}", ex.GetType().Name, ex.Message);
      }
   }
}
// The example displays either the following output:
//    0, 1...218,922,995,834,555,169,026
//    1, 1...354,224,848,179,261,915,075
// or the following output:
//    TaskCanceledException: A task was canceled.
//    TaskCanceledException: A task was canceled.

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

Module Example
   Public Sub Main()
      Dim rnd As New Random()
      Dim tasks As New List(Of Task(Of BigInteger()))
      Dim source As New CancellationTokenSource
      Dim token As CancellationToken = source.Token
      For ctr As Integer = 0 To 1
         Dim start As Integer = ctr
         tasks.Add(Task.Run(Function()
                               Dim sequence(99) As BigInteger
                               sequence(0) = start
                               sequence(1) = 1
                               For index As Integer = 2 To sequence.GetUpperBound(0)
                                  token.ThrowIfCancellationRequested()
                                  sequence(index) = sequence(index - 1) + sequence(index - 2)
                               Next
                               Return sequence
                            End Function, token))
      Next
      If rnd.Next(0, 2) = 1 Then source.Cancel
      Try
         Task.WaitAll(tasks.ToArray())
         For Each t In tasks
            Console.WriteLine("{0}, {1}...{2:N0}", t.Result(0), t.Result(1),
                              t.Result(99))
         Next
      Catch e As AggregateException
         For Each ex In e.InnerExceptions
            Console.WriteLine("{0}: {1}", ex.GetType().Name, ex.Message)
         Next
      End Try
   End Sub
End Module
' The example displays either the following output:
'    0, 1...218,922,995,834,555,169,026
'    1, 1...354,224,848,179,261,915,075
' or the following output:
'    TaskCanceledException: A task was canceled.
'    TaskCanceledException: A task was canceled.

설명

호출 StartNew 은 해당 생성자 중 하나를 사용하여 만든 Task<TResult> 다음 실행을 예약하도록 호출 Start 하는 것과 기능적으로 동일합니다.

.NET Framework 4.5부터 Task.Run<TResult>(Func<TResult>, CancellationToken) 메서드를 기본 매개 변수로 StartNew<TResult>(Func<TResult>, CancellationToken) 호출하는 빠른 방법으로 사용할 수 있습니다. 그러나 두 메서드 Task.Run<TResult>(Func<TResult>, CancellationToken) 간에는 동작에 차이가 있습니다. 기본적으로 자식 작업은 현재 Task<TResult> 인스턴스에 연결하는 옵션으로 TaskCreationOptions.AttachedToParent 시작하는 것을 허용하지 않지만, StartNew<TResult>(Func<TResult>, CancellationToken) 그렇지 않습니다. 자세한 내용 및 코드 예제는 .NET 블로그가 있는 병렬 프로그래밍에서 Task.Run 및 Task.Factory.StartNew 항목을 참조하세요.

추가 정보

• TPL(작업 병렬 라이브러리)
• 연속 작업을 사용하여 작업 체이닝
• 작업 취소

public:
generic <typename TResult>
 System::Threading::Tasks::Task<TResult> ^ StartNew(Func<TResult> ^ function, System::Threading::Tasks::TaskCreationOptions creationOptions);

public System.Threading.Tasks.Task<TResult> StartNew<TResult>(Func<TResult> function, System.Threading.Tasks.TaskCreationOptions creationOptions);

member this.StartNew : Func<'Result> * System.Threading.Tasks.TaskCreationOptions -> System.Threading.Tasks.Task<'Result>

Public Function StartNew(Of TResult) (function As Func(Of TResult), creationOptions As TaskCreationOptions) As Task(Of TResult)

형식 매개 변수

매개 변수

반품

시작된 작업입니다.

예외

설명

StartNew를 호출하는 것은 해당 생성자 중 하나를 사용하여 만든 Task<TResult> 다음 실행을 예약하도록 호출 Start 하는 것과 기능적으로 동일합니다.

.NET Framework 4.5부터 Action 개체와 함께 Run 메서드를 사용하여 기본 매개 변수로 StartNew 호출할 수 있습니다. 자세한 내용 및 코드 예제는 .NET 블로그가 있는 병렬 프로그래밍에서 Task.Run 및 Task.Factory.StartNew 항목을 참조하세요.

추가 정보

• TPL(작업 병렬 라이브러리)
• 연속 작업을 사용하여 작업 체이닝
• 작업 취소

public:
generic <typename TResult>
 System::Threading::Tasks::Task<TResult> ^ StartNew(Func<System::Object ^, TResult> ^ function, System::Object ^ state, System::Threading::CancellationToken cancellationToken);

public System.Threading.Tasks.Task<TResult> StartNew<TResult>(Func<object,TResult> function, object state, System.Threading.CancellationToken cancellationToken);

member this.StartNew : Func<obj, 'Result> * obj * System.Threading.CancellationToken -> System.Threading.Tasks.Task<'Result>

Public Function StartNew(Of TResult) (function As Func(Of Object, TResult), state As Object, cancellationToken As CancellationToken) As Task(Of TResult)

형식 매개 변수

매개 변수

반품

시작된 작업입니다.

예외

설명

StartNew를 호출하는 것은 해당 생성자 중 하나를 사용하여 만든 Task<TResult> 다음 실행을 예약하도록 호출 Start 하는 것과 기능적으로 동일합니다.

.NET Framework 4.5부터 Action 개체와 함께 Run 메서드를 사용하여 기본 매개 변수로 StartNew 호출할 수 있습니다. 자세한 내용 및 코드 예제는 .NET 블로그가 있는 병렬 프로그래밍에서 Task.Run 및 Task.Factory.StartNew 항목을 참조하세요.

추가 정보

• TPL(작업 병렬 라이브러리)
• 연속 작업을 사용하여 작업 체이닝
• 작업 취소

public:
generic <typename TResult>
 System::Threading::Tasks::Task<TResult> ^ StartNew(Func<System::Object ^, TResult> ^ function, System::Object ^ state, System::Threading::Tasks::TaskCreationOptions creationOptions);

public System.Threading.Tasks.Task<TResult> StartNew<TResult>(Func<object,TResult> function, object state, System.Threading.Tasks.TaskCreationOptions creationOptions);

member this.StartNew : Func<obj, 'Result> * obj * System.Threading.Tasks.TaskCreationOptions -> System.Threading.Tasks.Task<'Result>

Public Function StartNew(Of TResult) (function As Func(Of Object, TResult), state As Object, creationOptions As TaskCreationOptions) As Task(Of TResult)

형식 매개 변수

매개 변수

반품

시작된 작업입니다.

예외

설명

StartNew를 호출하는 것은 해당 생성자 중 하나를 사용하여 만든 Task<TResult> 다음 실행을 예약하도록 호출 Start 하는 것과 기능적으로 동일합니다.

.NET Framework 4.5부터 Action 개체와 함께 Run 메서드를 사용하여 기본 매개 변수로 StartNew 호출할 수 있습니다. 자세한 내용 및 코드 예제는 .NET 블로그가 있는 병렬 프로그래밍에서 Task.Run 및 Task.Factory.StartNew 항목을 참조하세요.

추가 정보

• TPL(작업 병렬 라이브러리)
• 연속 작업을 사용하여 작업 체이닝
• 작업 취소

public:
generic <typename TResult>
 System::Threading::Tasks::Task<TResult> ^ StartNew(Func<System::Object ^, TResult> ^ function, System::Object ^ state, System::Threading::CancellationToken cancellationToken, System::Threading::Tasks::TaskCreationOptions creationOptions, System::Threading::Tasks::TaskScheduler ^ scheduler);

public System.Threading.Tasks.Task<TResult> StartNew<TResult>(Func<object,TResult> function, object state, System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskCreationOptions creationOptions, System.Threading.Tasks.TaskScheduler scheduler);

member this.StartNew : Func<obj, 'Result> * obj * System.Threading.CancellationToken * System.Threading.Tasks.TaskCreationOptions * System.Threading.Tasks.TaskScheduler -> System.Threading.Tasks.Task<'Result>

Public Function StartNew(Of TResult) (function As Func(Of Object, TResult), state As Object, cancellationToken As CancellationToken, creationOptions As TaskCreationOptions, scheduler As TaskScheduler) As Task(Of TResult)

형식 매개 변수

매개 변수

반품

시작된 작업입니다.

예외

설명

StartNew를 호출하는 것은 해당 생성자 중 하나를 사용하여 만든 Task<TResult> 다음 실행을 예약하도록 호출 Start 하는 것과 기능적으로 동일합니다.

.NET Framework 4.5부터 Action 개체와 함께 Run 메서드를 사용하여 기본 매개 변수로 StartNew 호출할 수 있습니다. 자세한 내용 및 코드 예제는 .NET 블로그가 있는 병렬 프로그래밍에서 Task.Run 및 Task.Factory.StartNew 항목을 참조하세요.

추가 정보

• TaskScheduler
• TPL(작업 병렬 라이브러리)
• 연속 작업을 사용하여 작업 체이닝
• 작업 취소