C#

public async T RefreshData<T>(string url)
{
   try 
   {
      var response = await client.GetAsync (url);
      if (response.IsSuccessStatusCode) {
         var content = await response.Content.ReadAsStringAsync ();
         var items = JsonConvert.DeserializeObject<T>(content);
         if(items != null)
         {
            return items;
         }
         throw new Exception($"Service did not provide a response formatted as type: {typeof(T)}");
      }else{
         throw new Exception($"Service request failure. Code: {response.StatusCode}");
      }
   } 
   catch (Exception ex) 
   {
      Debug.WriteLine ($"ERROR {ex.Message}");
   }
}

var myList = RefreshData<List<todoitem>>("http ://localhost:9054/TotoItem");

Nathan Minier wrote:

you're returning List<todoitem>, which is different from Task<List<todoitem>>.

Nathan Minier wrote:

your method, as written, will run synchronously

var response = await client.GetAsync (uri);

public async Task<T> RefreshData<T>(string url)
{
   return Task<T>.Run(()=>
   {
      var response = await client.GetAsync (url);
      if (response.IsSuccessStatusCode) {
         var content = await response.Content.ReadAsStringAsync ();
         var items = JsonConvert.DeserializeObject<T>(content);
         if(items != null)
         {
            return items;
         }
         throw new Exception($"Service did not provide a response formatted as type: {typeof(T)}");
      }else{
         throw new Exception($"Service request failure. Code: {response.StatusCode}");
      }
   })
   .ContinueWith(ex => { Debug.WriteLine ($"ERROR {ex.Message}");}, TaskContinuationOptions.OnlyOnFaulted));
}

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; }
}