Wait for async Task without wrapping exceptions in AggregateException

Question

I am using a library which provides methods ending with ...Async and return Task. I am going to use these in a command line application

Answer 1

I am going to use these in a command line application. So I need to call them synchronously a lot.

No, you don't. You can use async-await in a console application, you just need to make an async to sync transition at the very top. And you can do that by using Wait():

public static void Main()
{
    MainAsync().Wait();
}

public static async Task MainAsync()
{
    var datastore = …;
    await datastore.SaveAsync();
}

Usually, combining await with Wait() is a bad idea (it can cause deadlocks), but it's the right solution here.

Note that if SaveAsync() throws an exception and you don't catch it, it will be rethrown as AggregateException from the Wait(). But you can catch it as the original exception in MainAsync() (because it doesn't use Wait()).

If you really wanted to get the first exception thrown directly, you could do something similar to what await does: task.GetAwaiter().GetResult(). Note that if the Task contains more than one exception, you will get only the first one (but the same applies to await).

Since C# 7.1, you can make your Main method async and the compiler will write the transition code for you:

public static async Task Main()
{
    var datastore = …;
    await datastore.SaveAsync();
}

When I use a method returning Task, task.Result throws AggregateException even though there are no continuation tasks set. Why is this happening?

This has nothing to do with continuations. A single Task can represent multiple operations, and each of them can throw an exception. Because of that, Task methods always throw the exceptions wrapped in an AggregateException.

I also have tried task.RunSynchronously()

That doesn't make any sense. RunSynchronously() can only be used on Tasks that were created using the Task constructor. That's not the case here, so you can't use it. Tasks returned from async methods are always already started.