Difference between 'client.GetStringAsync' and 'await client.GetStringAsync'

Question

Hello! I have a synchronous function that I cannot change to async. How can I still call it correctly without using GetAwaiter?

Task<string> task = client.GetStringAsync("http://ifconfig.me");

Task<string> task3 = Task<string>.Run<string>(async () => await client.GetStringAsync("https://api.ipify.org?format=json"));

What is the difference here? Can someone explain that. Thanks in advance When should I take what and why?

using (HttpClient client = new HttpClient())
{
	string sIPAddress = "";
	string responseState = "";

	//Task<string> task = System.Threading.Tasks.Task.Run(() => await client.GetStringAsync("https://www.wieistmeineip.de/"));
	Task<string> task = client.GetStringAsync("http://ifconfig.me");
	(responseState) = task.Result;
	System.Diagnostics.Debug.WriteLine(sIPAddress);

	Task<string> task2 = Task<string>.Run<string>(async () => await client.GetStringAsync("http://ifconfig.me"));
	Task<string> task3 = Task<string>.Run<string>(async () => await client.GetStringAsync("https://api.ipify.org?format=json"));

	// Parse the returned JSON response
	//string jsonResponse = await response.Content.ReadAsStringAsync();
	JObject jsonObject = JObject.Parse(task3.Result);

	// Extract IP address
	string erg = jsonObject["ip"].ToString();
}

Answer 1

Task.Run creates a new thread to run the callback on (whether it is sync or async). It returns a task you can wait on. so in your sample:

// .GetString() returns a Task<string>
Task<string> task = client.GetStringAsync("http://ifconfig.me");

// Task<string>.Run<string> returns a Task<string> 
//   that returns the value of the callback which in turn 
//   returns a Task<string>   
Task<string> task3 = Task<string>.Run<string>(async () => await client.GetStringAsync("https://api.ipify.org?format=json"));

//simplified call without unnecessary await 
Task<string> task3 = Task.Run(() => client.GetStringAsync("https://api.ipify.org?format=json"));

as .GetStringAsync() returns a Task<string>, there is no need for the extra Task.Run(). typically you would use Task.Run(async () = {....}); when you waned to mix async and sync code in the task.

await is just C# syntax sugar. it converts to the code after the await to a continue statement

async Task<string> FooAsync(string s)
{
    await Task.Delay(1000);
	return s;
}

is compiled to:

Task<string> FooAsync(string s)
{
    return Task.Delay(1000).ContinueWith((t) => s);
}

to call a Task sync (continue on the same thread) use:

var r = FooAsync.Result; // stall current thread until task completes
var r2 = FooAsync.GetAwaiter().GetResult(); // stall current thread until task completes

the difference between the two is how errors throw by the task are returned. .GetAwaiter(), like await, returns the exception unmodified, while for compatibility .Result wraps the exception as an AggregateException.

Answer 2

The main difference is the particular thread that the execution is tied to. Task.Run always runs the work on a new thread.

HttpClient.GetStringAsync is an asynchronous method, but up until the point that the first await is reached inside that method the execution is actually synchronously running & blocking the calling thread. Consider this example:

  Console.WriteLine($"Current Thread 1: {Environment.CurrentManagedThreadId}");
  
  Console.WriteLine("--- Outside a Task.Run");
  
  await SomeMethod();
  
  Console.WriteLine("--- Inside a Task.Run");
  
  await Task.Run(() =  SomeMethod());
  
  async Task SomeMethod() {
    /* Some synchronous work */
  	Console.WriteLine($"Current Thread 2: {Environment.CurrentManagedThreadId}");
  
    /* Simulate some asynchronous work */
  	await Task.Delay(1000);
  
  	Console.WriteLine($"Current Thread 3: {Environment.CurrentManagedThreadId}");
  }

The output here for me is:

  Current Thread 1: 1
  Outside a Task.Run
  Current Thread 2: 1
  Current Thread 3: 12
  Inside a Task.Run
  Current Thread 2: 12
  Current Thread 3: 12

So initially the thread is 1 (main thread), when running SomeMethod without a Task.Run we're still on the main thread, then we hit the await and the continuation is done on a new thread (thread 12).

Running inside Task.Run it does the entire method execution on this new thread.

In your snippet above task3.Result will result in the calling thread blocking. The main difference between that and Task.GetAwaiter().GetResult() is that the latter propagates unaggregated exceptions to the calling code, so the GetAwaiter approach tends to be preferred.

Answer 3

Hi Noah,

For synchronous you can use Send method since it is synchronous. Sample below:

using (HttpClient client = new HttpClient())
{
    HttpResponseMessage response = client.Send(new HttpRequestMessage(HttpMethod.Get, "https://api.ipify.org"));
    var streamReader = new StreamReader(response.Content.ReadAsStream());
    System.Diagnostics.Debug.WriteLine(streamReader.ReadToEnd());
}

Please click Accept Answer and upvote if the above was helpful.

Thanks.

-TP