Task Oluşturucular

Başvuru

Tanım

Ad Alanı:: System.Threading.Tasks

Bütünleştirilmiş Kod:: System.Threading.Tasks.dll

Bütünleştirilmiş Kod:: System.Runtime.dll

Bütünleştirilmiş Kod:: mscorlib.dll

Bütünleştirilmiş Kod:: netstandard.dll

Önemli

Bazı bilgiler ürünün ön sürümüyle ilgilidir ve sürüm öncesinde önemli değişiklikler yapılmış olabilir. Burada verilen bilgilerle ilgili olarak Microsoft açık veya zımni hiçbir garanti vermez.

Yeni Taskbir başlatır.

Aşırı Yüklemeler

Task(Action)	Belirtilen eylemle yeni Task bir başlatır.
Task(Action, CancellationToken)	Belirtilen eylem ve CancellationTokenile yeni Task bir başlatır.
Task(Action, TaskCreationOptions)	Belirtilen eylem ve oluşturma seçenekleriyle yeni Task bir başlatır.
Task(Action<Object>, Object)	Belirtilen eylem ve durumla yeni Task bir başlatır.
Task(Action, CancellationToken, TaskCreationOptions)	Belirtilen eylem ve oluşturma seçenekleriyle yeni Task bir başlatır.
Task(Action<Object>, Object, CancellationToken)	Belirtilen eylem, durum ve CancellationTokenile yeni Task bir başlatır.
Task(Action<Object>, Object, TaskCreationOptions)	Belirtilen eylem, durum ve seçeneklerle yeni Task bir başlatır.
Task(Action<Object>, Object, CancellationToken, TaskCreationOptions)	Belirtilen eylem, durum ve seçeneklerle yeni Task bir başlatır.

Task(Action)

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

Belirtilen eylemle yeni Task bir başlatır.

public:
 Task(Action ^ action);

public Task (Action action);

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

Public Sub New (action As Action)

Parametreler

action: Action

Görevde yürütülecek kodu temsil eden temsilci.

Özel durumlar

ArgumentNullException

action bağımsız değişkenidirnull.

Örnekler

Aşağıdaki örnek, belirtilen dizinlerdeki dosya adlarını alan görevler oluşturmak için oluşturucuyu kullanır Task(Action) . Tüm görevler dosya adlarını tek ConcurrentBag<T> bir nesneye yazar. Örnek daha sonra tüm görevlerin WaitAll(Task[]) tamamlandığından emin olmak için yöntemini çağırır ve ardından nesneye ConcurrentBag<T> yazılan toplam dosya adı sayısının sayısını görüntüler.

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

Aşağıdaki örnek, tek bir işlemde Run(Action) görevin örneğini oluşturmak ve çalıştırmak için yöntemini kullanması dışında aynıdır. yöntemi, görevi temsil eden nesneyi döndürür 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

Açıklamalar

Bu oluşturucu yalnızca, görevin oluşturulması ve başlatılmasının ayrılmasının gerekli olduğu gelişmiş senaryolarda kullanılmalıdır.

Bu oluşturucuyu çağırmak yerine, bir Task nesnenin örneğini oluşturmanın ve bir görevi başlatmanın en yaygın yolu statik Task.Run(Action) veya TaskFactory.StartNew(Action) yöntemini çağırmaktır.

Yalnızca API tüketicisinin beklemesi gereken bir şeye sahip olması için eylem içermeyen bir görev gerekiyorsa, TaskCompletionSource<TResult> bir kullanılmalıdır.

Ayrıca bkz.

Run(Action)

Şunlara uygulanır

Task(Action, CancellationToken)

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

Belirtilen eylem ve CancellationTokenile yeni Task bir başlatır.

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)

Parametreler

action: Action

Görevde yürütülecek kodu temsil eden temsilci.

cancellationToken: CancellationToken

CancellationToken Yeni görevin gözlemleyeceği.

Özel durumlar

ObjectDisposedException

Sağlanan CancellationToken zaten atılmış.

ArgumentNullException

Bağımsız action değişken null.

Örnekler

Aşağıdaki örnek, C:\Windows\System32 dizinindeki dosyaları yineleyen bir görev oluşturmak için oluşturucuyu çağırır Task(Action, CancellationToken) . Lambda ifadesi, bir List<T> nesneye her dosya hakkında bilgi eklemek için yöntemini çağırırParallel.ForEach. Döngü tarafından Parallel.ForEach çağrılan her ayrılmış iç içe görev, iptal belirtecinin durumunu denetler ve iptal istenirse yöntemini çağırır CancellationToken.ThrowIfCancellationRequested . yöntemi, CancellationToken.ThrowIfCancellationRequested çağıran iş parçacığı yöntemini çağırdığında Task.Wait bir blokta işlenen bir catch özel durum oluştururOperationCanceledException. Daha Start sonra görevi başlatmak için yöntemi çağrılır.

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

Açıklamalar

Bu oluşturucuyu çağırmak yerine, bir Task nesnenin örneğini oluşturmanın ve bir görevi başlatmanın en yaygın yolu statik Task.Run(Action, CancellationToken) ve TaskFactory.StartNew(Action, CancellationToken) yöntemleri çağırmaktır. Bu oluşturucunun sunduğu tek avantaj, nesne örneklemesinin görev çağrısından ayrılmasına izin vermesidir.

Daha fazla bilgi için bkz. Yönetilen İş Parçacıklarında Görev Paralelliği (Görev Paralel Kitaplığı) ve İptal.

Şunlara uygulanır

Task(Action, TaskCreationOptions)

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

Belirtilen eylem ve oluşturma seçenekleriyle yeni Task bir başlatır.

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)

Parametreler

action: Action

Görevde yürütülecek kodu temsil eden temsilci.

creationOptions: TaskCreationOptions

Görevin TaskCreationOptions davranışını özelleştirmek için kullanılır.

Özel durumlar

ArgumentNullException

Bağımsız action değişken null.

ArgumentOutOfRangeException

creationOptions bağımsız değişkeni için TaskCreationOptionsgeçersiz bir değer belirtir.

Açıklamalar

Bu oluşturucuyu çağırmak yerine, bir Task nesnenin örneğini oluşturmanın ve bir görevi başlatmanın en yaygın yolu statik TaskFactory.StartNew(Action, TaskCreationOptions) yöntemi çağırmaktır. Bu oluşturucunun sunduğu tek avantaj, nesne örneklemesinin görev çağrısından ayrılmasına izin vermesidir.

Şunlara uygulanır

Task(Action<Object>, Object)

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

Belirtilen eylem ve durumla yeni Task bir başlatır.

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)

Parametreler

action: Action<Object>

Görevde yürütülecek kodu temsil eden temsilci.

state: Object

Eylem tarafından kullanılacak verileri temsil eden nesne.

Özel durumlar

ArgumentNullException

Bağımsız action değişken null.

Örnekler

Aşağıdaki örnek, 6 harfli sözcüklerden oluşan bir dizi tanımlar. Daha sonra her sözcük oluşturucuya Task(Action<Object>, Object) bağımsız değişken olarak geçirilir ve Action<T> bu durumda temsilci sözcükteki karakterleri karıştırıp özgün sözcüğü ve karışık sürümünü görüntüler.

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

Açıklamalar

Bu oluşturucuyu çağırmak yerine, bir Task nesnenin örneğini oluşturmanın ve bir görevi başlatmanın en yaygın yolu statik TaskFactory.StartNew(Action<Object>, Object) yöntemi çağırmaktır. Bu oluşturucunun sunduğu tek avantaj, nesne örneklemesinin görev çağrısından ayrılmasına izin vermesidir.

Ayrıca bkz.

StartNew(Action<Object>, Object)

Şunlara uygulanır

Task(Action, CancellationToken, TaskCreationOptions)

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

Belirtilen eylem ve oluşturma seçenekleriyle yeni Task bir başlatır.

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)

Parametreler

action: Action

Görevde yürütülecek kodu temsil eden temsilci.

cancellationToken: CancellationToken

CancellationToken Yeni görevin gözlemleyeceği.

creationOptions: TaskCreationOptions

Görevin TaskCreationOptions davranışını özelleştirmek için kullanılır.

Özel durumlar

ObjectDisposedException

Oluşturulan CancellationTokenSourcecancellationToken zaten atılmış.

ArgumentNullException

Bağımsız action değişken null.

ArgumentOutOfRangeException

creationOptions bağımsız değişkeni için TaskCreationOptionsgeçersiz bir değer belirtir.

Açıklamalar

Bu oluşturucuyu çağırmak yerine, bir Task nesnenin örneğini oluşturmanın ve bir görevi başlatmanın en yaygın yolu statik TaskFactory.StartNew(Action, CancellationToken, TaskCreationOptions, TaskScheduler) yöntemi çağırmaktır. Bu oluşturucunun sunduğu tek avantaj, nesne örneklemesinin görev çağrısından ayrılmasına izin vermesidir.

Daha fazla bilgi için bkz . Görev Paralelliği (Görev Paralel Kitaplığı) ve Görev İptali.

Şunlara uygulanır

Task(Action<Object>, Object, CancellationToken)

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

Belirtilen eylem, durum ve CancellationTokenile yeni Task bir başlatır.

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)

Parametreler

action: Action<Object>

Görevde yürütülecek kodu temsil eden temsilci.

state: Object

Eylem tarafından kullanılacak verileri temsil eden nesne.

cancellationToken: CancellationToken

CancellationToken Yeni görevin gözlemleyeceği.

Özel durumlar

ObjectDisposedException

Oluşturulan CancellationTokenSourcecancellationToken zaten atılmış.

ArgumentNullException

Bağımsız action değişken null.

Açıklamalar

Bu oluşturucuyu çağırmak yerine, bir Task nesnenin örneğini oluşturmanın ve bir görevi başlatmanın en yaygın yolu statik TaskFactory.StartNew(Action<Object>, Object, CancellationToken) yöntemi çağırmaktır. Bu oluşturucunun sunduğu tek avantaj, nesne örneklemesinin görev çağrısından ayrılmasına izin vermesidir.

Şunlara uygulanır

Task(Action<Object>, Object, TaskCreationOptions)

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

Belirtilen eylem, durum ve seçeneklerle yeni Task bir başlatır.

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)

Parametreler

action: Action<Object>

Görevde yürütülecek kodu temsil eden temsilci.

state: Object

Eylem tarafından kullanılacak verileri temsil eden nesne.

creationOptions: TaskCreationOptions

Görevin TaskCreationOptions davranışını özelleştirmek için kullanılır.

Özel durumlar

ArgumentNullException

Bağımsız action değişken null.

ArgumentOutOfRangeException

creationOptions bağımsız değişkeni için TaskCreationOptionsgeçersiz bir değer belirtir.

Açıklamalar

Bu oluşturucuyu çağırmak yerine, bir Task nesnenin örneğini oluşturmanın ve bir görevi başlatmanın en yaygın yolu statik TaskFactory.StartNew(Action<Object>, Object, TaskCreationOptions) yöntemi çağırmaktır. Bu oluşturucunun sunduğu tek avantaj, nesne örneklemesinin görev çağrısından ayrılmasına izin vermesidir.

Şunlara uygulanır

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

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

Belirtilen eylem, durum ve seçeneklerle yeni Task bir başlatır.

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)

Parametreler

action: Action<Object>

Görevde yürütülecek kodu temsil eden temsilci.

state: Object

Eylem tarafından kullanılacak verileri temsil eden nesne.

cancellationToken: CancellationToken

CancellationToken Yeni görevin gözlemleyeceği.

creationOptions: TaskCreationOptions

Görevin TaskCreationOptions davranışını özelleştirmek için kullanılır.

Özel durumlar

ObjectDisposedException

Oluşturulan CancellationTokenSourcecancellationToken zaten atılmış.

ArgumentNullException

Bağımsız action değişken null.

ArgumentOutOfRangeException

creationOptions bağımsız değişkeni için TaskCreationOptionsgeçersiz bir değer belirtir.

Açıklamalar

Bu oluşturucuyu çağırmak yerine, bir Task nesnenin örneğini oluşturmanın ve bir görevi başlatmanın en yaygın yolu statik TaskFactory.StartNew(Action<Object>, Object, CancellationToken, TaskCreationOptions, TaskScheduler) yöntemi çağırmaktır. Bu oluşturucunun sunduğu tek avantaj, nesne örneklemesinin görev çağrısından ayrılmasına izin vermesidir.

Şunlara uygulanır

Task Oluşturucular

Tanım

Aşırı Yüklemeler

Task(Action)

Parametreler

Özel durumlar

Örnekler

Açıklamalar

Ayrıca bkz.

Şunlara uygulanır

Task(Action, CancellationToken)

Parametreler

Özel durumlar

Örnekler

Açıklamalar

Şunlara uygulanır

Task(Action, TaskCreationOptions)

Parametreler

Özel durumlar

Açıklamalar

Şunlara uygulanır

Task(Action<Object>, Object)

Parametreler

Özel durumlar

Örnekler

Açıklamalar

Ayrıca bkz.

Şunlara uygulanır

Task(Action, CancellationToken, TaskCreationOptions)

Parametreler

Özel durumlar

Açıklamalar

Şunlara uygulanır

Task(Action<Object>, Object, CancellationToken)

Parametreler

Özel durumlar

Açıklamalar

Şunlara uygulanır

Task(Action<Object>, Object, TaskCreationOptions)

Parametreler

Özel durumlar

Açıklamalar

Şunlara uygulanır

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

Parametreler

Özel durumlar

Açıklamalar

Şunlara uygulanır

Geri Bildirim

Ek kaynaklar