Call async method after another async method is finished in C#

Question

I want to call step2 method after step 1 is finished. With this code below the methods step 1 and step 2 are executing in parallel. And of course I they need to be asynchronous so they won't block step 3 from executing.

using System;
using System.Threading;
using System.Threading.Tasks;

namespace test
{
    internal class Program
    {
        static void Main(string[] args)
        {

            async void step1()
            {
                await Task.Run(() =>
                {
                    Thread.Sleep(2000);
                    Console.WriteLine("step 1");
                });

            }

            async void step2()
            {
                await Task.Run(() =>
                {
                    Thread.Sleep(5000);
                    Console.WriteLine("step 2");
                });

            }

            void step3()
            {
                Console.WriteLine("step 3");
            }

            step1();
            step2();
            step3();
            
            // the code below is not working but just and idea 
            // what I want to make. If it at all posible
            // step1().step2()
            // step3() 

            Console.ReadLine();
        }
    }
}

Any help would be greatly appreciated. Keep in mind I am beginner in C#!

Edit:

I know that I can get the end result even with this code.

         void step1()
         {
             Thread.Sleep(2000);
             Console.WriteLine("step 1");
         }
         void step2()
         {
             Thread.Sleep(5000);
             Console.WriteLine("step 2");
         }
         void step3()
         {
             Console.WriteLine("step 3");
         }
         step3();
         step1();
         step2();

even without async/await at all.

The point of this question is to make small proof of concept application where even though the code is set up like this:
```
         step1();
         step2();
         step3();
```

where step3() is set last will execute first because has no delay and also step2() will have to wait for step1() to finish.

Is this at all possible with async/await in C#. I think this can be done with promises in javascript.

learn.microsoft.com/en-us/archive/msdn-magazine/2013/march/… — GSerg
– GSerg, Commented Dec 9, 2022 at 16:16
Its just testcode but don't use Thread.Sleep here use Task.Delay. A Task isn't a thread. — Ralf
– Ralf, Commented Dec 9, 2022 at 16:18
"where step3() is set last will execute first because has no delay" - From what I understand, you're saying, "I want to call it last but run it first." I don't understand why you would want this. If you want to run it first, what is the problem with calling it first? — Gabriel Luci
– Gabriel Luci, Commented Dec 9, 2022 at 17:24
Like I said this is just a proof of concept app. Sometimes where step1() is some external library you don't have the luxury of calling stop3() first. — Happy Coconut
– Happy Coconut, Commented Dec 9, 2022 at 17:29

Gabriel Luci · Accepted Answer · 2022-12-09 17:58:51Z

There may be a misunderstanding about how asynchronous methods work. All async methods start running synchronously, just like any other method. The magic happens when await acts on a Task that is incomplete. At that point, the method returns a new incomplete Task to the calling method (or returns nothing if it's void, which is why you should avoid async void).

So if you call step1() first, then step1() will start executing first - there is no way around that. But when step1() hits await Task.Run(...) then it returns and the Main method continues executing. At that point, you can decide what to do. Do you want to wait until step1() completes or go do something else?

Here is what the code would look like if you want:

step1() to start executing first.
step2() to only start after step1() completes.
step3() executes as soon as possible after step1() starts, but without waiting for step1() to complete.

static async Task Main(string[] args)
{
    async Task step1()
    {
        Console.WriteLine("step 1 starting");
        await Task.Run(() =>
        {
            Thread.Sleep(2000);
            Console.WriteLine("step 1 done");
        });
    }

    async Task step2()
    {
        Console.WriteLine("step 2 starting");
        await Task.Run(() =>
        {
            Thread.Sleep(5000);
            Console.WriteLine("step 2 done");
        });
    }

    void step3()
    {
        Console.WriteLine("step 3");
    }

    var step1task = step1();
    step3();
    await step1task;
    await step2();

    Console.ReadLine();
}

The output is:

step 1 starting
step 3
step 1 done
step 2 starting
step 2 done

If you want step3() to execute before step1() even starts executing, then you need to call step3() first - no way around it.

Batesias · Accepted Answer · 2022-12-09 16:21:52Z

2

If you change your Main method (as well as step1 and step2) to async Task instead of void (or async void), you'll be able to await your methods.

static async Task Main(string[] args)
{
    async Task step1()
    {
        await Task.Run(() =>
        {
            Thread.Sleep(2000);
            Console.WriteLine("step 1");
        });

    }

    async Task step2()
    {
        await Task.Run(() =>
        {
            Thread.Sleep(5000);
            Console.WriteLine("step 2");
        });

    }

    void step3()
    {
        Console.WriteLine("step 3");
    }

    step3(); // You can put step3 here if you want it to run before step1 and step2.
    await step1();
    await step2();
    

    Console.ReadLine();
}

I suggest you check this Microsoft article to get a better understanding of async Task vs async void.

edited Dec 9, 2022 at 16:21

answered Dec 9, 2022 at 16:18

Batesias

2,2361 gold badge17 silver badges27 bronze badges

5 Comments

Happy Coconut Over a year ago

Thanks for answer! However step 3 is executed last here and not first. It should be the first method that is executed.

Batesias Over a year ago

Sorry I didn't catch that part. I made the edit with a comment :)

Happy Coconut Over a year ago

Yes I can move step3 to the top and I can even not use any async/await for step1 and step2 just regular void and step 2 will be executed after step 1 for sure. But That was not the point of the question. That is why I put step3 as last.

Ralf Over a year ago

Then you should make that clear in the question. If it comes with conditions (like can't use async there) then name them and also say why they are there.

Batesias Over a year ago

I'm a bit confused now. Can you update the question with all the requirements?

Stig · Accepted Answer · 2022-12-09 20:18:18Z

If the constraints are

step2 should start when step1 ends
step1 and step2 should not block step3
Calling code must be (e.g. no ContinueWith)

step1();
step2();
step3();

Then the answer is this is not possible.

Unless you have control of the code inside the steps, and do thread signalling to prevent step2 to start before step1 ends. Read about ManualResetEvent.

static void Main(string[] args)
{
    var mre = new ManualResetEvent(false);

    void step1()
    {
        Task.Run(() =>
        {
            Thread.Sleep(1000);
            Console.WriteLine("step 1");
            mre.Set();
        });
    }
    void step2()
    {
        Task.Run(() =>
        {
            mre.WaitOne();
            Console.WriteLine("step 2");
        });
    }
    void step3()
    {
        Console.WriteLine("step 3");
    }

    step1();
    step2();
    step3();

    Console.ReadLine();
}

Stig · Accepted Answer · 2022-12-09 20:19:32Z

-2

Drop the async, it is not meaning what you think. Use ContinueWith

    Task step1()
    {
        return Task.Run(() =>
        {
            Thread.Sleep(2000);
            Console.WriteLine("step 1");
        });
    }

    Task step2()
    {
        return Task.Run(() =>
        {
            Thread.Sleep(5000);
            Console.WriteLine("step 2");
        });
    }

    void step3()
    {
        Console.WriteLine("step 3");
    }

    var task = step1()
        .ContinueWith(x => step2());
    step3();
    task.Wait();

edited Dec 9, 2022 at 20:19

answered Dec 9, 2022 at 16:40

Stig

2,1152 gold badges28 silver badges55 bronze badges

17 Comments

Gabriel Luci Over a year ago

There's no reason to use .ContinueWith() over await. And while using .Wait() here doesn't really make a difference, it's a bad idea to get into the habit of using it. There's no reason to recommend it here.

Stig Over a year ago

Yes .Wait() here is important when I don't use await and don't have Console.ReadLine(); The Program would exist before Task is finished.

Stig Over a year ago

Disagree again, ContinueWith and await has two difference purposes. He want's to chain tasks, which has nothing to do with await.

Gabriel Luci Over a year ago

But you don't need .Wait() to do that. Mark the Main() method as async and use await task;.

Gabriel Luci Over a year ago

The OP is a self-admitted newbie. Sometimes it's better to point out the fault in the question rather than recommend something that might contribute to bad habits.

|

Collectives™ on Stack Overflow

Call async method after another async method is finished in C#

4 Answers 4

Comments

5 Comments

Comments

17 Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

4 Answers 4

Comments

5 Comments

Comments

17 Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related