Come si usa Task per eseguire molti lavori "Fire and Forget"?

Question

Ho un'applicazione per Windows a cui voglio aggiungere la funzionalità TPL. Lo scenario è che ho una classe con un metodo Process che ha una serie di MailMessage s passati ad essa, così come la connessione IMAP corrente (usando AE.Net.Mail).

Voglio spin off come tanti fili possibile di un metodo Execute in un'altra classe che prende un singolo MailMessage elemento, e il MailMessage al DB, e poi utilizza la connessione IMAP per eliminare il MailMessage dal server.

Non mi preoccupo troppo di tenere traccia dei processi - Ho a che fare con un gran numero di e-mail, e non mi preoccupo se ottengo degli errori nella scrittura nel DB o nella cancellazione. Ho solo bisogno dell'applicazione per superare un gran numero di MailMessage il più velocemente possibile.

Ho giocato con Task<MailMessage>.Factory.StartNew ma non so davvero cosa sto facendo. Non mi sembra di essere in grado di dare il via ... ecco cosa ho provato:

Task test = Task.Factory.StartNew(() => 
{ 
    foreach (var mailMessage in _mms) 
    { 
    new ProcessMessage().Execute(mailMessage, imapConn); 
    } 

}); 

Sono abbastanza sicuro che non avrei dovuto un ciclo nell'espressione Lamda, quando ho eseguito questo lo fa non sembra andare in ProcessMessage.Execute.

Answer 1

Non si dovrebbe assolutamente avere un ciclo nell'espressione di lamdba. Prova questo:

_mms.ForEach(mms => { 
    Task.Factory.StartNew(() => ProcessMessage().Execute(mailMessage, imapConn)) 
}); 

Se non siete preoccupati per tenere traccia dei risultati o qualsiasi cosa che non è necessario per salvare un'istanza di un compito così come prova Task = .... si può semplicemente il metodo kickstart esecuzione in un nuovo thread utilizzando Task.Factory.StartNew() In questo modo possiamo semplicemente avviare una nuova attività per ogni messaggio di posta che si desidera elaborare e lasciare che il pool di thread si prenda cura delle cose per noi.

Inoltre, Task<MailMessage>.Factory.StartNew verrebbe utilizzato per impostare una chiamata di metodo in un altro thread che restituisce un messaggio di posta, pertanto se si chiama un metodo di annullamento non è necessario eseguire questa operazione. La sintassi Task<object> fa sempre riferimento al tipo restituito del metodo che si sta avviando con una nuova attività.

Answer 2

Questo dovrebbe fare ogni esecuzione in thread separato (in modo da sapere cosa si sta facendo ora :))

foreach (var mailMessage in _mms) 
    { 
    ThreadPool.QueueUserWorkItem(delegate 
    { 
     new ProcessMessage().Execute(mailMessage, imapConn); 
    }); 
    } 

o

foreach (var mailMessage in _mms) 
    { 
     new Thread(delegate() { new ProcessMessage().Execute(mailMessage, imapConn); }).Start(); 
    } 

Answer 3

In questo momento si sta eseguendo il ciclo foreach come un separato attività, ma probabilmente si desidera eseguire ciascuna iterazione come attività separata. Si dovrebbe provare il Parallel.ForEach:

 Parallel.ForEach(_mms, mailMessage => 
      { 
       new ProcessMessage().Execute(mailMessage, imapConn); 
      }); 

Questo eseguirà iterazioni in parallelo, che sembra essere quello che stai cercando di fare.

Answer 4

Un'altra opzione è quella di utilizzare .AsParallel() and .ForAll() sulla raccolta:

_mms.AsParallel() 
    .ForAll(mm => ProcessMessage().Execute(mm, imapConn)); 

Answer 5

quando ho eseguito questo non sembra andare in ProcessMessage.Execute.

Quindi ci deve essere qualcos'altro che non funziona nel codice, il codice dovrebbe funzionare.E avere un loop nel lambda potrebbe essere del tutto appropriato se non vuoi (o non puoi) parallelizzare il tuo codice.

Se si desidera parallelizzarlo (che non è chiaro dalla domanda), è possibile utilizzare ad esempio Parallel.ForEach() che è ottimizzato esattamente per questo.