How to write an async method with out parameter

Question

I want to write an async method with an out parameter  like this   public async void Method1         int op      int result   await GetDataTaskAsync out op       How do I do this in GetDataTaskAsync

User · Answer

You can do this by using TPL  task parallel library  instead of direct using await keyword   private bool CheckInCategory int  id  out Category category                if  id    null    id    0              category   null          else             category   Task Run async      gt  await  context Categories FindAsync id    0   Result           return category    null         if  CheckInCategory int  id  out var category   return error

User · Answer

The limitation of the async methods not accepting out parameters applies only to the compiler-generated async methods  these declared with the async keyword  It doesn t apply to hand-crafted async methods  In other words it is possible to create Task returning methods accepting out parameters  For example lets say that we already have a ParseIntAsync method that throws  and we want to create a TryParseIntAsync that doesn t throw  We could implement it like this   public static Task lt bool gt  TryParseIntAsync string s  out Task lt int gt  result        var tcs   new TaskCompletionSource lt int gt         result   tcs Task      return ParseIntAsync s  ContinueWith t   gt                if  t IsFaulted                        tcs SetException t Exception InnerException               return false                    tcs SetResult t Result           return true         default  TaskContinuationOptions None  TaskScheduler Default       Using the TaskCompletionSource and the ContinueWith method is a bit awkward  but there is no other option since we can t use the convenient await keyword inside this method   Usage example   if  await TryParseIntAsync  -13   out var result         Console WriteLine   Result   await result       else       Console WriteLine   Parse failed          Update  If the async logic is too complex to be expressed without await  then it could be encapsulated inside a nested asynchronous anonymous delegate  A TaskCompletionSource would still be needed for the out parameter  It is possible that the out parameter could be completed before the completion of the main task  as in the example bellow   public static Task lt string gt  GetDataAsync string url  out Task lt int gt  rawDataLength        var tcs   new TaskCompletionSource lt int gt         rawDataLength   tcs Task      return   Func lt Task lt string gt  gt   async      gt                var response   await GetResponseAsync url           var rawData   await GetRawDataAsync response           tcs SetResult rawData Length           return await FilterDataAsync rawData                  This example assumes the existence of three asynchronous methods GetResponseAsync  GetRawDataAsync and FilterDataAsync that are called in succession  The out parameter is completed on the completion of the second method  The GetDataAsync method could be used like this   var data   await GetDataAsync  http   example com   out var rawDataLength   Console WriteLine   Data   data     Console WriteLine   RawDataLength   await rawDataLength       Awaiting the data before awaiting the rawDataLength is important in this simplified example  because in case of an exception the out parameter will never be completed

User · Answer

You can t have async methods with ref or out parameters   Lucian Wischik explains why this is not possible on this MSDN thread  http   social msdn microsoft com Forums en-US d2f48a52-e35a-4948-844d-828a1a6deb74 why-async-methods-cannot-have-ref-or-out-parameters     As for why async methods don t support out-by-reference parameters     or ref parameters   That s a limitation of the CLR  We chose to   implement async methods in a similar way to iterator methods -- i e    through the compiler transforming the method into a   state-machine-object  The CLR has no safe way to store the address of   an  out parameter  or  reference parameter  as a field of an object    The only way to have supported out-by-reference parameters would be if   the async feature were done by a low-level CLR rewrite instead of a   compiler-rewrite  We examined that approach  and it had a lot going   for it  but it would ultimately have been so costly that it d never   have happened    A typical workaround for this situation is to have the async method return a Tuple instead  You could re-write your method as such   public async Task Method1         var tuple   await GetDataTaskAsync        int op   tuple Item1      int result   tuple Item2     public async Task lt Tuple lt int  int gt  gt  GetDataTaskAsync                   return new Tuple lt int  int gt  1  2

User · Answer

One nice feature of out parameters is that they can be used to return data even when a function throws an exception  I think the closest equivalent to doing this with an async method would be using a new object to hold the data that both the async method and caller can refer to  Another way would be to pass a delegate as suggested in another answer   Note that neither of these techniques will have any of the sort of enforcement from the compiler that out has  I e   the compiler won   t require you to set the value on the shared object or call a passed in delegate   Here   s an example implementation using a shared object to imitate ref and out for use with async methods and other various scenarios where ref and out aren   t available   class Ref lt T gt           Field rather than a property to support passing to functions        accepting  ref T  or  out T       public T Value     async Task OperationExampleAsync Ref lt int gt  successfulLoopsRef        var things   new     0  1  2         var i   0      while  true                   Fourth iteration will throw an exception  but we will still have            communicated data back to the caller via successfulLoopsRef          things i     i          successfulLoopsRef Value            i             async Task UsageExample         var successCounterRef   new Ref lt int gt            Note that it does not make sense to access successCounterRef        until OperationExampleAsync completes  either fails or succeeds         because there   s no synchronization  Here  I think of passing        the variable as    temporarily giving ownership    of the referenced        object to OperationExampleAsync  Deciding on conventions is up to        you and belongs in documentation         try               await OperationExampleAsync successCounterRef             finally               Console WriteLine   Had  successCounterRef Value  successful loops

User · Answer

I love the Try pattern  It s a tidy pattern   if  double TryParse name  out var result            handle success   else          handle error     But  it s challenging with async  That doesn t mean we don t have real options  Here are the three core approaches you can consider for async methods in a quasi-version of the Try pattern   Approach 1 - output a structure  This looks most like a sync Try method only returning a tuple instead of a bool with an out parameter  which we all know is not permitted in C    var result   await DoAsync name   if  result Success           handle success   else          handle error     With a method that returns true of false and never throws an exception       Remember  throwing an exception in a Try method breaks the whole purpose of the pattern    async Task lt  bool Success  StorageFile File  Exception exception  gt  DoAsync string fileName        try               var folder   ApplicationData Current LocalCacheFolder          return  true  await folder GetFileAsync fileName   null             catch  Exception exception                return  false  null  exception             Approach 2 - pass in callback methods  We can use anonymous methods to set external variables  It s clever syntax  though slightly complicated  In small doses  it s fine    var file   default StorageFile   var exception   default Exception   if  await DoAsync name  x   gt  file   x  x   gt  exception   x            handle success   else          handle failure     The method obeys the basics of the Try pattern but sets out parameters to passed in callback methods  It s done like this   async Task lt bool gt  DoAsync string fileName  Action lt StorageFile gt  file  Action lt Exception gt  error        try               var folder   ApplicationData Current LocalCacheFolder          file  Invoke await folder GetFileAsync fileName            return true            catch  Exception exception                error  Invoke exception           return false               There s a question in my mind about performance here  But  the C  compiler is so freaking smart  that I think you re safe choosing this option  almost for sure    Approach 3 - use ContinueWith  What if you just use the TPL as designed  No tuples  The idea here is that we use exceptions to redirect ContinueWith to two different paths   await DoAsync name  ContinueWith task   gt        if  task Exception    null                   handle fail           if  task Result is StorageFile sf                   handle success             With a method that throws an exception when there is any kind of failure  That s different than returning a boolean  It s a way to communicate with the TPL   async Task lt StorageFile gt  DoAsync string fileName        var folder   ApplicationData Current LocalCacheFolder      return await folder GetFileAsync fileName       In the code above  if the file is not found  an exception is thrown  This will invoke the failure ContinueWith that will handle Task Exception in its logic block  Neat  huh       Listen  there s a reason we love the Try pattern  It s fundamentally so neat and readable and  as a result  maintainable  As you choose your approach  watchdog for readability  Remember the next developer who in 6 months and doesn t have you to answer clarifying questions  Your code can be the only documentation a developer will ever have    Best of luck

User · Answer

Alex made a great point on readability   Equivalently  a function is also interface enough to define the type s  being returned and you also get meaningful variable names   delegate void OpDelegate int op   Task lt bool gt  GetDataTaskAsync OpDelegate callback        bool canGetData   true      if  canGetData  callback 5       return Task FromResult canGetData       Callers provide a lambda  or a named function  and intellisense helps by copying the variable name s  from the delegate   int myOp  bool result   await GetDataTaskAsync op   gt  myOp   op     This particular approach is like a  Try  method where myOp is set if the method result is true  Otherwise  you don t care about myOp

User · Answer

I had the same problem as I like using the Try-method-pattern which basically seems to be incompatible to the async-await-paradigm    Important to me is that I can call the Try-method within a single if-clause and do not have to pre-define the out-variables before  but can do it in-line like in the following example  if  TryReceive out string msg            use msg    So I came up with the following solution   Define a helper struct   public struct AsyncOut lt T  OUT gt          private readonly T returnValue       private readonly OUT result        public AsyncOut T returnValue  OUT result                  this returnValue   returnValue           this result   result               public T Out out OUT result                  result   this result           return returnValue               public T ReturnValue   gt  returnValue        public static implicit operator AsyncOut lt T  OUT gt   T returnValue  OUT result  tuple    gt            new AsyncOut lt T  OUT gt  tuple returnValue  tuple result        Define async Try-method like this   public async Task lt AsyncOut lt bool  string gt  gt  TryReceiveAsync           string message       bool success                   return  success  message        Call the async Try-method like this   if   await TryReceiveAsync    Out out string msg              use msg       For multiple out parameters you can define additional structs  e g  AsyncOut lt T OUT1  OUT2 gt   or you can return a tuple

User · Answer

For developers who REALLY want to keep it in parameter  here might be another workaround  Change the parameter to an array or List to wrap the actual value up  Remember to initialize the list before sending into the method  After returned  be sure to check value existence before consuming it  Code with caution

User · Answer

You cannot have ref or out parameters in async methods  as was already noted    This screams for some modelling in the data moving around   public class Data       public int Op  get  set       public int Result  get  set      public async void Method1         Data data   await GetDataTaskAsync           use data Op and data Result from here on    public async Task lt Data gt  GetDataTaskAsync         var returnValue   new Data           Fill up returnValue     return returnValue      You gain the ability to reuse your code more easily  plus it s way more readable than variables or tuples

User · Answer

I think using ValueTuples like this can work   You have to add the ValueTuple NuGet package first though   public async void Method1          int op  int result  tuple   await GetDataTaskAsync        int op   tuple op      int result   tuple result     public async Task lt  int op  int result  gt  GetDataTaskAsync         int x   5      int y   10      return  op  x  result  y

User · Answer

The C 7  Solution is to use implicit tuple syntax       private async Task lt  bool IsSuccess  IActionResult Result  gt  TryLogin OpenIdConnectRequest request                 return  true  BadRequest new OpenIdErrorResponse                       Error   OpenIdConnectConstants Errors AccessDenied              ErrorDescription    Access token provided is not valid                        return result utilizes the method signature defined property names  e g   var foo   await TryLogin request   if  foo IsSuccess       return foo Result

User · Answer

Here s the code of  dcastro s answer modified for C  7 0 with named tuples and tuple deconstruction  which streamlines the notation   public async void Method1            Version 1  named tuples         just to show how it works            var tuple   await GetDataTaskAsync        int op   tuple paramOp      int result   tuple paramResult                 Version 2  tuple deconstruction         much shorter  most elegant      int op  int result    await GetDataTaskAsync       public async Task lt  int paramOp  int paramResult  gt  GetDataTaskAsync                   return  1  2       For details about the new named tuples  tuple literals and tuple deconstructions see  https   blogs msdn microsoft com dotnet 2017 03 09 new-features-in-c-7-0

[c#] How to write an async method with out parameter?

Examples related to c#

Examples related to async-await