title: Fire-and-forget with async vs "old async delegate"
body: <p>I am trying to replace my old fire-and-forget calls with a new syntax, hoping for more simplicity and it seems to be eluding me. Here's an example</p>
  
  <pre><code>class Program
  {
      static void DoIt(string entry) 
      { 
          Console.WriteLine("Message: " + entry);
      }
  
      static async void DoIt2(string entry)
      {
          await Task.Yield();
          Console.WriteLine("Message2: " + entry);
      }
  
      static void Main(string[] args)
      {
          // old way
          Action&lt;string&gt; async = DoIt;
          async.BeginInvoke("Test", ar =&gt; { async.EndInvoke(ar); ar.AsyncWaitHandle.Close(); }, null);
          Console.WriteLine("old-way main thread invoker finished");
          // new way
          DoIt2("Test2");   
          Console.WriteLine("new-way main thread invoker finished");
          Console.ReadLine();
      }
  }
  </code></pre>
  
  <p>Both approaches do the same thing, however what I seem to have gained (no need to <code>EndInvoke</code> and close handle, which is imho still a bit debatable) I am losing in the new way by having to await a <code>Task.Yield()</code>, which actually poses a new problem of having to rewrite all existing async F&amp;F methods just to add that one-liner. Are there some invisible gains in terms of performance/cleanup?</p>
  
  <p>How would I go about applying async if I can't modify the background method? Seems to me that there is no direct way, I would have to create a wrapper async method that would await Task.Run()?  </p>
  
  <p>Edit: I now see I might be missing a real questions. The question is: Given a synchronous method A(), how can I call it asynchronously using <code>async</code>/<code>await</code> in a fire-and-forget manner without getting a solution that is more complicated than the "old way"  </p>