get callback value from action

Question

I have this function with action parameter, after it was executed the parameter on that function will have a value. Is there a way for me to get the value?

public void DetailsAsync(string param1, string param2,Action<IList<Detail>> callback)
{
       //process happen here and will have a callback to produce the data for detail
}

public class DetailController:ApiController
{
  private IList<Detail> details;

  private DetailCompleted(IList<Detail> detail)
  {
    //now detail parameter has a value that I can use
    details = detail;
  }


  [HttpGet]
  public IList<Detail> GetDetails()
  {
    ServiceManager.DetailsAsync("param1","param2",detailsCompleted)

   //after ServiceManager.DetailsAsync it will go to return details
    return details;
  }
}

When I tried this code, I placed a breakpoint on return details and breakpoint on detailsCompleted but what happen is that when I called the web api GetDatails, it will first execute return details and right after that it will execute detailsCompleted function. that's why currently I cant get the value.

Answer 1

The return value of a Action<T> is by default void. If you want a return value, you should use Func<T,TResult>

https://learn.microsoft.com/en-us/dotnet/api/system.func-2?view=netframework-4.7.2

Answer 2

I think the problem here is that DetailsAsync(), as implied by name is asynchronous and you return details before waiting for results of DetailsAsync(). So you should await it, but because DetailsAsync returns void, you can't.

So you could wrap the DetailsAsync in a Task and .Wait() for it, but it kind of sucks because you will block the calling thread.

[HttpGet]
public IList<Detail> GetDetails()
{
    Task.Run(() => 
        ServiceManager.DetailsAsync("param1", "param2", detailsCompleted)
    ).Wait();
    return details;
}

Answer 3

Because of the way DetailsAsync is written, you will need some sort of signalling system to pause execution of GetDetails until the callback is fired. There are several options, but I choose an AutoResetEvent because it is fairly simple to work with and understand.

(I've changed some of the return types just so that I didn't have to create fake classes to match your code)

public class DetailController
{
    private IList<int> details;
    private AutoResetEvent callbackSignal = new AutoResetEvent(false);

    private void DetailCompleted(IList<int> detail)
    {
        details = detail;
        callbackSignal.Set();
    }    

    public IList<int> GetDetails()
    {    
        ServiceManager.DetailsAsync("param1", "param2", DetailCompleted);
        callbackSignal.WaitOne();
        return details;
    }
}

callbackSignal.WaitOne(); will block until "signaled". In the callback method, callbackSignal.Set(); sends the signal, telling anything waiting on the event that it is ok to proceed now.

Without knowing exactly how DetailsAsync is implemented, I can't guarantee that this will work, but I'm hopeful. You may also have to add some additional protection to make sure this is full reentrant if required.

---

If you would rather work with the more modern async / await pattern, you could wrap access to DetailsAsync access in a method that is Task returning, and uses a TaskCompletionSource to orchestrate the callback and return values.

public class DetailController
{
    public async Task<IList<int>> GetDetails()
    {
        var details = await ServiceWrapper.GetDetails();
        return details;
    }
}

public static class ServiceWrapper
{
    public static Task<IList<int>> GetDetails()
    {
        var tcs = new TaskCompletionSource<IList<int>>();
        ServiceManager.DetailsAsync("param1", "param2", (IList<int> details) =>
            {
                tcs.SetResult(details);
            });
        return tcs.Task;
    }
}