title: What is the best practice using async without await?
body: <h3>Application</h3>
  <p>I have a <code>View Model</code> that is referenced by multiple projects or <code>Views</code>.</p>
  <p>Due to the API, some of the <code>View</code> projects are <code>async</code> and others are not.</p>
  <p>The <code>View</code> project injects it's implementation of an interface into the <code>View Model</code> using an IOC container.</p>
  <h3>Code</h3>
  <p>Consider this minimal example of the code</p>
  <p>The interface:</p>
  <pre><code>public interface IDatabase
  {
      Task&lt;Data&gt; GetData();
  }
  </code></pre>
  <p>The <code>View Model</code> awaits the GetData method:</p>
  <pre><code>public class DisplayDataViewModel
  {
       private readonly  IDatabase _database
       public DisplayDataViewModel(IDatabase database)
       {
            _database = database;
       }
  
       private async Task GetDataFromDatabase()
       {
           Data data = await _database.GetData();
           // do something with data...
       }
  }
  </code></pre>
  <p><code>Asynchronous View</code> project uses an Async function to get the data</p>
  <pre><code>public class AsynchronousViewDataBase : IDatabase
  {
      public async Task&lt;Data&gt; GetData()
      {
          return await GetDataAsync();
      }
  }
  </code></pre>
  <p><code>Synchronous View</code> project uses a synchronous call to get the data, but due to the constraint of the interface, I need to return a Task, but I am merely  interested in the return of the <code>Data</code> thus making the method async.</p>
  <pre><code>public class SynchronousViewDatabase : IDatabase
  {
      public async Task&lt;Data&gt; GetData()
      {
          return GetData();
      } 
  }
  </code></pre>
  <p><strong>But</strong> then it gives warning:</p>
  <blockquote>
  <p>This async method lacks 'await' operators and will run synchronously. Consider using the 'await' operator to await non-blocking API calls, or 'await Task.Run(...)' to do CPU-bound work on a background thread.</p>
  </blockquote>
  <p><em>Which is sort-of fine with me, since I don't care if it runs synchronously.</em></p>
  <p>Using a <code>Task.Run</code> to suppress the warning seems unnecessary since the call can (and in my case does) originate from a background thread.</p>
  <h3>Question</h3>
  <p>Is there a best practice to implement this type of non-await async method? Is it okay to ignore the warning? Is there a better way to implement the <em>async</em> Synchronous call?</p>
  <h3>Additional</h3>
  <p>I did convert the interface to a synchronous call, and using the <code>Task.Result</code> in the <code>Asynchronous View</code> (which fixed the warning), but that caused the app to stop responding and just a lot of difficult issues.</p>
  <p><em>Note</em>: I am <strong>not</strong> stating that using the <code>async</code> keyword magically makes the method run asynchronously.</p>