C# Downloader: ¿debería usar Threads, BackgroundWorker o ThreadPool?

Question

Escribo un programa de descarga en C# y me detengo en el siguiente problema: ¿qué tipo de método debo usar para paralelizar mis descargas y actualizar mi GUI?

En mi primer intento, utilicé 4 subprocesos y al finalizar cada uno de ellos comencé otro: el problema principal era que mi CPU funciona al 100% en cada nuevo inicio de subproceso.

Buscando en Google, encontré la existencia de BackgroundWorker y ThreadPool: afirmando que quiero actualizar mi GUI con el progreso de cada enlace que estoy descargando, ¿cuál es la mejor solución?

1) Creando 4 BackgroundWorker diferentes, adjuntando a cada evento ProgressChanged un Delegado a una función en mi GUI para actualizar el progreso?

2) ¿Utiliza ThreadPool y establece el número máximo y mínimo de hilos en el mismo valor?

Si elijo # 2, cuando no hay más hilos en la cola, ¿detiene los 4 hilos de trabajo? ¿Los suspende? Como tengo que descargar diferentes listas de enlaces (20 enlaces a cada uno de ellos) y pasar de uno a otro cuando se completa, ¿el ThreadPool inicia y detiene los hilos entre cada lista?

Si deseo cambiar el número de hilos de trabajo en vivo y decido usar ThreadPool, cambiando de 10 hilos a 6, ¿lanza y corta 4 hilos aleatorios?

Esta es la única parte que me está dando dolores de cabeza. Agradezco a cada uno de ustedes por adelantado sus respuestas.

Answer 1

se recomienda usar WebClient.DownloadFileAsync para esto. Puede tener varias descargas funcionando, cada una de las cuales genera el evento DownloadProgressChanged a medida que avanza, y DownloadFileCompleted cuando termina.

Puede controlar la concurrencia utilizando una cola con un semáforo o, si está utilizando .NET 4.0, un BlockingCollection. Por ejemplo:

// Information used in callbacks. 
class DownloadArgs 
{ 
    public readonly string Url; 
    public readonly string Filename; 
    public readonly WebClient Client; 
    public DownloadArgs(string u, string f, WebClient c) 
    { 
     Url = u; 
     Filename = f; 
     Client = c; 
    } 
} 

const int MaxClients = 4; 

// create a queue that allows the max items 
BlockingCollection<WebClient> ClientQueue = new BlockingCollection<WebClient>(MaxClients); 

// queue of urls to be downloaded (unbounded) 
Queue<string> UrlQueue = new Queue<string>(); 

// create four WebClient instances and put them into the queue 
for (int i = 0; i < MaxClients; ++i) 
{ 
    var cli = new WebClient(); 
    cli.DownloadProgressChanged += DownloadProgressChanged; 
    cli.DownloadFileCompleted += DownloadFileCompleted; 
    ClientQueue.Add(cli); 
} 

// Fill the UrlQueue here 

// Now go until the UrlQueue is empty 
while (UrlQueue.Count > 0) 
{ 
    WebClient cli = ClientQueue.Take(); // blocks if there is no client available 
    string url = UrlQueue.Dequeue(); 
    string fname = CreateOutputFilename(url); // or however you get the output file name 
    cli.DownloadFileAsync(new Uri(url), fname, 
     new DownloadArgs(url, fname, cli)); 
} 


void DownloadProgressChanged(object sender, DownloadProgressChangedEventArgs e) 
{ 
    DownloadArgs args = (DownloadArgs)e.UserState; 
    // Do status updates for this download 
} 

void DownloadFileCompleted(object sender, AsyncCompletedEventArgs e) 
{ 
    DownloadArgs args = (DownloadArgs)e.UserState; 
    // do whatever UI updates 

    // now put this client back into the queue 
    ClientQueue.Add(args.Client); 
} 

No hay necesidad de administrar explícitamente los hilos o ir al TPL.

Answer 2

Tener 100% de carga de CPU no tiene nada que ver con la descarga (ya que su red es prácticamente siempre el cuello de botella). Yo diría que tienes que verificar tu lógica de cómo esperas que se complete la descarga.

¿Puedes publicar un código del código del hilo que comiences varias veces?

Answer 3

creo que usted debe buscar en el uso de la Task Parallel Library, que es nueva en .NET 4 y está diseñado para resolver este tipo de problemas

Answer 4

Al crear 4 diferentes backgroundworkers será la creación de hilos separados que ya no interferirán con tu GUI. Los trabajadores de campo son simples de implementar y, según lo que entiendo, harán exactamente lo que usted necesita que hagan.

Personalmente, haría esto y simplemente permitiría que los otros no comiencen hasta que el anterior haya terminado. (O tal vez sólo uno, y permitir que se ejecute un método a la vez en el orden correcto.)

FYI - Backgroundworker