C#

public async Task<List<todoitem>> RefreshDataAsync ()
{
    Items = new List<todoitem> ();
    RestUrl = "http://localhost:9054/TotoItem"
    var uri = new Uri (string.Format (RestUrl, string.Empty));
    
    try {
        // Runs synchronously up to here...
        var response = await client.GetAsync (uri);
        
        // The rest of the method is signed up as a continuation,
        // invoked when the IO completion port notifies that the request has been completed.
        // The current thread is NOT blocked.
        
        // Depending on the calling context, the continuation MIGHT run on the same thread as the caller.
        // But this is handled asynchronously; the thread does not block waiting to run the continuation.
        // This can be changed by adding ".ConfigureAwait(false)" after "GetAsync(url)".
        
        if (response.IsSuccessStatusCode) {
            var content = await response.Content.ReadAsStringAsync ();
            // Again, the rest of the method is signed up as a continuation.
            // The thread is NOT blocked waiting for the response content to be downloaded.
            
            Items = JsonConvert.DeserializeObject <List<todoitem>> (content);
            // The JSON conversion IS run syncronously.
            // But async support in JSON.NET was only recently added (v10.1), so there's probably no option here.
    }
    } catch (Exception ex) {
        Debug.WriteLine (@" ERROR {0}", ex.Message);
    }
    
    return Items;
}

var response = await client.GetAsync (uri);<br />
// Code execution within this method halted until response is resolved
if (response.IsSuccessStatusCode) {

public async Task<T> RefreshData<T>(string url)
{
   return Task<T>.Run(()=>
   {
      var response = await client.GetAsync (url);
      // Code execution within this method halted until response is resolved
      ...
   })
   .ContinueWith(ex => { Debug.WriteLine ($"ERROR {ex.Message}");}, TaskContinuationOptions.OnlyOnFaulted));
}

public class MyClass
{
  private readonly IMyFirstService firstService;
  private readonly IMySecondService secondService;
  [ImportingConstructor]
  public class MyClass(IMyFirstService firstService, IMySecondService secondService)
  {
    this.firstService = firstService;
    this.secondService = secondService;
  }

  public IMyFirstService MyFirstService{ get { return firstService; } }
  public IMySecondService MySecondService { get { return secondService; } }
}

public class MyClass
{
  [Import]
  public IMyFirstService { get; set; }
  [Import]
  public IMySecondService { get; set; }
}