stop bubbling up Async await Task to caller without getting deadlock

Question

I have a problem where I have a library that uses an async function, GetParametersByPathAsync (which is defined here: https://github.com/aws/aws-sdk-net/blob/master/sdk/src/Services/SimpleSystemsManagement/Generated/_mobile/AmazonSimpleSystemsManagementClient.cs#L2718)

I have a library function defined as

Task<Dictionary<string,string>> GetAllParameters(string region)
{
    var pars = DoParameterGatheringWork(reigion);
    ...(do some more work)
    return dict;
}

which calls another method

async Task<Dictionary<string,string>> DoParameterGatheringWork(string region)
{
    ...
    var response = await GetParametersByPathAsync(requestObj);
    ... (process the response)
    return parameterDict;
}

that awaits on the GetParametersByPathAsync and gathers things.

This is a problem because GetAllParameters has to be called by my service from a static constructor and initialize a parameter Dictionary<string,string> MyParameters { get; }

I would like to stop this bubbling up of Tasks at some point in the library, so it can just expose Dictionary<string,string> GetAllParameters(string region), not the Task version. (I am completely fine with it becoming synchronous..)

I don't think I should be just doing Task.Wait() or Task.Result either because that will cause deadlocks.

Maybe this isn't the best way to go about it, but I am unsure how to continue on from here.

Any thoughts would be appreciated!

Edit:

Here is the constructor code I would like to have:

public class MyConfiguration
{
    static MyConfiguration()
    {
        ...
        Parameters = ServiceConfiguration.GetAllParameters(); // (library call)
    }
    public static Dictionary<string, string> Parameters { get; }
}

and the client will be able to use this anywhere just by MyConfiguration.Parameters["IAMAPARAMETER"]

Answer 1

After comment: at the end of this answer: How to call the async method from a non-async method

Apparently DoParameterGatheringWork is a function that normally would have to do some busy waiting for another process, like a database, or a file, or some information from the internet.

The designer of that function thought it would be a waste of time if your thread would be waiting idly for the result of this remove action. Therefore he decided to make it async, so the callers could do other things while the other process would process the request.

You saw correct that this means that all callers should also be async, and that a constructor can't be async.

If you want to benefit from the advantages of async-await (meaning that your callers can continue processing instead of idly waiting, make your constructor ligthweight and let some Create function do the async job you normally would do in the constructor. Force everyone who wants an object of your class to use this async Create function.

public class MyConfiguration
{
    // Static async Create function, does everything you'd normally do in the constructor:
    public static async Task<MyConfiguration> CreateAsync()
    {
        Dictionary<string,string> allParameters = await ServiceConfiguration.GetAllParameters(...);
        MyConfiguration createdConfiguration = new MyConfiguration(allParameters);
        return createdConfiguration;
     }

     // make sure that no one except CreateAsync can call the constructor:
     private MyConfiguration(Dictionary<string,string> allParameters)
     {
          parameters = allParameters;
     }
}

What you do is that you make the constructor as lightweight as possible and do all the difficult stuff, including await in the CreateAsync function.

Usage:

The following will lead to compiler error, so you know the problem before you start running:

MyConfiguration config = new MyConfiguration(...);

Proper usage:

async Task<...> DoSomethingAsync(...)
{
     ...
     // I need a configuration:
     MyConfiguration config = await MyConfiguration.Create();
     // from here you can use the fully initialized MyConfiguration object:
     config.DoSomethingElse();
     ...
}

Simple comme bonjour

Addition: how to call async method from a non-async function

To call an async function from a non-async method, use Task.Run to start the async function, Task.Wait to wait for the async function to complete and Task.Result to get the return value of the async function.

static void Main(string[] args)
{
    // call an async function:
    var asyncTask = Task.Run( () => MyAsyncFunction(...));

    // if desired: do other things
    DoSomethingElse();

    // now you need the result of the async function
    asyncTask.Wait();
    var returnValue = asyncTask.Result;
    Process(returnvalue);
}