Differenza tra delegate.BeginInvoke e utilizzando fili ThreadPool in C#

Question

In C# v'è alcuna differenza tra l'utilizzo di un delegato per fare qualche lavoro in modo asincrono (chiamata BeginInvoke()) e con una filettatura ThreadPool come mostrato sotto

public void asynchronousWork(object num) 
    { 
     //asynchronous work to be done 
     Console.WriteLine(num); 
    } 

public void test() 
    { 
     Action<object> myCustomDelegate = this.asynchronousWork; 
     int x = 7; 

     //Using Delegate 
     myCustomDelegate.BeginInvoke(7, null, null); 

     //Using Threadpool 
     ThreadPool.QueueUserWorkItem(new WaitCallback(asynchronousWork), 7); 
     Thread.Sleep(2000); 
    } 

Modifica:
BeginInvoke si assicura che un thread dal pool di thread venga utilizzato per eseguire il codice asincrono, quindi c'è qualche differenza?

Answer 1

Joe Duffy, nel suo libro Concurrent Programming on Windows (pagina 418), dice questo circa Delegate.BeginInvoke:

Tutti i tipi di delegati, per offerta convenzione un BeginInvoke e EndInvoke metodo accanto al normale metodo di sincrono Invoke. Sebbene si tratti di una buona funzionalità del modello di programmazione, dovresti stare lontano da loro ovunque sia possibile. L'implementazione utilizza un'infrastruttura remota che impone un overhead considerevole alla chiamata asincrona. Il lavoro in coda per il pool di thread direttamente è spesso un approccio migliore, anche se ciò significa che devi coordinare te stesso la logica del rendez-vous.

EDIT: Ho creato la seguente semplice test delle relative spese generali:

int counter = 0; 
int iterations = 1000000; 
Action d =() => { Interlocked.Increment(ref counter); }; 

var stopwatch = new System.Diagnostics.Stopwatch(); 
stopwatch.Start(); 
for (int i = 0; i < iterations; i++) 
{ 
    var asyncResult = d.BeginInvoke(null, null); 
} 

do { } while(counter < iterations); 
stopwatch.Stop(); 

Console.WriteLine("Took {0}ms", stopwatch.ElapsedMilliseconds); 
Console.ReadLine(); 

Sulla mia macchina le corse di prova di cui sopra in circa 20 secondi. Sostituzione della chiamata BeginInvoke con

System.Threading.ThreadPool.QueueUserWorkItem(state => 
{ 
    Interlocked.Increment(ref counter); 
}); 

cambia il tempo di esecuzione di 864ms.