How to iterate dictionary in "await foreach"

Question

Help with a small problem...

I have a method that returns a dictionary. I need to rewrite it in such a way that I can enumerate the result of this method using await foreach. Please help me, something is not working for me at all.

It's my method:

public IDictionary<long, long> TransformListInDictionary(IList<string> list)
{
    var result = new Dictionary<long, long>();
    foreach (var member in list)
    {
        var idx = member.IndexOf(':');

        var key = member.Substring(0, idx);
        var value = member.Substring(idx + 1);

        result.Add(Convert.ToInt64(key), Convert.ToInt64(value));
    }
    return result;
}

To use a dictionary in an await foreach loop, this method requires a return value of IAsyncEnumerable<KeyValuePair<long,long>>.

Therefore, I have a question, how to rewrite the method published above is the return value.

Why do I need it.

I have some code which I am posting below. I'll try to describe my idea.

When the code enters the for loop, it does some work and instantiates the dictionary. Which is further processed in the foreach loop.

var logic = new AllLogic();

var variable = Convert.ToInt32(Console.ReadLine());
var randomSecundForPause = new Random();

for (int i = 0; i < variable; i++)
{
    var list = new List<string>();

    var dict = logic.TransformListInDictionary(list);

    //some code

    foreach (var item in dict)
    {
        try
        {
            //some code

            Thread.Sleep(randomSecundForPause.Next(100000, 150000));
        }
        catch (Exception e)
        {
            //some code

            Thread.Sleep(randomSecundForPause.Next(100000, 150000));
        }
    }

}

I would like this foreach loop to run in the background and the main code flow to go to a new iteration of the for loop.

As I understand it, I need to replace foreach with await foreach.

`Dictionary<,>` doesn't implement `IAsyncEnumerable`. Why do you you think you need `await foreach`? Await the result, *then* iterate over that. — madreflection, Aug 19 '22 at 18:26
In fact, there's no reason this method needs to be async (or awaitable at all). You're not using `await` anywhere, and you're not overriding something that already defines the `Task<...>` return type. — madreflection, Aug 19 '22 at 18:29
@madreflection I need to perform some actions asynchronously with the result of this method... So far, the only thing that fits is await foreach — itehnoviking, Aug 19 '22 at 18:31
That has nothing to do with how you produce the result within this method. — madreflection, Aug 19 '22 at 18:32
@madreflection Yes, that's why I want to rewrite this method. — itehnoviking, Aug 19 '22 at 18:32
Right. Change the method to return `IDictionary` (no Task), then iterate over that.. Do async work in the `foreach` loop. — madreflection, Aug 19 '22 at 18:35
@madreflection the problem is that I want to rewrite this method in such a way that the result of the method can be used in the "await foreach" loop. I can't use a dictionary — itehnoviking, Aug 19 '22 at 18:43
Please provide a [mre]. What you've posted is focused on the wrong aspect of the problem. — madreflection, Aug 19 '22 at 18:44
You're still not `await`ing anything. This code doesn't need to be async. You could use Theodor Zoulias's answer, sure, but there's no indication that you need to. — madreflection, Aug 19 '22 at 19:22
@madreflection But how then can I rewrite the code for my task? — itehnoviking, Aug 19 '22 at 19:29
@madreflection "I would like this foreach loop to run in the background and the main code flow to go to a new iteration of the for loop." — itehnoviking, Aug 19 '22 at 19:29
Running in the background and being async are entirely separate things. Your question is about async. Your code doesn't do any I/O and would not benefit from being async. — madreflection, Aug 19 '22 at 19:31
@madreflection Then in what direction should I look for the answer to my question? — itehnoviking, Aug 19 '22 at 19:33
Threading. You need a background thread. If you need need to know when it's done, you can use `Task.Run`, give it a *synchronous* method/lambda, and await that task. There are other ways, too. — madreflection, Aug 19 '22 at 19:37

score 0 · Answer 1 · answered Aug 19 '22 at 19:13

0

What you want is probably an asynchronous iterator:

#pragma warning disable CS1998
public async IAsyncEnumerable<KeyValuePair<long, long>> ToAsyncEnumerable(
#pragma warning restore CS1998
    IList<string> list)
{
    foreach (var member in list)
    {
        var idx = member.IndexOf(':');

        var key = member.Substring(0, idx);
        var value = member.Substring(idx + 1);

        yield return KeyValuePair.Create(Convert.ToInt64(key), Convert.ToInt64(value));
    }
}

The method must be async, it must have IAsyncEnumerable<X> as return type, and it must contain the yield contextual keyword.

The #pragma warning disable CS1998 is needed in order to suppress a warning about an async method that lacks the await keyword. Without it the program will still compile, but the C# compiler will emit a warning.

answered Aug 19 '22 at 19:13

Theodor Zoulias

34,835
7
69
104

The point I was making above is that this is entirely unnecessary *because* it doesn't use `await`. – madreflection Aug 19 '22 at 19:16
@madreflection you might be right, but we don't know how the OP intends to use this method. Generic extension methods that convert `IEnumerable`s to `IAsyncEnumerable`s do exist in third-party libraries, like the respectable [System.Linq.Async](https://github.com/dotnet/reactive/blob/85f1eb7c53e27cccdbeee3e0b044916168843fcc/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/ToAsyncEnumerable.cs#L21-L32), so it's not something completely unheard of. – Theodor Zoulias Aug 19 '22 at 19:22
We kind of do now that it's been edited, and it's still not `await`ing anything. It's all synchronous code at this point. – madreflection Aug 19 '22 at 19:23

score 0 · Answer 2 · answered Aug 21 '22 at 08:55

I would like this foreach loop to run in the background and the main code flow to go to a new iteration of the for loop.

You don't need an await foreach. The for loop body would not continue to the next iteration once it hits an await of any kind. Instead, it would asynchronously wait for whatever it is to finish, and only when it does will the next iteration of the for loop start.

If you want to understand it better, try running this code:

for(int i = 0; i < 10; i++)
{
    Console.WriteLine($"{i} Started");
    await Task.Delay(2000);
    Console.WriteLine($"{i} Finished");
}

If you want the foreach body to run in the background, you need to wrap the body inside a Task.Run(...) call. This call would return a Task, so store the Task in a collection and await Task.WhenAll(...) afterwards.

Would something like this:

var tasks = new List<Task>(variable);
for (int i = 0; i < variable; i++)
{
    var list = new List<string>();

    var dict = logic.TransformListInDictionary(list);

    //some code
    var task = Task.Run(async () => 
    {
        foreach (var item in dict)
        {
            try
            {
                //some code

                await Task.Delay(randomSecundForPause.Next(100000, 150000)); // This is better because the thread is not blocked
            }
            catch (Exception e)
            {
                //some code

                await Task.Delay(randomSecundForPause.Next(100000, 150000));
            }
        }
    });
    tasks.Add(task);
}

await Task.WhenAll(tasks);

Notice that the Dictionary class is thread-safe for multiple readers, but not for multiple writers, so depending on what //some code does you might want to consider a ConcurrentDictionary.

How to iterate dictionary in "await foreach"

2 Answers2