Flusso di dati (Task Parallel Library)

La raccolta di flusso di libreria TPL è costituito dai blocchi delflusso di dati, che sono strutture di dati che memorizza nel buffer ed elaborano i dati. La libreria TPL definisce tre tipi di blocchi del flusso di dati: blocchi di origine, blocchi di destinazionee blocchi di propagazione. Un blocco di origine funge da origine dei dati e può essere letto da. Un blocco di destinazione funge da destinatario dei dati e può essere scritto su. Un blocco di propagazione funge sia da blocco di origine che un blocco di destinazione e può essere letto da e scritti su. La libreria TPL definisce l'interfaccia System.Threading.Tasks.Dataflow.ISourceBlock<TOutput> per rappresentare i database di origine, System.Threading.Tasks.Dataflow.ITargetBlock<TInput> per rappresentare le destinazioni e System.Threading.Tasks.Dataflow.IPropagatorBlock<TInput, TOutput> per rappresentare i propagatori. IPropagatorBlock<TInput, TOutput> eredita da entrambe le ISourceBlock<TOutput>e da ITargetBlock<TInput>.

La raccolta di flusso di libreria TPL fornisce vari tipi di blocchi predefiniti del flusso di dati che implementano ISourceBlock<TOutput>, ITargetBlock<TInput>e le interfacce IPropagatorBlock<TInput, TOutput>. Questi tipi di blocco del flusso di dati sono descritti in questo documento nella sezione Tipi di blocchi predefiniti del flusso di dati.

È possibile connettere i blocchi del flusso di dati per creare pipeline, che sono sequenze lineari di blocchi del flusso di dati, o reti, ovvero grafici dei blocchi del flusso di dati. Una pipeline è un form di rete. In una pipeline o una rete, i database di origine in modo asincrono si spostano i dati per i database di destinazione come tali dati diventano disponibili. Il metodo ISourceBlock<TOutput>.LinkTo collega un blocco di origine del flusso di dati a un blocco di destinazione. Un'origine può essere collegato a zero o più destinazioni, le destinazioni possono essere collegati da zero o più database di origine. È possibile aggiungere o rimuovere i blocchi del flusso di dati o da una pipeline o una rete contemporaneamente. I tipi di blocchi predefiniti del flusso di dati gestire tutti gli aspetti di thread safety di accedere e disconnect.

Per un esempio che collega i blocchi del flusso di dati per formare una pipeline di base, vedere Procedura dettagliata: creazione di una pipeline del flusso di dati. Per un esempio che collega i blocchi del flusso di dati per formare una rete più complessa, vedere Procedura dettagliata: utilizzo del flusso di dati in un'applicazione Windows Form. Per un esempio che sconnette una destinazione da un'origine dopo che il database di origine offre al database di destinazione un messaggio, vedere Procedura: scollegare i blocchi di flussi di dati.

Filtraggio

Quando si chiama il metodo ISourceBlock<TOutput>.LinkTo per collegare un database di origine a un database di destinazione, è possibile fornire un delegato che stabilisce se il blocco di destinazione deve accettare o rifiutare un messaggio in base al valore del messaggio. Questo processo di filtro garantiscono che un blocco del flusso di dati riceva solo determinati valori. Per la maggior parte dei tipi di blocchi predefiniti del flusso di dati, se un blocco di origine è connesso ai blocchi di destinazione multipli, quando un blocco di destinazione rifiutare un messaggio, le offerte di origine del messaggio alla destinazione seguente. L'ordine in cui un database di origine offre i messaggi a destinazioni è definito dal database di origine e può variare a seconda del tipo di origine. La maggior parte di interruzione di origine dei tipi di blocco che offre un messaggio dopo uno di destinazione accetta il messaggio. Un'eccezione a questa regola è la classe BroadcastBlock<T>, che offre ogni messaggio a tutti i database di destinazione, anche se alcuni target negare il messaggio. Per un esempio che utilizza il filtro per elaborare solo determinati messaggi, vedere Procedura dettagliata: utilizzo del flusso di dati in un'applicazione Windows Form.

Importante

Poiché ogni tipo di blocco di origine predefinito del flusso di dati garantisce che i messaggi vengono propagati all'ordine in cui vengono ricevuti, ogni messaggio deve essere letta dal blocco di origine prima del blocco di origine può elaborare il messaggio successivo. Pertanto, quando si utilizza il filtro per connettere più destinazioni a un database di origine, accertarsi che almeno un blocco di destinazione ricevere ogni messaggio. In caso contrario, l'applicazione potrebbe verificarsi deadlock.

Il modello di programmazione del flusso di dati è correlato al concetto di passaggio dei messaggi, in base al quale i componenti indipendenti di un programma comunicano con un altro programma inviando messaggi. Un modo per propagare i messaggi tra i componenti dell'applicazione consiste nel chiamare i metodi DataflowBlock.SendAsync e Post<TInput> per inviare messaggi al post di destinazione dei blocchi del flusso di dati (Post<TInput> agisce in modo sincrono, documenti SendAsync in modo asincrono) e Receive, ReceiveAsynce metodi TryReceive<TOutput> ricevere i messaggi dai blocchi di origine. È possibile combinare questi metodi con pipeline o reti del flusso di dati inviando i dati di input nel nodo head (un blocco di destinazione) e ricevendo i dati di input dal nodo terminale della pipeline o dei nodi finali di rete (uno o più dei blocchi). È inoltre possibile utilizzare il metodo Choose per leggere dal primo di origine forniti con dati disponibili e per eseguire l'operazione sui dati.

I dati originali offrono di blocchi per gestire i blocchi chiamando il metodo ITargetBlock<TInput>.OfferMessage. Il blocco di destinazione risponde a un messaggio offerto in tre modi: accetta il messaggio, il rifiuto del messaggio, o posticipare il messaggio. Quando la destinazione accetta il messaggio, il metodo OfferMessage restituisce Accepted. Quando la destinazione rifiuta il messaggio, il metodo OfferMessage restituisce Declined. Quando la destinazione richiede che non riceve i messaggi dal database di origine, in OfferMessage restituisce DecliningPermanently. I tipi di blocco di origine predefiniti non offrono i messaggi a destinazioni collegati dopo che questo valore restituito viene generato automaticamente sconnettono da tali destinazioni.

Quando un blocco di destinazione posticipare il messaggio per un utilizzo successivo, il metodo OfferMessage restituisce Postponed. Un blocco di destinazione che posticipa un messaggio può chiamate successive al metodo ISourceBlock<TOutput>.ReserveMessage provare a prenotare il messaggio offerto. In questa fase, il messaggio viene nuovamente o disponibile e può essere utilizzato dal blocco di destinazione, o il messaggio è stato creato da un altro database di destinazione. Quando il blocco di destinazione successiva richiede il messaggio o non necessita di messaggi, chiama il ISourceBlock<TOutput>.ConsumeMessage o il metodo ReleaseReservation, rispettivamente. La prenotazione dei messaggi in genere utilizzata dai tipi di blocco del flusso di dati che vengono eseguiti in modalità non-greedy. La modalità non-greedy viene illustrata più avanti in questo documento. Anziché riserva del messaggio posposto, un blocco di destinazione può inoltre utilizzare il metodo ISourceBlock<TOutput>.ConsumeMessage per tentare di utilizzare direttamente il messaggio posposto.

I blocchi del flusso di dati supportano il concetto di completamento. Un blocco del flusso di dati con stato completato non esegue alcuna per passare il lavoro. Ogni blocco del flusso di dati è un oggetto collegato System.Threading.Tasks.Task, noto come un'attività di completamento, che rappresenta lo stato di completamento del blocco. Poiché è possibile attendere che un oggetto Task per il completamento, tramite attività di completamento, è possibile attendere uno o più nodi finali di una rete del flusso di dati per completare. L'interfaccia IDataflowBlock definisce il metodo Complete, che informa il blocco del flusso di dati di una richiesta per completare e la proprietà Completion, che restituisce l'attività di completamento per il blocco del flusso di dati. Sia ISourceBlock<TOutput> che ereditano ITargetBlock<TInput> l'interfaccia IDataflowBlock.

Esistono due modi per determinare se un blocco del flusso di dati completato senza errori, rilevato uno o più errori, o annullati. La prima consiste nel chiamare il metodo Task.Wait l'attività di completamento in un blocco di try-catch (Try-Catch in Visual Basic). Nell'esempio seguente viene creato un oggetto ActionBlock<TInput> che genera ArgumentOutOfRangeException se il valore di input è minore di zero. AggregateException viene generato quando questo esempio viene chiamato Wait l'attività di completamento. ArgumentOutOfRangeException si accede mediante la proprietà InnerExceptions dell'oggetto AggregateException.

// Create an ActionBlock<int> object that prints its input
// and throws ArgumentOutOfRangeException if the input
// is less than zero.
var throwIfNegative = new ActionBlock<int>(n =>
{
   Console.WriteLine("n = {0}", n);
   if (n < 0)
   {
      throw new ArgumentOutOfRangeException();
   }
});

// Post values to the block.
throwIfNegative.Post(0);
throwIfNegative.Post(-1);
throwIfNegative.Post(1);
throwIfNegative.Post(-2);
throwIfNegative.Complete();

// Wait for completion in a try/catch block.
try
{
   throwIfNegative.Completion.Wait();
}
catch (AggregateException ae)
{
   // If an unhandled exception occurs during dataflow processing, all
   // exceptions are propagated through an AggregateException object.
   ae.Handle(e =>
   {
      Console.WriteLine("Encountered {0}: {1}", 
         e.GetType().Name, e.Message);
      return true;
   });
}

/* Output:
n = 0
n = -1
Encountered ArgumentOutOfRangeException: Specified argument was out of the range
 of valid values.
*/

In questo esempio viene illustrato il caso in cui un'eccezione non gestita viene inserito nel delegato di un blocco del flusso di esecuzione. È consigliabile gestire le eccezioni nei corpi di tali blocchi. Tuttavia, se non si riesce a tale scopo, il blocco si comporta come se fosse stato annullato e non elabora i messaggi in arrivo.

Quando un blocco del flusso di dati è impostato in modo esplicito, l'oggetto AggregateException contiene OperationCanceledException nella proprietà InnerExceptions. Per ulteriori informazioni sull'annullamento del flusso di dati, vedere abilitare l'annullamento più avanti in questo documento.

La seconda modalità per determinare lo stato di completamento di un blocco del flusso di dati è utilizzare una continuazione dell'attività di completamento, o utilizzare le funzionalità del linguaggio asincrone di Visual Basic e C# in modo asincrono per attendere l'attività di completamento. Il delegato che fornite all'Task.ContinueWith il metodo accetta un oggetto Task che rappresenta l'attività precedente. Nel caso della proprietà Completion, il delegato per la continuazione esegue l'attività di completamento stessa. L'esempio seguente è simile al precedente, con la differenza che utilizza il metodo ContinueWith per creare un'attività di completamento che visualizza lo stato dell'operazione globale del flusso di dati.

// Create an ActionBlock<int> object that prints its input
// and throws ArgumentOutOfRangeException if the input
// is less than zero.
var throwIfNegative = new ActionBlock<int>(n =>
{
   Console.WriteLine("n = {0}", n);
   if (n < 0)
   {
      throw new ArgumentOutOfRangeException();
   }
});

// Create a continuation task that prints the overall 
// task status to the console when the block finishes.
throwIfNegative.Completion.ContinueWith(task =>
{
   Console.WriteLine("The status of the completion task is '{0}'.", 
      task.Status);
});

// Post values to the block.
throwIfNegative.Post(0);
throwIfNegative.Post(-1);
throwIfNegative.Post(1);
throwIfNegative.Post(-2);
throwIfNegative.Complete();

// Wait for completion in a try/catch block.
try
{
   throwIfNegative.Completion.Wait();
}
catch (AggregateException ae)
{
   // If an unhandled exception occurs during dataflow processing, all
   // exceptions are propagated through an AggregateException object.
   ae.Handle(e =>
   {
      Console.WriteLine("Encountered {0}: {1}",
         e.GetType().Name, e.Message);
      return true;
   });
}

/* Output:
n = 0
n = -1
The status of the completion task is 'Faulted'.
Encountered ArgumentOutOfRangeException: Specified argument was out of the range
 of valid values.
*/

È possibile utilizzare le proprietà come IsCanceled nel corpo dell'attività di continuazione ottenere informazioni aggiuntive sullo stato di completamento di un blocco del flusso di dati. Per ulteriori informazioni sulle attività di continuazione e la rispettiva per l'annullamento e la gestione degli errori, vedere Attività di continuazionesu, su Annullamento delle attività, in Gestione delle eccezioni (Task Parallel Library)e su Procedura: gestire le eccezioni generate dalle attività.

[vai all'inizio]

Dati al fine dei blocchi di buffer con gli utenti di dati. La raccolta di flusso di libreria TPL fornisce tre tipi di blocco memorizzazione nel buffer: System.Threading.Tasks.Dataflow.BufferBlock<T>, System.Threading.Tasks.Dataflow.BroadcastBlock<T>e System.Threading.Tasks.Dataflow.WriteOnceBlock<T>.

BufferBlock (T)

// Create a BufferBlock<int> object.
var bufferBlock = new BufferBlock<int>();

// Post several messages to the block.
for (int i = 0; i < 3; i++)
{
   bufferBlock.Post(i);
}

// Receive the messages back from the block.
for (int i = 0; i < 3; i++)
{
   Console.WriteLine(bufferBlock.Receive());
}

/* Output:
   0
   1
   2
 */

BroadcastBlock (T)

// Create a BroadcastBlock<double> object.
var broadcastBlock = new BroadcastBlock<double>(null);

// Post a message to the block.
broadcastBlock.Post(Math.PI);

// Receive the messages back from the block several times.
for (int i = 0; i < 3; i++)
{
   Console.WriteLine(broadcastBlock.Receive());
}

/* Output:
   3.14159265358979
   3.14159265358979
   3.14159265358979
 */

WriteOnceBlock (T)

// Create a WriteOnceBlock<string> object.
var writeOnceBlock = new WriteOnceBlock<string>(null);

// Post several messages to the block in parallel. The first 
// message to be received is written to the block. 
// Subsequent messages are discarded.
Parallel.Invoke(
   () => writeOnceBlock.Post("Message 1"),
   () => writeOnceBlock.Post("Message 2"),
   () => writeOnceBlock.Post("Message 3"));

// Receive the message from the block.
Console.WriteLine(writeOnceBlock.Receive());

/* Sample output:
   Message 2
 */

I blocchi di esecuzione chiamano forniti dall'utente il delegato di ogni porzione di dati ricevuti. La raccolta di flusso di libreria TPL fornisce tre tipi di blocco di esecuzione: ActionBlock<TInput>, System.Threading.Tasks.Dataflow.TransformBlock<TInput, TOutput>e System.Threading.Tasks.Dataflow.TransformManyBlock<TInput, TOutput>.

ActionBlock (T)

// Create an ActionBlock<int> object that prints values
// to the console.
var actionBlock = new ActionBlock<int>(n => Console.WriteLine(n));

// Post several messages to the block.
for (int i = 0; i < 3; i++)
{
   actionBlock.Post(i * 10);
}

// Set the block to the completed state and wait for all 
// tasks to finish.
actionBlock.Complete();
actionBlock.Completion.Wait();

/* Output:
   0
   10
   20
 */

TransformBlock (TInput, TOutput)

// Create a TransformBlock<int, double> object that 
// computes the square root of its input.
var transformBlock = new TransformBlock<int, double>(n => Math.Sqrt(n));

// Post several messages to the block.
transformBlock.Post(10);
transformBlock.Post(20);
transformBlock.Post(30);

// Read the output messages from the block.
for (int i = 0; i < 3; i++)
{
   Console.WriteLine(transformBlock.Receive());
}

/* Output:
   3.16227766016838
   4.47213595499958
   5.47722557505166
 */

TransformManyBlock (TInput, TOutput)

// Create a TransformManyBlock<string, char> object that splits
// a string into its individual characters.
var transformManyBlock = new TransformManyBlock<string, char>(
   s => s.ToCharArray());

// Post two messages to the first block.
transformManyBlock.Post("Hello");
transformManyBlock.Post("World");

// Receive all output values from the block.
for (int i = 0; i < ("Hello" + "World").Length; i++)
{
   Console.WriteLine(transformManyBlock.Receive());
}

/* Output:
   H
   e
   l
   l
   o
   W
   o
   r
   l
   d
 */

Livello di parallelismo

Riepilogo dei tipi delegati

I blocchi di raggruppamento combinano i dati da uno o più database di origine e in vari vincoli. La raccolta di flusso di libreria TPL fornisce tre tipi di blocco di join: BatchBlock<T>, JoinBlock<T1, T2>e BatchedJoinBlock<T1, T2>.

BatchBlock (T)

// Create a BatchBlock<int> object that holds ten
// elements per batch.
var batchBlock = new BatchBlock<int>(10);

// Post several values to the block.
for (int i = 0; i < 13; i++)
{
   batchBlock.Post(i);
}
// Set the block to the completed state. This causes
// the block to propagate out any any remaining
// values as a final batch.
batchBlock.Complete();

// Print the sum of both batches.

Console.WriteLine("The sum of the elements in batch 1 is {0}.",
   batchBlock.Receive().Sum());

Console.WriteLine("The sum of the elements in batch 2 is {0}.",
   batchBlock.Receive().Sum());

/* Output:
   The sum of the elements in batch 1 is 45.
   The sum of the elements in batch 2 is 33.
 */

JoinBlock (T1,T2,…)

// Create a JoinBlock<int, int, char> object that requires
// two numbers and an operator.
var joinBlock = new JoinBlock<int, int, char>();

// Post two values to each target of the join.

joinBlock.Target1.Post(3);
joinBlock.Target1.Post(6);

joinBlock.Target2.Post(5);
joinBlock.Target2.Post(4);

joinBlock.Target3.Post('+');
joinBlock.Target3.Post('-');

// Receive each group of values and apply the operator part
// to the number parts.

for (int i = 0; i < 2; i++)
{
   var data = joinBlock.Receive();
   switch (data.Item3)
   {
      case '+':
         Console.WriteLine("{0} + {1} = {2}",
            data.Item1, data.Item2, data.Item1 + data.Item2);
         break;
      case '-':
         Console.WriteLine("{0} - {1} = {2}",
            data.Item1, data.Item2, data.Item1 - data.Item2);
         break;
      default:
         Console.WriteLine("Unknown operator '{0}'.", data.Item3);
         break;
   }
}

/* Output:
   3 + 5 = 8
   6 - 4 = 2
 */

BatchedJoinBlock (T1,T2,…)

// Create a JoinBlock<int, int, char> object that requires
// two numbers and an operator.
var joinBlock = new JoinBlock<int, int, char>();

// Post two values to each target of the join.

joinBlock.Target1.Post(3);
joinBlock.Target1.Post(6);

joinBlock.Target2.Post(5);
joinBlock.Target2.Post(4);

joinBlock.Target3.Post('+');
joinBlock.Target3.Post('-');

// Receive each group of values and apply the operator part
// to the number parts.

for (int i = 0; i < 2; i++)
{
   var data = joinBlock.Receive();
   switch (data.Item3)
   {
      case '+':
         Console.WriteLine("{0} + {1} = {2}",
            data.Item1, data.Item2, data.Item1 + data.Item2);
         break;
      case '-':
         Console.WriteLine("{0} - {1} = {2}",
            data.Item1, data.Item2, data.Item1 - data.Item2);
         break;
      default:
         Console.WriteLine("Unknown operator '{0}'.", data.Item3);
         break;
   }
}

/* Output:
   3 + 5 = 8
   6 - 4 = 2
 */

Ogni blocco predefinito del flusso di dati utilizzato il meccanismo di pianificazione delle attività di libreria TPL per eseguire attività quali la propagazione dei dati in un database di destinazione, la ricezione di dati da un'origine ed eseguire i delegati definiti dall'utente quando i dati diventano disponibili. TaskScheduler è una classe astratta che rappresenta un'utilità di pianificazione che mette in coda le attività dei thread. L'utilità di pianificazione predefinita, Default, utilizzare la classe ThreadPool accodare ed eseguire lavoro. È possibile eseguire l'override dell'utilità di pianificazione predefinita impostando la proprietà TaskScheduler quando si costruisce un oggetto del blocco del flusso di dati.

Quando la stessa utilità di pianificazione gestisce i più blocchi del flusso di dati, è possibile applicare i criteri relativi. Ad esempio, se si blocca in ciascuno del flusso di dati configurati per utilizzare l'utilità di pianificazione determina lo stesso oggetto ConcurrentExclusiveSchedulerPair, tutto il lavoro eseguito tramite questi blocchi è serializzata. Analogamente, se questi blocchi sono configurati per utilizzare l'utilità di pianificazione simultanee lo stesso oggetto ConcurrentExclusiveSchedulerPair e l'utilità di pianificazione è configurato per avere un livello di concorrenza massimo, tutto il lavoro da questi blocchi è limitato al numero di operazioni simultanee. Per un esempio che utilizza la classe ConcurrentExclusiveSchedulerPair per abilitare le operazioni di lettura per essere eseguite in parallelo, ma le operazioni di scrittura per verificare separatamente di tutte le altre operazioni, vedere Procedura: specificare un'utilità di pianificazione in un blocco di flussi di dati. Per ulteriori informazioni sulle utilità di pianificazione in TPL, inclusa la classe ConcurrentExclusiveSchedulerPair, vedere Utilità di pianificazione delle attività.

Per impostazione predefinita, i tre tipi di blocco che la raccolta di flusso di libreria TPL modo, ActionBlock<TInput>, TransformBlock<TInput, TOutput>e TransformManyBlock<TInput, TOutput>di esecuzione, elaborare un messaggio per volta. Questi del flusso dei tipi di blocco dei messaggi anche nell'ordine in cui vengono ricevuti. Per consentire a questi blocchi del flusso di dati per elaborare i messaggi contemporaneamente, impostare la proprietà ExecutionDataflowBlockOptions.MaxDegreeOfParallelism quando si crea l'oggetto del blocco del flusso di dati.

Il valore predefinito MaxDegreeOfParallelism è 1, che garantisce che il blocco del flusso di dati elabora un messaggio per volta. Impostare questa proprietà su un valore maggiore di 1 consente al blocco del flusso di dati per elaborare i messaggi contemporaneamente più. Impostare la proprietà su DataflowBlockOptions.Unbounded consente all'utilità di pianificazione sottostante per gestire il livello massimo di concorrenza.

Importante
Quando si specifica un livello massimo di parallelismo maggiore di 1, più messaggi vengono elaborati contemporaneamente, pertanto i messaggi potrebbero non essere elaborati in ordine in cui vengono ricevuti. L'ordine in cui i messaggi vengono restituiti dal blocco, tuttavia, correttamente verrà ordinato.

Poiché la proprietà MaxDegreeOfParallelism rappresenta il livello massimo di parallelismo, il blocco del flusso di dati può eseguire con un massimo grado di parallelismo specificato. Il blocco del flusso di dati può contenere un massimo grado di parallelismo per soddisfare le richieste funzionali o perché è una mancanza di risorse di sistema disponibili. Un blocco del flusso di dati non può mai più parallelismo specificato.

Il valore della proprietà MaxDegreeOfParallelism è esclusivo a ogni oggetto del blocco del flusso di dati. Ad esempio, se quattro blocchi di flusso oggetto ognuno specificare 1 per il massimo grado di parallelismo, tutti e quattro gli oggetti del blocco del flusso di dati potenzialmente può essere eseguito in parallelo.

Per un esempio che imposta il massimo grado di parallelismo per abilitare le operazioni lunghe per verificare in parallelo, vedere Procedura: specificare il grado di parallelismo in un blocco di flussi di dati.

I tipi di blocchi predefiniti del flusso di dati utilizzano le attività elaborare gli elementi di input. Ciò contribuisce a ridurre il numero di oggetti task necessari per elaborare i dati, che consentono alle applicazioni eseguite in modo più efficiente. Tuttavia, quando le attività da un set di blocchi del flusso di dati a elaborare i dati, attività da altri blocchi del flusso di dati potrebbero essere necessario attendere il tempo di elaborazione accodamento messaggi. Per abilitare la migliore equità tra attività del flusso di dati, impostare la proprietà MaxMessagesPerTask. Quando MaxMessagesPerTask è impostato su DataflowBlockOptions.Unbounded, ovvero l'impostazione predefinita, l'attività utilizzata da un blocco del flusso di dati elabora tutti i messaggi come sono disponibili. Quando MaxMessagesPerTask è impostato su un valore diverso da Unbounded, i processi del blocco del flusso di dati al massimo questo numero di messaggi per l'oggetto Task. Sebbene impostare la proprietà MaxMessagesPerTask può aumentare l'equità tra le attività, può provocare il sistema per creare più attività, che possono ridurre le prestazioni.

La libreria TPL fornisce un meccanismo che consente alle attività coordinare l'annullamento in modo cooperativo. Per consentire ai blocchi del flusso di dati per partecipare a questo meccanismo di annullamento, impostare la proprietà CancellationToken. Quando l'oggetto CancellationToken è impostato sullo stato annullato, tutti i blocchi del flusso di dati che controllano l'esecuzione del token di inizio dell'elemento corrente ma non iniziano elaborare gli elementi successivi. Questi blocchi del flusso di dati anche possibile definire i messaggi memorizzati nel buffer, connessioni della versione ai blocchi di origine e di destinazione e transizione allo stato canceled. La transizione allo stato canceled, la proprietà Completion è stata impostata la proprietà Status a Canceled, a meno che l'eccezione venga eseguita durante l'elaborazione. In tal caso, Status è impostato su Faulted.

Per un esempio che illustra come utilizzare l'annullamento in un'applicazione Windows Form, vedere Procedura: annullare un blocco di flussi di dati. Per ulteriori informazioni sull'annullamento nella libreria TPL, vedere Annullamento delle attività.

Diversi che raggruppano i tipi di blocco del flusso di dati possono essere eseguite in modalità greedy e non-greedy. Per impostazione predefinita, i tipi di blocchi predefiniti del flusso di dati vengono eseguiti in modalità greedy.

Per i tipi di blocco di join come JoinBlock<T1, T2>, la modalità greedy significa che il blocco immediatamente accetta i dati anche se i dati corrispondenti a cui aggiungere non è ancora disponibile. La modalità non-greedy significa che il blocco posticipa tutti i messaggi in arrivo finché non ne sia disponibile in ciascuna delle relative destinazioni per completare l'operazione di join. Se uno dei messaggi posposti non sono più disponibili, il blocco di join pubblica tutti i messaggi posposti e riavviare il processo. Per la classe BatchBlock<T>, il comportamento di non-greedy e di greedy è simile, tranne che nella modalità specifica, un oggetto BatchBlock<T> posticipa tutti i messaggi in arrivo finché sufficiente non sono disponibili da origine distinti per completare un batch.

Per specificare la modalità non-greedy per un blocco del flusso di dati, impostare Greedy a False. Per un esempio che illustra come utilizzare la modalità non-greedy per consentire a più blocchi di join per condividere più efficiente un'origine dati, vedere Procedura: utilizzare JoinBlock per leggere dati da più origini.

[vai all'inizio]