A little background information.
I am learning the Web API stack and I am trying to encapsulate all data in the form of a "Result" object with parameters such as Success and ErrorCodes.
Different methods however, would produce different results and error codes but the result object would generally be instantiated the same way.
To save some time and also to learn more about async/await capabilities in C#, I am trying to wrap all the method bodies of my web api actions in an asynchronous action delegate but got caught in a bit of a snag...
Given the following classes:
public class Result
{
public bool Success { get; set; }
public List<int> ErrorCodes{ get; set; }
}
public async Task<Result> GetResultAsync()
{
return await DoSomethingAsync<Result>(result =>
{
// Do something here
result.Success = true;
if (SomethingIsTrue)
{
result.ErrorCodes.Add(404);
result.Success = false;
}
}
}
I want to write a method that performs an action on a Result object and return it. Normally through synchronous methods it would be
public T DoSomethingAsync<T>(Action<T> resultBody) where T : Result, new()
{
T result = new T();
resultBody(result);
return result;
}
But how do I transform this method into an asynchronous method using async/await?
This is what I have tried:
public async Task<T> DoSomethingAsync<T>(Action<T, Task> resultBody)
where T: Result, new()
{
// But I don't know what do do from here.
// What do I await?
}
new
-ing up theT
, why does your method need to be asynchronous? AFAIK in code using asynchronous APIs, you only need to propagate theasync
ness from other methods you use. – millimooseStream.ReadAsync()
in a method, that method should itself be asynchronous, and return aTask<T>
whereT
is what you'd have returned were the method synchronous. The idea is that this way, every caller of your method can then "asynchronously wait" (I don't know what a good term for this is) for the underlyingStream.ReadAsync()
to complete. A metaphor for this you can use is that async is "infectious", and spreads from low-level built-in I/O into other code whose results depend on those of said I/O. – millimoose