Task.Factory.StartNew vs Task.Factory.FromAsync

Question

Supponiamo di disporre di un metodo di I/O (come un metodo per effettuare chiamate DB). Questo metodo può essere eseguito sia in modo sincrono che asincrono. Cioè,

1. Sync:

   IOMethod() 
   

2. asincrono:

   BeginIOMethod() 
   EndIOMethod() 
   

Poi quando eseguiamo il metodo in diversi modi, come mostrato sotto, qual è la differenza di prestazioni in termini dell'utilizzo delle risorse?

1. var task = Task.Factory.StartNew(() => { IOMethod(); }); 
   task.Wait(); 
   

2. var task = Task.Factory.FromAsync(BeginIOMethod, EndIOMethod, ...); 
   task.Wait(); 
   

Answer 1

var task = Task.Factory.StartNew(() => { IOMethod(); }); 
task.Wait(); 

Questo bloccherà un filo pool di thread mentre IOMethod() è l'esecuzione e anche bloccare il tuo thread corrente a causa del Wait(). Totale thread bloccati: 2.

var task = Task.Factory.FromAsync(BeginIOMethod, EndIOMethod, ...); 
task.Wait(); 

Questa volontà (più probabile) eseguire l'operazione in modo asincrono senza utilizzare un filo, ma bloccherà il thread corrente a causa della Wait(). Totale discussioni bloccate: 1.

IOMethod(); 

Questo bloccherà il thread corrente mentre IOMethod() è in esecuzione. Totale thread bloccati: 1.

Se è necessario bloccare il thread corrente, o se il blocco è ok per te, allora dovresti usare questo, perché provare ad usare TPL non ti darà nulla.

var task = Task.Factory.FromAsync(BeginIOMethod, EndIOMethod, ...); 
await task; 

Questo sarà eseguire l'operazione in modo asincrono senza utilizzare un filo, e sarà anche attendere il completamento dell'operazione asincrono, grazie alla await. Totale thread bloccati: 0.

Questo è ciò che si dovrebbe usare se si desidera sfruttare l'asincronia e si può usare C# 5.0.

var task = Task.Factory.FromAsync(BeginIOMethod, EndIOMethod, ...); 
task.ContinueWith(() => /* rest of the method here */); 

Questo sarà eseguire l'operazione in modo asincrono senza utilizzare un filo, e sarà anche attendere il completamento dell'operazione asincrono, grazie alla ContinueWith(). Totale thread bloccati: 0.

Questo è ciò che si dovrebbe usare se si desidera sfruttare l'asincronia e non è possibile utilizzare C# 5.0.

Answer 2

(1) sarà (probabilmente) causare il pool di thread .NET per elaborare la vostra Task.

(2) utilizzerà qualsiasi meccanismo utilizzato dalla coppia BeginIOMethod/EndIOMethod in modo nativo per gestire la parte asincrona, che potrebbe o meno coinvolgere il pool di thread .NET.

Ad esempio, se il BeginIOMethod sta inviando un messaggio TCP attraverso la rete internet, e in un secondo momento il destinatario sta per inviare un messaggio TCP in risposta (ricevuto da EndIOMethod), allora la natura asincrona dell'operazione è non viene fornito dal pool di thread .NET. La libreria TCP in uso sta fornendo la parte asincrona.

Questa operazione può essere eseguita utilizzando TaskCompletionSource class. Task.Factory.FromAsync, è possibile creare un Task<T>, restituire il Task<T>, quindi utilizzare EndIOMethod come trigger per inserire Result nello Task<T> restituito dal modulo Task.Factory.FromAsync al momento della chiamata.

Qual è la differenza di prestazioni in termini di utilizzo delle risorse?

La differenza tra (1) e (2) è principalmente se il pool di thread .NET avrà o meno il suo carico di lavoro aggiunto. In generale, la cosa giusta da fare è scegliere Task.Factory.FromAsync se si dispone solo di una coppia Begin.../End... e Task.Factory.StartNew.

---

Se stai usando C# 5.0, allora si dovrebbe utilizzare il non-blocking await task; invece di task.Wait();. (Si veda la risposta del svick.)