c#.net 4.5 async / multithread?

Si vous souhaitez utiliser le async et await mots-clés (bien que vous n'ayez pas à le faire, mais ils facilitent les choses dans. Net 4.5), vous devez d'abord changer votre méthode ScrapeData pour retourner un Task<T> instance en utilisant le mot clé async, comme ceci:

async Task<DataSet> ScrapeDataAsync(Uri url)
{
    // Create the HttpClientHandler which will handle cookies.
    var handler = new HttpClientHandler();

    // Set cookies on handler.

    // Await on an async call to fetch here, convert to a data
    // set and return.
    var client = new HttpClient(handler);

    // Wait for the HttpResponseMessage.
    HttpResponseMessage response = await client.GetAsync(url);

    // Get the content, await on the string content.
    string content = await response.Content.ReadAsStringAsync();

    // Process content variable here into a data set and return.
    DataSet ds = ...;

    // Return the DataSet, it will return Task<DataSet>.
    return ds;
}

Notez que vous voudrez probablement vous éloigner de la classe WebClient, car elle ne supporte pas Task<T> intrinsèquement dans ses opérations asynchrones. Un meilleur choix dans. Net 4.5 est le HttpClient classe. J'ai choisi pour utiliser HttpClient ci-dessus. Aussi, jetez un oeil à la HttpClientHandler de catégorie, plus précisément le CookieContainer la propriété que vous utiliserez pour envoyer des cookies à chaque requête.

Cependant, cela signifie que vous devrez plus que probablement utiliser le mot clé await pour attendre une autre opération asynchrone, qui dans ce cas, serait plus que probablement le téléchargement de la page. Vous devrez adapter vos appels qui téléchargent des données pour utiliser les versions asynchrones et await sur de ceux-ci.

Une fois cela terminé, vous appelez normalement await sur cela, mais vous ne pouvez pas le faire dans ce scénario parce que vous le feriez await sur une variable. Dans ce scénario, vous exécutez une boucle, de sorte que la variable serait réinitialisée à chaque itération. Dans ce cas, il est préférable de simplement stocker le Task<T> dans un tableau comme ceci:

DataSet alldata = ...;

var tasks = new List<Task<DataSet>>();

foreach(var url in the8000urls)
{
    // ScrapeData downloads the html from the url with 
    // WebClient.DownloadString
    // and scrapes the data into several datatables which 
    // it returns as a dataset.
    tasks.Add(ScrapeDataAsync(url));
}

Il s'agit de fusionner les données en allData. À cette fin, vous voulez appeler le ContinueWith méthode sur Task<T> instance retournée et effectuer la tâche d'ajouter les données à allData:

DataSet alldata = ...;

var tasks = new List<Task<DataSet>>();

foreach(var url in the8000urls)
{
    // ScrapeData downloads the html from the url with 
    // WebClient.DownloadString
    // and scrapes the data into several datatables which 
    // it returns as a dataset.
    tasks.Add(ScrapeDataAsync(url).ContinueWith(t => {
        // Lock access to the data set, since this is
        // async now.
        lock (allData)
        {
             // Add the data.
        }
    });
}

Ensuite, vous pouvez attendre sur toutes les tâches en utilisant le WhenAll méthode sur le Task classe et await sur cela:

// After your loop.
await Task.WhenAll(tasks);

// Process allData

Notez, Cependant, que vous avez un foreach, et WhenAll prend un IEnumerable<T> la mise en œuvre. C'est un bon indicateur que cela convient pour utiliser LINQ, ce qui est:

DataSet alldata;

var tasks = 
    from url in the8000Urls
    select ScrapeDataAsync(url).ContinueWith(t => {
        // Lock access to the data set, since this is
        // async now.
        lock (allData)
        {
             // Add the data.
        }
    });

await Task.WhenAll(tasks);

// Process allData

Vous pouvez également choisir de ne pas utiliser la syntaxe de requête si vous le souhaitez, cela n'a pas d'importance cas.

Notez que si le contenant méthode n'est pas marqué comme async (parce que vous êtes dans une application console et attendre les résultats avant que l'application se termine), alors vous pouvez simplement appeler l'Wait méthode sur Task retourné lorsque vous appelez WhenAll:

// This will block, waiting for all tasks to complete, all
// tasks will run asynchronously and when all are done, then the
// code will continue to execute.
Task.WhenAll(tasks).Wait();

// Process allData.

À savoir, le fait est que vous voulez collecter vos instances Task dans une séquence, puis attendre toute la séquence avant de traiter allData.

Cependant, je suggère d'essayer de traiter le données avant de les fusionner en allData si vous le pouvez; à moins que le traitement des données ne nécessite l'ensemble DataSet, vous obtiendrez encore plus de gains de performance en traitant la plus grande partie des données que vous récupérez lorsque vous les récupérez, plutôt que d'attendre que all revienne.