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 task = client.GetStringAsync("http://ifconfig.me");

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

	Task task2 = Task.Run(async () => await client.GetStringAsync("http://ifconfig.me"));
	Task task3 = Task.Run(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();
}

Accepted Answer

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
Task task = client.GetStringAsync("http://ifconfig.me");

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

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

as .GetStringAsync() returns a Task, 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 FooAsync(string s)
{
    await Task.Delay(1000);
	return s;
}

is compiled to:

Task 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

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

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

Share via

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

2 additional answers

Your answer