Making HTTP Requests

(new System.Net.WebClient()).DownloadString("http://x.com");        //string
(new System.Net.WebClient()).DownloadData("http://x.com/file.bin"); //byte[]
(new System.Net.WebClient()).DownloadFile("http://x.com/file.zip", @"c:\file.zip"); //void

public class Person {
    public string Name {get; set;}
    public string Email {get; set;}
}

[Route("api/[controller]")]

public class ToolInvokeController : Controller
{
    [HttpPost]
    public void Post([FromBody]Person p)
    {
    }//In VS set breakpoint here to ensure that p is deserialized properly
}

using Newtonsoft.Json;

...
HttpClient client = new HttpClient();
client.BaseAddress = new Uri(EndpointUri);

//if authn headers needed:
client.DefaultRequestHeaders.Authorization =
    new AuthenticationHeaderValue("Bearer", "[jwt here]");

HttpResponseMessage response = client.PostAsync("/api/ToolInvoke", 
    new StringContent(
        JsonConvert.SerializeObject(person),
        Encoding.UTF8, "application/json")
    ).Result;

//Tip: If you don't want to serialize a POCO, you can create an anon. type: JsonConvert.SerializeObject(new { Name = "asdf", Email = "agafg" })

Could not load file or assembly 'Newtonsoft.Json, Version=[old version no.], Culture=neutral, PublicKeyToken=30ad4fe6b2a6aeed' or one of its dependencies

public static class HttpClientExt
{
    public static async System.Threading.Tasks.Task<HttpResponseMessage> PostAsJsonAsync<T>(this HttpClient client, string requestUrl, T theObj)
    {
        var stringContent = new StringContent(
            Newtonsoft.Json.JsonConvert.SerializeObject(theObj),
            System.Text.Encoding.UTF8, "application/json");
        return await client.PostAsync(requestUrl, stringContent);
    }  //modified from: https://stackoverflow.com/a/40525794/2205372
}

public class HttpClientWrapper
{
    private HttpClient httpClient;
    public HttpClient Client => httpClient ?? (httpClient = new HttpClient());
}

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Get, "http://localhost:10329/TimeoutTest/Edit/1");
var response = client.SendAsync(request, timeoutInSec: 21).Result; //timeout param that will not cause an error to be thrown, rather it sets an appropriate error code + message in the HttpResponseMessage

var errors = response.GetErrorsAsync().Result;  //easy way to get errors.  
if (errors == null)
{
    var objects = response.DeserializeAsListAsync<Dictionary<string, string>>().Result; //efficient way of deserializing (using streams instead of reading entire string as memory)
}
client.Dispose();

public static class HttpClientExt
{
	public static async Task<HttpResponseMessage> PostAsJsonAsync(this HttpClient client, string requestUrl, object theObj, int timeoutInSec = 0)
	{
		return await SendAsync(client, new HttpRequestMessage(HttpMethod.Post, requestUrl), theObj, timeoutInSec);
	}
	public static async Task<HttpResponseMessage> SendAsync(this HttpClient client,
	   HttpRequestMessage request,

	   object objToSend = null,
	   int timeoutInSec = 0)
	{
		var cts = new CancellationTokenSource();
		if (timeoutInSec > 0)
		{
			if (client.Timeout.TotalMilliseconds != -1)
			{
				client.Timeout = new TimeSpan(0, 0, 0, 0, -1);
			}
			cts.CancelAfter(TimeSpan.FromSeconds(timeoutInSec));
		}
		if(objToSend != null)
		{
			request.Content = new StringContent(
				JsonConvert.SerializeObject(objToSend),
				System.Text.Encoding.UTF8, "application/json");
		}
		
		var responseAsTask = client.SendAsync(request, HttpCompletionOption.ResponseHeadersRead, cts.Token);
		HttpResponseMessage response;
		try
		{
			response = await responseAsTask.ConfigureAwait(false);
		}
		catch (TaskCanceledException)
		{
			response = new HttpResponseMessage { StatusCode = HttpStatusCode.RequestTimeout, ReasonPhrase = $"Manual Timed out set by client: {timeoutInSec} seconds" };
		}
		catch (HttpRequestException e)
		{//Server is down
			response = new HttpResponseMessage { StatusCode = HttpStatusCode.ServiceUnavailable, ReasonPhrase = e.InnerException.Message };
		}
			
		return response;
	}

	public static async Task<string> GetErrorsAsync(this HttpResponseMessage response)
	{
		if (!response.IsSuccessStatusCode) //success = [200-299]
		{
			if(response.Content == null)
			{
				return response.ReasonPhrase;
			}
			else
			{
				var stream = await response.Content.ReadAsStreamAsync();
				var content = await StreamToStringAsync(stream);
				return content;
			}
		}
		return null;
	}

	public static async Task<List<T>> DeserializeAsListAsync<T>(this HttpResponseMessage response)
	{
		response.EnsureSuccessStatusCode();
		var stream = await response.Content.ReadAsStreamAsync();
		return DeserializeJsonFromStream<List<T>>(stream);
	}

	private static async Task<string> StreamToStringAsync(Stream stream)
	{
		string content = null;

		if (stream != null)
			using (var sr = new StreamReader(stream))
				content = await sr.ReadToEndAsync();

		return content;
	}

	private static T DeserializeJsonFromStream<T>(Stream stream)
	{
		if (stream == null || stream.CanRead == false)
			return default(T);

		using (var sr = new StreamReader(stream))
		using (var jtr = new JsonTextReader(sr))
		{
			var js = new JsonSerializer();
			return js.Deserialize<T>(jtr);
		}
	}
}