Async operation, i'm doing it wrong... why?

Question

Sync Code:

public static void ImportData()
{

    for (var i = 0; i < 40000; i++)
    {
        DoSomething(i)
    }
}

Async Code:

public static void ImportDataAsync()
{
    for (int i = 0; i < 40000; i++)
    {
        await DoSomething(i)
    }
}

Just to be clear, that's one of my first attempt in async operation.

With the async code, my software it's really slow, when if i run synchronously multiple instance of the command line application it's 10x time faster.

I mean, i don't think that the DB access and the try/catch block of the GetAsync function will do this abissal difference between the two method, what do you think?

Edit: I don't know how to improve this question, but i will try to give an answer instead.

What i was asking is for the "Parallel.Foreach" method, what i was doing is thinking that the "await" prefix would set the current thread in standby creating another thread and continuing the for cycle, instead, what the await did is to simply leave that method until the awaited result, then he came back at the same point in the for cycle and resume it where he was awaiting.

I was just confusing things, specially in a Console Application actually i do not see any good reason to use await/async.

Answer 1

At a first read, maybe could be this? 20 000 vs 100 000 iterations?

// Sync version
var start = 4000000;
var end = start + 20000;

// Async version
var start = 4000000;
var end = start + 100000

Also in your async method I see some things:

1. public static void ImportAsyncData() should be public static async Task ImportAsyncData() to let the caller await your operation

2. var slot = gs.GetAsync(c); I think here you want to await for that call: var slot = await gs.GetAsync(c); In this way you don't have to use ContinueWith, because your GetAsync call is awaited, so the next lines of code are executed only when or GetAsync task completes.

3. You shouldn't wait with a "busy waiting" like this: while (requestDid - requestDone > 100);, you are using your CPU to just wait. In this case you could use a shared variable between your tasks with respect for the concurrence, maybe using some simple lock logic.

You can refactor it to something like this, but I didn't understand so much what you want to achieve and what is your problem :-)

public async Task ImportAsyncData()
{
    var gs = new Site();

    int requestDid = 0;
    int requestDone = 0;
    var found = 0;

    var watch = System.Diagnostics.Stopwatch.StartNew();
    var start = 4000000;
    var end = start + 100000

    var cod = "user"

    for (int i = start; i < end; i++)
    {
        var ts = watch.Elapsed;
        string elapsedTime = String.Format("{0:00}:{1:00}:{2:00}.{3:00}",
            ts.Hours, ts.Minutes, ts.Seconds, ts.Milliseconds / 10);

        Console.Title = "R: " + (i - start) + " F: " + found + " EL: " + ts;

        var c = cod + i;

        var user = await gs.GetAsync(c);
        if (user == null)
        {
            requestDone++;
            return;
        }

        using (var db = new Database())
        {
            found++;
            db.InsertUser(user);
        }

        requestDid++;
    }
}