Is it possible to use async when using List<T>.ForEach? Below is the code I am trying:
using (DataContext db = new DataLayer.DataContext()) { db.Groups.ToList().ForEach(i => async { await GetAdminsFromGroup(i.Gid); }); } I am getting the error:
The name 'Async' does not exist in the current context
The method the using statement is enclosed in is set to async.
List<T>.ForEach doesn't play particularly well with async (neither does LINQ-to-objects, for the same reasons).
In this case, I recommend projecting each element into an asynchronous operation, and you can then (asynchronously) wait for them all to complete.
using (DataContext db = new DataLayer.DataContext()) { var tasks = db.Groups.ToList().Select(i => GetAdminsFromGroupAsync(i.Gid)); var results = await Task.WhenAll(tasks); } The benefits of this approach over giving an async delegate to ForEach are:
async void cannot be caught with catch; this approach will propagate exceptions at the await Task.WhenAll line, allowing natural exception handling.await Task.WhenAll. If you use async void, you cannot easily tell when the operations have completed.GetAdminsFromGroupAsync sounds like it's an operation that produces a result (the admins), and such code is more natural if such operations can return their results rather than setting a value as a side effect.
List.ForEach() is not part of LINQ.
async. They have been very helpful!
foreach with an await in your loop body.ForEach only takes a synchronous delegate type, and there's no overload taking an asynchronous delegate type. So the short answer is "no one wrote an asynchronous ForEach". The longer answer is that you'd have to assume some semantics; e.g., should the items be processed one at a time (like foreach), or simultaneously (like Select)? If one at a time, wouldn't asynchronous streams be a better solution? If simultaneously, should the results be in original item order or in order of completion? Should it fail on the first failure or wait until all have completed? Etc.SemaphoreSlim to throttle asynchronous tasks.This little extension method should give you exception-safe async iteration:
public static async Task ForEachAsync<T>(this List<T> list, Func<T, Task> func) { foreach (var value in list) { await func(value); } } Since we're changing the return type of the lambda from void to Task, exceptions will propagate up correctly. This will allow you to write something like this in practice:
await db.Groups.ToList().ForEachAsync(async i => { await GetAdminsFromGroup(i.Gid); }); 
someList.ForeEach(async item => { await SomeFunctionAsync(); }) When changing my code to your approach my data gets loaded correctly from the database. When using my approach here the data that is in the list is not shwon in my result. Do you know why?
Starting with C# 8.0, you can create and consume streams asynchronously.
private async void button1_Click(object sender, EventArgs e) { IAsyncEnumerable<int> enumerable = GenerateSequence(); await foreach (var i in enumerable) { Debug.WriteLine(i); } } public static async IAsyncEnumerable<int> GenerateSequence() { for (int i = 0; i < 20; i++) { await Task.Delay(100); yield return i; } } 
MoveNext of the enumerator. This is important in cases where the enumerator cannot fetch the next element instantly, and must wait for one to become available.
The simple answer is to use the foreach keyword instead of the ForEach() method of List().
using (DataContext db = new DataLayer.DataContext()) { foreach(var i in db.Groups) { await GetAdminsFromGroup(i.Gid); } } 
ForEach() method of List()?
public void ForEach (Action<T> action) @taylorswiftfan. In order for it to work, it would need to be ForEach(Task<T> action). Since we're not passing a delegate with the plain ol' for loop, we can await each call inside the loop. There are better ways these days though. stackoverflow.com/a/58112039/3198973
This is not an old question, but .Net 6 introduced Parallel.ForeachAsync:
var collectionToIterate = db.Groups.ToList(); await Parallel.ForEachAsync(collectionToIterate, async (i, token) => { await GetAdminsFromGroup(i); }); ForeachAsync also accepts a ParallelOptions object, but usually you don't want to mess with the MaxDegreeOfParallelism property:
ParallelOptions parallelOptions = new ParallelOptions { MaxDegreeOfParallelism = 4 }; var collectionToIterate = db.Groups.ToList(); await Parallel.ForEachAsync(collectionToIterate, parallelOptions , async (i, token) => { await GetAdminsFromGroup(i); }); From Microsoft Docs: https://learn.microsoft.com/en-us/dotnet/api/system.threading.tasks.paralleloptions.maxdegreeofparallelism?view=net-6.0
By default, For and ForEach will utilize however many threads the underlying scheduler provides, so changing MaxDegreeOfParallelism from the default only limits how many concurrent tasks will be used.
Generally, you do not need to modify this setting....
Here is an actual working version of the above async foreach variants with sequential processing:
public static async Task ForEachAsync<T>(this List<T> enumerable, Action<T> action) { foreach (var item in enumerable) await Task.Run(() => { action(item); }).ConfigureAwait(false); } Here is the implementation:
public async void SequentialAsync() { var list = new List<Action>(); Action action1 = () => { //do stuff 1 }; Action action2 = () => { //do stuff 2 }; list.Add(action1); list.Add(action2); await list.ForEachAsync(); } What's the key difference? .ConfigureAwait(false); which keeps the context of main thread while async sequential processing of each task.
Add this extension method
public static class ForEachAsyncExtension { public static Task ForEachAsync<T>(this IEnumerable<T> source, int dop, Func<T, Task> body) { return Task.WhenAll(from partition in Partitioner.Create(source).GetPartitions(dop) select Task.Run(async delegate { using (partition) while (partition.MoveNext()) await body(partition.Current).ConfigureAwait(false); })); } } And then use like so:
Task.Run(async () => { var s3 = new AmazonS3Client(Config.Instance.Aws.Credentials, Config.Instance.Aws.RegionEndpoint); var buckets = await s3.ListBucketsAsync(); foreach (var s3Bucket in buckets.Buckets) { if (s3Bucket.BucketName.StartsWith("mybucket-")) { log.Information("Bucket => {BucketName}", s3Bucket.BucketName); ListObjectsResponse objects; try { objects = await s3.ListObjectsAsync(s3Bucket.BucketName); } catch { log.Error("Error getting objects. Bucket => {BucketName}", s3Bucket.BucketName); continue; } // ForEachAsync (4 is how many tasks you want to run in parallel) await objects.S3Objects.ForEachAsync(4, async s3Object => { try { log.Information("Bucket => {BucketName} => {Key}", s3Bucket.BucketName, s3Object.Key); await s3.DeleteObjectAsync(s3Bucket.BucketName, s3Object.Key); } catch { log.Error("Error deleting bucket {BucketName} object {Key}", s3Bucket.BucketName, s3Object.Key); } }); try { await s3.DeleteBucketAsync(s3Bucket.BucketName); } catch { log.Error("Error deleting bucket {BucketName}", s3Bucket.BucketName); } } } }).Wait(); If you are using EntityFramework.Core there is an extension method ForEachAsync.
The example usage looks like this:
using Microsoft.EntityFrameworkCore; using System.Threading.Tasks; public class Example { private readonly DbContext _dbContext; public Example(DbContext dbContext) { _dbContext = dbContext; } public async void LogicMethod() { await _dbContext.Set<dbTable>().ForEachAsync(async x => { //logic await AsyncTask(x); }); } public async Task<bool> AsyncTask(object x) { //other logic return await Task.FromResult<bool>(true); } } The problem was that the async keyword needs to appear before the lambda, not before the body:
db.Groups.ToList().ForEach(async (i) => { await GetAdminsFromGroup(i.Gid); }); 
async void. This approach has problems around exception handling and knowing when the asynchronous operations complete.
I would like to add that there is a Parallel class with ForEach function built in that can be used for this purpose.
Parallel class is not async-friendly.
Parallel class is great for CPU-bound work, but not for I/O-bound work. For example you don't really need threads when you are doing web requests.you can use this to have cleaner code :
private async void Action(typeOfTheI i) { await GetAdminsFromGroup(i.Gid); } db.Groups.ToList().ForEach(Action); 
Action in your example doesn't look like an event handler.The simple way is:
MyList.ForEach(async a => await UploadAsync(a.Data)); or
foreach (var a in MyList) { await UploadAsync(a.Data); } This is method I created to handle async scenarios with ForEach.
public static class ParallelExecutor { /// <summary> /// Executes asynchronously given function on all elements of given enumerable with task count restriction. /// Executor will continue starting new tasks even if one of the tasks throws. If at least one of the tasks throwed exception then <see cref="AggregateException"/> is throwed at the end of the method run. /// </summary> /// <typeparam name="T">Type of elements in enumerable</typeparam> /// <param name="maxTaskCount">The maximum task count.</param> /// <param name="enumerable">The enumerable.</param> /// <param name="asyncFunc">asynchronous function that will be executed on every element of the enumerable. MUST be thread safe.</param> /// <param name="onException">Acton that will be executed on every exception that would be thrown by asyncFunc. CAN be thread unsafe.</param> /// <param name="cancellationToken">The cancellation token.</param> public static async Task ForEachAsync<T>(int maxTaskCount, IEnumerable<T> enumerable, Func<T, Task> asyncFunc, Action<Exception> onException = null, CancellationToken cancellationToken = default) { using var semaphore = new SemaphoreSlim(initialCount: maxTaskCount, maxCount: maxTaskCount); // This `lockObject` is used only in `catch { }` block. object lockObject = new object(); var exceptions = new List<Exception>(); var tasks = new Task[enumerable.Count()]; int i = 0; try { foreach (var t in enumerable) { await semaphore.WaitAsync(cancellationToken); tasks[i++] = Task.Run( async () => { try { await asyncFunc(t); } catch (Exception e) { if (onException != null) { lock (lockObject) { onException.Invoke(e); } } // This exception will be swallowed here but it will be collected at the end of ForEachAsync method in order to generate AggregateException. throw; } finally { semaphore.Release(); } }, cancellationToken); if (cancellationToken.IsCancellationRequested) { break; } } } catch (OperationCanceledException e) { exceptions.Add(e); } foreach (var t in tasks) { if (cancellationToken.IsCancellationRequested) { break; } // Exception handling in this case is actually pretty fast. // https://gist.github.com/shoter/d943500eda37c7d99461ce3dace42141 try { await t; } #pragma warning disable CA1031 // Do not catch general exception types - we want to throw that exception later as aggregate exception. Nothing wrong here. catch (Exception e) #pragma warning restore CA1031 // Do not catch general exception types { exceptions.Add(e); } } if (exceptions.Any()) { throw new AggregateException(exceptions); } } } 
IEnumerable<T> is enumerated twice because of the Count(), which is a no-no. The enumerable may be hitting the database/filesystem/web on each enumeration. 2. The Task.Factory.StartNew(async produces a Task<Task>, and you are awaiting only the outer Task. The method may not propagate all exceptions, and may return before all tasks have been completed. And 3. using the cancellationToken.IsCancellationRequested may result to inconsistent cancellation behavior. Use the ThrowIfCancellationRequested instead.Action<Exception> onException = null parameter, what is its use case? Is it for logging the errors as soon as they happen, as opposed to logging them in batch after the completion of the ForEachAsync method?
Task.Run and it does not swallow them.