// let's say there is a list of 1000+ URLs
string[] urls = { "http://google.com", "http://yahoo.com", ... };

// now let's send HTTP requests to each of these URLs in parallel
urls.AsParallel().ForAll(async (url) => {
    var client = new HttpClient();
    var html = await client.GetStringAsync(url);
});

Hier ist das Problem, es startet 1000+ gleichzeitige Webanfragen. Gibt es eine einfache Möglichkeit, die gleichzeitige Anzahl dieser asynchronen http-Anforderungen zu begrenzen? Damit werden nicht mehr als 20 Webseiten gleichzeitig heruntergeladen. Wie geht das am effizientesten?

Sie können dies definitiv in den neuesten Versionen von Async für .NET mit .NET 4.5 Beta tun. Der vorherige Beitrag von 'usr' verweist auf einen guten Artikel von Stephen Toub, aber die weniger angekündigten Neuigkeiten sind, dass das asynchrone Semaphor es tatsächlich in die Beta-Version von .NET 4.5 geschafft hat

Wenn Sie sich unsere geliebte SemaphoreSlimKlasse ansehen (die Sie verwenden sollten, da sie leistungsfähiger als das Original ist Semaphore), bietet sie jetzt eine WaitAsync(...)Reihe von Überladungen mit allen erwarteten Argumenten - Zeitüberschreitungsintervalle, Stornierungs-Token, all Ihre üblichen Planungsfreunde: )

Stephen ist auch eine neuere Blog - Post über die neuen .NET 4.5 Goodies geschrieben , die mit Beta herauskam siehe Was ist neu für Parallelismus in .NET 4.5 Beta .

Zuletzt finden Sie hier einen Beispielcode zur Verwendung von SemaphoreSlim für die Drosselung asynchroner Methoden:

public async Task MyOuterMethod()
{
    // let's say there is a list of 1000+ URLs
    var urls = { "http://google.com", "http://yahoo.com", ... };

    // now let's send HTTP requests to each of these URLs in parallel
    var allTasks = new List<Task>();
    var throttler = new SemaphoreSlim(initialCount: 20);
    foreach (var url in urls)
    {
        // do an async wait until we can schedule again
        await throttler.WaitAsync();

        // using Task.Run(...) to run the lambda in its own parallel
        // flow on the threadpool
        allTasks.Add(
            Task.Run(async () =>
            {
                try
                {
                    var client = new HttpClient();
                    var html = await client.GetStringAsync(url);
                }
                finally
                {
                    throttler.Release();
                }
            }));
    }

    // won't get here until all urls have been put into tasks
    await Task.WhenAll(allTasks);

    // won't get here until all tasks have completed in some way
    // (either success or exception)
}

Zuletzt, aber wahrscheinlich eine Erwähnung wert, ist eine Lösung, die TPL-basierte Planung verwendet. Sie können delegatengebundene Aufgaben in der TPL erstellen, die noch nicht gestartet wurden, und einen benutzerdefinierten Aufgabenplaner zulassen, um die Parallelität zu begrenzen. Tatsächlich gibt es hier ein MSDN-Beispiel dafür:

Siehe auch TaskScheduler .

Wenn Sie über eine IEnumerable (dh URL-Zeichenfolgen) verfügen und mit jeder dieser Operationen gleichzeitig eine E / A-gebundene Operation ausführen möchten (dh eine asynchrone http-Anforderung erstellen) UND optional möchten Sie auch die maximale Anzahl gleichzeitiger Operationen festlegen E / A-Anforderungen in Echtzeit. So können Sie das tun. Auf diese Weise verwenden Sie Thread Thread et al. Nicht. Die Methode verwendet Semaphoreslim, um die maximale Anzahl gleichzeitiger E / A-Anforderungen zu steuern, ähnlich einem Schiebefenstermuster, das eine Anforderung abschließt, das Semaphor verlässt und die nächste eingeht.

Verwendung: Warten auf ForEachAsync (urlStrings, YourAsyncFunc, optionalMaxDegreeOfConcurrency);

public static Task ForEachAsync<TIn>(
        IEnumerable<TIn> inputEnumerable,
        Func<TIn, Task> asyncProcessor,
        int? maxDegreeOfParallelism = null)
    {
        int maxAsyncThreadCount = maxDegreeOfParallelism ?? DefaultMaxDegreeOfParallelism;
        SemaphoreSlim throttler = new SemaphoreSlim(maxAsyncThreadCount, maxAsyncThreadCount);

        IEnumerable<Task> tasks = inputEnumerable.Select(async input =>
        {
            await throttler.WaitAsync().ConfigureAwait(false);
            try
            {
                await asyncProcessor(input).ConfigureAwait(false);
            }
            finally
            {
                throttler.Release();
            }
        });

        return Task.WhenAll(tasks);
    }

Leider fehlen in .NET Framework die wichtigsten Kombinatoren für die Orchestrierung paralleler asynchroner Aufgaben. Es ist so etwas nicht eingebaut.

Schauen Sie sich die AsyncSemaphore- Klasse an, die von Stephen Toub erstellt wurde. Was Sie wollen, heißt Semaphor, und Sie benötigen eine asynchrone Version davon.

Es gibt viele Fallstricke und die direkte Verwendung eines Semaphors kann in Fehlerfällen schwierig sein. Daher würde ich empfehlen, das AsyncEnumerator NuGet-Paket zu verwenden, anstatt das Rad neu zu erfinden:

// let's say there is a list of 1000+ URLs
string[] urls = { "http://google.com", "http://yahoo.com", ... };

// now let's send HTTP requests to each of these URLs in parallel
await urls.ParallelForEachAsync(async (url) => {
    var client = new HttpClient();
    var html = await client.GetStringAsync(url);
}, maxDegreeOfParalellism: 20);

Das Beispiel von Theo Yaung ist nett, aber es gibt eine Variante ohne Liste wartender Aufgaben.

 class SomeChecker
 {
    private const int ThreadCount=20;
    private CountdownEvent _countdownEvent;
    private SemaphoreSlim _throttler;

    public Task Check(IList<string> urls)
    {
        _countdownEvent = new CountdownEvent(urls.Count);
        _throttler = new SemaphoreSlim(ThreadCount); 

        return Task.Run( // prevent UI thread lock
            async  () =>{
                foreach (var url in urls)
                {
                    // do an async wait until we can schedule again
                    await _throttler.WaitAsync();
                    ProccessUrl(url); // NOT await
                }
                //instead of await Task.WhenAll(allTasks);
                _countdownEvent.Wait();
            });
    }

    private async Task ProccessUrl(string url)
    {
        try
        {
            var page = await new WebClient()
                       .DownloadStringTaskAsync(new Uri(url)); 
            ProccessResult(page);
        }
        finally
        {
            _throttler.Release();
            _countdownEvent.Signal();
        }
    }

    private void ProccessResult(string page){/*....*/}
}

SemaphoreSlim kann hier sehr hilfreich sein. Hier ist die Erweiterungsmethode, die ich erstellt habe.

    /// <summary>
    /// Concurrently Executes async actions for each item of <see cref="IEnumerable<typeparamref name="T"/>
    /// </summary>
    /// <typeparam name="T">Type of IEnumerable</typeparam>
    /// <param name="enumerable">instance of <see cref="IEnumerable<typeparamref name="T"/>"/></param>
    /// <param name="action">an async <see cref="Action" /> to execute</param>
    /// <param name="maxActionsToRunInParallel">Optional, max numbers of the actions to run in parallel,
    /// Must be grater than 0</param>
    /// <returns>A Task representing an async operation</returns>
    /// <exception cref="ArgumentOutOfRangeException">If the maxActionsToRunInParallel is less than 1</exception>
    public static async Task ForEachAsyncConcurrent<T>(
        this IEnumerable<T> enumerable,
        Func<T, Task> action,
        int? maxActionsToRunInParallel = null)
    {
        if (maxActionsToRunInParallel.HasValue)
        {
            using (var semaphoreSlim = new SemaphoreSlim(
                maxActionsToRunInParallel.Value, maxActionsToRunInParallel.Value))
            {
                var tasksWithThrottler = new List<Task>();

                foreach (var item in enumerable)
                {
                    // Increment the number of currently running tasks and wait if they are more than limit.
                    await semaphoreSlim.WaitAsync();

                    tasksWithThrottler.Add(Task.Run(async () =>
                    {
                        await action(item).ContinueWith(res =>
                        {
                            // action is completed, so decrement the number of currently running tasks
                            semaphoreSlim.Release();
                        });
                    }));
                }

                // Wait for all of the provided tasks to complete.
                await Task.WhenAll(tasksWithThrottler.ToArray());
            }
        }
        else
        {
            await Task.WhenAll(enumerable.Select(item => action(item)));
        }
    }

Beispielnutzung:

await enumerable.ForEachAsyncConcurrent(
    async item =>
    {
        await SomeAsyncMethod(item);
    },
    5);

Alte Frage, neue Antwort. @vitidev hatte einen Codeblock, der in einem von mir überprüften Projekt fast intakt wiederverwendet wurde. Nach einer Diskussion mit einigen Kollegen fragte man: "Warum verwenden Sie nicht einfach die integrierten TPL-Methoden?" ActionBlock sieht dort wie der Gewinner aus. https://msdn.microsoft.com/en-us/library/hh194773(v=vs.110).aspx . Wahrscheinlich wird sich kein vorhandener Code ändern, aber auf jeden Fall wird versucht, dieses Nuget zu übernehmen und Mr. Softys Best Practice für gedrosselte Parallelität wiederzuverwenden.

Hier ist eine Lösung, die die Faulheit von LINQ ausnutzt. Es entspricht funktional der akzeptierten Antwort , verwendet jedoch Worker-Tasks anstelle von a SemaphoreSlim, wodurch der Speicherbedarf des gesamten Vorgangs verringert wird. Lassen Sie es zunächst ohne Drosselung funktionieren. Der erste Schritt besteht darin, unsere URLs in eine Vielzahl von Aufgaben umzuwandeln.

string[] urls =
{
    "https://stackoverflow.com",
    "https://superuser.com",
    "https://serverfault.com",
    "https://meta.stackexchange.com",
    // ...
};
var httpClient = new HttpClient();
var tasks = urls.Select(async (url) =>
{
    return (Url: url, Html: await httpClient.GetStringAsync(url));
});

Der zweite Schritt besteht darin, awaitalle Aufgaben gleichzeitig mit der folgenden Task.WhenAllMethode auszuführen :

var results = await Task.WhenAll(tasks);
foreach (var result in results)
{
    Console.WriteLine($"Url: {result.Url}, {result.Html.Length:#,0} chars");
}

Ausgabe:

URL: https://stackoverflow.com , 105,574 Zeichen
Url: https://superuser.com , 126,953 Zeichen
Url: https://serverfault.com , 125,963 Zeichen
Url: https://meta.stackexchange.com , 185,276 Zeichen
...

Durch die Implementierung von Microsoft wirdTask.WhenAll die bereitgestellte Aufzählung für ein Array sofort materialisiert, sodass alle Aufgaben gleichzeitig gestartet werden. Das wollen wir nicht, weil wir die Anzahl der gleichzeitigen asynchronen Operationen begrenzen wollen. Wir müssen also eine Alternative implementieren WhenAll, die unsere Aufzählung sanft und langsam auflistet. Wir werden dies tun, indem wir eine Anzahl von Worker-Tasks erstellen (die dem gewünschten Grad an Parallelität entsprechen), und jede Worker-Task zählt unsere aufzählbaren Aufgaben einzeln auf, wobei eine Sperre verwendet wird, um sicherzustellen, dass jede URL-Task verarbeitet wird von nur einer Arbeiteraufgabe. Dann müssen wir awaitalle Arbeiteraufgaben erledigen und schließlich die Ergebnisse zurückgeben. Hier ist die Implementierung:

public static async Task<T[]> WhenAll<T>(IEnumerable<Task<T>> tasks,
    int concurrencyLevel)
{
    if (tasks is ICollection<Task<T>>) throw new ArgumentException(
        "The enumerable should not be materialized.", nameof(tasks));
    var locker = new object();
    var results = new List<T>();
    var failed = false;
    using (var enumerator = tasks.GetEnumerator())
    {
        var workerTasks = Enumerable.Range(0, concurrencyLevel)
        .Select(async _ =>
        {
            try
            {
                while (true)
                {
                    Task<T> task;
                    int index;
                    lock (locker)
                    {
                        if (failed) break;
                        if (!enumerator.MoveNext()) break;
                        task = enumerator.Current;
                        index = results.Count;
                        results.Add(default); // Reserve space in the list
                    }
                    var result = await task.ConfigureAwait(false);
                    lock (locker) results[index] = result;
                }
            }
            catch (Exception)
            {
                lock (locker) failed = true;
                throw;
            }
        }).ToArray();
        await Task.WhenAll(workerTasks).ConfigureAwait(false);
    }
    lock (locker) return results.ToArray();
}

... und hier ist, was wir in unserem ursprünglichen Code ändern müssen, um die gewünschte Drosselung zu erreichen:

var results = await WhenAll(tasks, concurrencyLevel: 2);

Es gibt einen Unterschied in der Behandlung der Ausnahmen. Der native Task.WhenAllwartet darauf, dass alle Aufgaben abgeschlossen sind, und aggregiert alle Ausnahmen. Die obige Implementierung wird sofort nach Abschluss der ersten fehlerhaften Aufgabe beendet.

Obwohl 1000 Aufgaben möglicherweise sehr schnell in die Warteschlange gestellt werden, kann die Bibliothek für parallele Aufgaben nur gleichzeitige Aufgaben verarbeiten, die der Anzahl der CPU-Kerne auf dem Computer entsprechen. Das bedeutet, dass bei einem Vier-Kern-Computer zu einem bestimmten Zeitpunkt nur vier Aufgaben ausgeführt werden (es sei denn, Sie verringern den MaxDegreeOfParallelism).

Parallele Berechnungen sollten verwendet werden, um CPU-gebundene Operationen zu beschleunigen. Hier geht es um E / A-gebundene Operationen. Ihre Implementierung sollte rein asynchron sein , es sei denn, Sie überwältigen den ausgelasteten Single Core auf Ihrer Multi-Core-CPU.

BEARBEITEN Ich mag den Vorschlag von usr, hier ein "asynchrones Semaphor" zu verwenden.

Verwenden MaxDegreeOfParallelismSie diese Option, die Sie angeben können in Parallel.ForEach():

var options = new ParallelOptions { MaxDegreeOfParallelism = 20 };

Parallel.ForEach(urls, options,
    url =>
        {
            var client = new HttpClient();
            var html = client.GetStringAsync(url);
            // do stuff with html
        });

Im Wesentlichen möchten Sie für jede URL, die Sie treffen möchten, eine Aktion oder Aufgabe erstellen, diese in eine Liste einfügen und diese Liste dann verarbeiten, um die Anzahl zu begrenzen, die parallel verarbeitet werden kann.

Mein Blog-Beitrag zeigt, wie dies sowohl mit Aufgaben als auch mit Aktionen gemacht wird, und enthält ein Beispielprojekt, das Sie herunterladen und ausführen können, um beide in Aktion zu sehen.

Mit Aktionen

Wenn Sie Aktionen verwenden, können Sie die integrierte .Net Parallel.Invoke-Funktion verwenden. Hier beschränken wir uns darauf, höchstens 20 Threads parallel auszuführen.

var listOfActions = new List<Action>();
foreach (var url in urls)
{
    var localUrl = url;
    // Note that we create the Task here, but do not start it.
    listOfTasks.Add(new Task(() => CallUrl(localUrl)));
}

var options = new ParallelOptions {MaxDegreeOfParallelism = 20};
Parallel.Invoke(options, listOfActions.ToArray());

Mit Aufgaben

Bei Aufgaben ist keine Funktion integriert. Sie können jedoch die verwenden, die ich in meinem Blog zur Verfügung stelle.

    /// <summary>
    /// Starts the given tasks and waits for them to complete. This will run, at most, the specified number of tasks in parallel.
    /// <para>NOTE: If one of the given tasks has already been started, an exception will be thrown.</para>
    /// </summary>
    /// <param name="tasksToRun">The tasks to run.</param>
    /// <param name="maxTasksToRunInParallel">The maximum number of tasks to run in parallel.</param>
    /// <param name="cancellationToken">The cancellation token.</param>
    public static async Task StartAndWaitAllThrottledAsync(IEnumerable<Task> tasksToRun, int maxTasksToRunInParallel, CancellationToken cancellationToken = new CancellationToken())
    {
        await StartAndWaitAllThrottledAsync(tasksToRun, maxTasksToRunInParallel, -1, cancellationToken);
    }

    /// <summary>
    /// Starts the given tasks and waits for them to complete. This will run the specified number of tasks in parallel.
    /// <para>NOTE: If a timeout is reached before the Task completes, another Task may be started, potentially running more than the specified maximum allowed.</para>
    /// <para>NOTE: If one of the given tasks has already been started, an exception will be thrown.</para>
    /// </summary>
    /// <param name="tasksToRun">The tasks to run.</param>
    /// <param name="maxTasksToRunInParallel">The maximum number of tasks to run in parallel.</param>
    /// <param name="timeoutInMilliseconds">The maximum milliseconds we should allow the max tasks to run in parallel before allowing another task to start. Specify -1 to wait indefinitely.</param>
    /// <param name="cancellationToken">The cancellation token.</param>
    public static async Task StartAndWaitAllThrottledAsync(IEnumerable<Task> tasksToRun, int maxTasksToRunInParallel, int timeoutInMilliseconds, CancellationToken cancellationToken = new CancellationToken())
    {
        // Convert to a list of tasks so that we don't enumerate over it multiple times needlessly.
        var tasks = tasksToRun.ToList();

        using (var throttler = new SemaphoreSlim(maxTasksToRunInParallel))
        {
            var postTaskTasks = new List<Task>();

            // Have each task notify the throttler when it completes so that it decrements the number of tasks currently running.
            tasks.ForEach(t => postTaskTasks.Add(t.ContinueWith(tsk => throttler.Release())));

            // Start running each task.
            foreach (var task in tasks)
            {
                // Increment the number of tasks currently running and wait if too many are running.
                await throttler.WaitAsync(timeoutInMilliseconds, cancellationToken);

                cancellationToken.ThrowIfCancellationRequested();
                task.Start();
            }

            // Wait for all of the provided tasks to complete.
            // We wait on the list of "post" tasks instead of the original tasks, otherwise there is a potential race condition where the throttler's using block is exited before some Tasks have had their "post" action completed, which references the throttler, resulting in an exception due to accessing a disposed object.
            await Task.WhenAll(postTaskTasks.ToArray());
        }
    }

Wenn Sie dann Ihre Aufgabenliste erstellen und die Funktion aufrufen, um sie ausführen zu lassen, beispielsweise maximal 20 gleichzeitig, können Sie Folgendes tun:

var listOfTasks = new List<Task>();
foreach (var url in urls)
{
    var localUrl = url;
    // Note that we create the Task here, but do not start it.
    listOfTasks.Add(new Task(async () => await CallUrl(localUrl)));
}
await Tasks.StartAndWaitAllThrottledAsync(listOfTasks, 20);

Dies ist keine gute Vorgehensweise, da eine globale Variable geändert wird. Es ist auch keine allgemeine Lösung für Async. Aber es ist einfach für alle Instanzen von HttpClient, wenn das alles ist, wonach Sie suchen. Sie können einfach versuchen:

System.Net.ServicePointManager.DefaultConnectionLimit = 20;