HttpClient.txt

適用版本:
.NET 4.5   以下,     建議使用 WebClient.
.NET 4.5   以上(含), 建議使用 HttpClient.
.NET 4.6.1 以上,     建議使用 HttpClientFactory. (需另外安裝 Microsoft.Extensions.Http NuGet 套件)

參考: HttpWebRequest vs WebClient vs HttpClient.txt

https://blog.yowko.com/httpclient-issue/
https://blog.yowko.com/webrequest-and-httpwebrequest/
https://blog.yowko.com/webclient/
https://blog.yowko.com/httpclient/

----------
20190715

ref:
https://docs.microsoft.com/en-us/aspnet/web-api/overview/advanced/calling-a-web-api-from-a-net-client


Action               HTTP method Relative URI
Get a product by ID  GET         /api/products/id
Create a new product POST        /api/products
Update a product     PUT         /api/products/id
Delete a product     DELETE      /api/products/id

To learn how to implement this API with ASP.NET Web API, see Creating a Web API that Supports CRUD Operations.
For simplicity, the client application in this tutorial is a Windows console application. HttpClient is also supported for Windows Phone and Windows Store apps. For more information, see Writing Web API Client Code for Multiple Platforms Using Portable Libraries


Create the Console Application

In Visual Studio, create a new Windows console app named HttpClientSample and paste in the following code:

using System;
using System.Net;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Threading.Tasks;

namespace HttpClientSample
{
    public class Product
    {
        public string Id { get; set; }
        public string Name { get; set; }
        public decimal Price { get; set; }
        public string Category { get; set; }
    }

    class Program
    {
        static HttpClient client = new HttpClient();

        static void ShowProduct(Product product)
        {
            Console.WriteLine($"Name: {product.Name}\tPrice: " +
                $"{product.Price}\tCategory: {product.Category}");
        }

        static async Task<Uri> CreateProductAsync(Product product)
        {
            HttpResponseMessage response = await client.PostAsJsonAsync(
                "api/products", product);
            response.EnsureSuccessStatusCode();

            // return URI of the created resource.
            return response.Headers.Location;
        }

        static async Task<Product> GetProductAsync(string path)
        {
            Product product = null;
            HttpResponseMessage response = await client.GetAsync(path);
            if (response.IsSuccessStatusCode)
            {
                product = await response.Content.ReadAsAsync<Product>();
            }
            return product;
        }

        static async Task<Product> UpdateProductAsync(Product product)
        {
            HttpResponseMessage response = await client.PutAsJsonAsync(
                $"api/products/{product.Id}", product);
            response.EnsureSuccessStatusCode();

            // Deserialize the updated product from the response body.
            product = await response.Content.ReadAsAsync<Product>();
            return product;
        }

        static async Task<HttpStatusCode> DeleteProductAsync(string id)
        {
            HttpResponseMessage response = await client.DeleteAsync(
                $"api/products/{id}");
            return response.StatusCode;
        }

        static void Main()
        {
            RunAsync().GetAwaiter().GetResult();
        }

        static async Task RunAsync()
        {
            // Update port # in the following line.
            client.BaseAddress = new Uri("http://localhost:64195/");
            client.DefaultRequestHeaders.Accept.Clear();
            client.DefaultRequestHeaders.Accept.Add(
                new MediaTypeWithQualityHeaderValue("application/json"));

            try
            {
                // Create a new product
                Product product = new Product
                {
                    Name = "Gizmo",
                    Price = 100,
                    Category = "Widgets"
                };

                var url = await CreateProductAsync(product);
                Console.WriteLine($"Created at {url}");

                // Get the product
                product = await GetProductAsync(url.PathAndQuery);
                ShowProduct(product);

                // Update the product
                Console.WriteLine("Updating price...");
                product.Price = 80;
                await UpdateProductAsync(product);

                // Get the updated product
                product = await GetProductAsync(url.PathAndQuery);
                ShowProduct(product);

                // Delete the product
                var statusCode = await DeleteProductAsync(product.Id);
                Console.WriteLine($"Deleted (HTTP Status = {(int)statusCode})");

            }
            catch (Exception e)
            {
                Console.WriteLine(e.Message);
            }

            Console.ReadLine();
        }
    }
}

The preceding code is the complete client app.
RunAsync runs and blocks until it completes. Most HttpClient methods are async, because they perform network I/O. All of the async tasks are done inside RunAsync. Normally an app doesn't block the main thread, but this app doesn't allow any interaction.


static async Task RunAsync()
{
    // Update port # in the following line.
    client.BaseAddress = new Uri("http://localhost:64195/");
    client.DefaultRequestHeaders.Accept.Clear();
    client.DefaultRequestHeaders.Accept.Add(
        new MediaTypeWithQualityHeaderValue("application/json"));

    try
    {
        // Create a new product
        Product product = new Product
        {
            Name = "Gizmo",
            Price = 100,
            Category = "Widgets"
        };

        var url = await CreateProductAsync(product);
        Console.WriteLine($"Created at {url}");

        // Get the product
        product = await GetProductAsync(url.PathAndQuery);
        ShowProduct(product);

        // Update the product
        Console.WriteLine("Updating price...");
        product.Price = 80;
        await UpdateProductAsync(product);

        // Get the updated product
        product = await GetProductAsync(url.PathAndQuery);
        ShowProduct(product);

        // Delete the product
        var statusCode = await DeleteProductAsync(product.Id);
        Console.WriteLine($"Deleted (HTTP Status = {(int)statusCode})");

    }
    catch (Exception e)
    {
        Console.WriteLine(e.Message);
    }

    Console.ReadLine();
}







----------
20190713

ref:
https://github.com/aspnet/AspNetDocs/blob/master/aspnet/web-api/overview/advanced/calling-a-web-api-from-a-net-client/sample/client/Program.cs

Action               HTTP method Relative URI
Get a product by ID  GET         /api/products/id
Create a new product POST        /api/products
Update a product     PUT         /api/products/id
Delete a product     DELETE      /api/products/id

#region snippet_all
using System;
using System.Net;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Threading.Tasks;

namespace HttpClientSample
{
    #region snippet_prod
    public class Product
    {
        public string Id { get; set; }
        public string Name { get; set; }
        public decimal Price { get; set; }
        public string Category { get; set; }
    }
    #endregion

    class Program
    {
        #region snippet_HttpClient
        static HttpClient client = new HttpClient();
        #endregion

        static void ShowProduct(Product product)
        {
            Console.WriteLine($"Name: {product.Name}\tPrice: " +
                $"{product.Price}\tCategory: {product.Category}");
        }

        #region snippet_CreateProductAsync
        static async Task<Uri> CreateProductAsync(Product product)
        {
            HttpResponseMessage response = await client.PostAsJsonAsync(
                "api/products", product);
            response.EnsureSuccessStatusCode();

            // return URI of the created resource.
            return response.Headers.Location;
        }
        #endregion

        #region snippet_GetProductAsync
        static async Task<Product> GetProductAsync(string path)
        {
            Product product = null;
            HttpResponseMessage response = await client.GetAsync(path);
            if (response.IsSuccessStatusCode)
            {
                product = await response.Content.ReadAsAsync<Product>();
            }
            return product;
        }
        #endregion

        #region snippet_UpdateProductAsync
        static async Task<Product> UpdateProductAsync(Product product)
        {
            HttpResponseMessage response = await client.PutAsJsonAsync(
                $"api/products/{product.Id}", product);
            response.EnsureSuccessStatusCode();

            // Deserialize the updated product from the response body.
            product = await response.Content.ReadAsAsync<Product>();
            return product;
        }
        #endregion

        #region snippet_DeleteProductAsync
        static async Task<HttpStatusCode> DeleteProductAsync(string id)
        {
            HttpResponseMessage response = await client.DeleteAsync(
                $"api/products/{id}");
            return response.StatusCode;
        }
        #endregion

        static void Main()
        {
            RunAsync().GetAwaiter().GetResult();
        }

        #region snippet_run
        #region snippet5
        static async Task RunAsync()
        {
            // Update port # in the following line.
            client.BaseAddress = new Uri("http://localhost:64195/");
            client.DefaultRequestHeaders.Accept.Clear();
            client.DefaultRequestHeaders.Accept.Add(
                new MediaTypeWithQualityHeaderValue("application/json"));
            #endregion

            try
            {
                // Create a new product
                Product product = new Product
                {
                    Name = "Gizmo",
                    Price = 100,
                    Category = "Widgets"
                };

                var url = await CreateProductAsync(product);
                Console.WriteLine($"Created at {url}");

                // Get the product
                product = await GetProductAsync(url.PathAndQuery);
                ShowProduct(product);

                // Update the product
                Console.WriteLine("Updating price...");
                product.Price = 80;
                await UpdateProductAsync(product);

                // Get the updated product
                product = await GetProductAsync(url.PathAndQuery);
                ShowProduct(product);

                // Delete the product
                var statusCode = await DeleteProductAsync(product.Id);
                Console.WriteLine($"Deleted (HTTP Status = {(int)statusCode})");

            }
            catch (Exception e)
            {
                Console.WriteLine(e.Message);
            }

            Console.ReadLine();
        }
        #endregion
    }
}
#endregion


Media-Type Formatters to Deserialize

When ReadAsAsync is called with no parameters, it uses a default set of media formatters to read the response body. The default formatters support JSON, XML, and Form-url-encoded data.
Instead of using the default formatters, you can provide a list of formatters to the ReadAsAsync method. Using a list of formatters is useful if you have a custom media-type formatter:
var formatters = new List<MediaTypeFormatter>() {
    new MyCustomFormatter(),
    new JsonMediaTypeFormatter(),
    new XmlMediaTypeFormatter()
};
resp.Content.ReadAsAsync<IEnumerable<Product>>(formatters);

----------
20190712

https://blog.yowko.com/httpclient/

使用 HttpClient 來存取 GET,POST,PUT,DELETE,PATCH 網路資源
之前文章 如何使用 WebRequest,HttpWebRequest 來存取 (GET,POST,PUT,DELETE,PATCH) 網路資源 紀錄 WebRequest,HttpWebRequest 的用法，使用 WebClient 來存取 GET,POST,PUT,DELETE,PATCH 網路資源 則紀錄了 WebClient 的用法，接著就是我所知的最後一個可以用來存取網路資源的 HttpClient
HttpClient 基本資訊
用來對 URI 提出 request，以及接收 HTTP 的回應
Namespace：System.Net.Http
Assembly：System.Net.Http (System.Net.Http.dll)
基本要求：.NET Framework 4.5 以上

GET
寫法 1
//建立 HttpClient
HttpClient client = new HttpClient() { BaseAddress= new Uri("http://jsonplaceholder.typicode.com/") };
//使用 async 方法從網路 url 上取得回應
using (HttpResponseMessage response = await client.GetAsync("posts"))
// 將網路取得回應的內容設定給 httpcontent，可省略，直接使用 response.Content
using (HttpContent content = response.Content)
{
    // 將 httpcontent 轉為 string
    string result = await content.ReadAsStringAsync();
    // linqpad 顯示資料用
    if (result != null)
        result.Dump();
}

寫法 2
//建立 HttpClient
HttpClient client = new HttpClient() { BaseAddress = new Uri("http://jsonplaceholder.typicode.com/") };

//使用 async 方法從網路 url 上取得回應
var response = await client.GetAsync("posts");
//如果 httpstatus code 不是 200 時會直接丟出 expection
response.EnsureSuccessStatusCode();
// 將 response 內容 轉為 string
string result = await response.Content.ReadAsStringAsync();
// linqpad 顯示資料用
result.Dump();

寫法 3 - 使用 SendAsync
//建立 HttpClient
HttpClient client = new HttpClient() { BaseAddress = new Uri("http://jsonplaceholder.typicode.com/") };
//指定 request 的 method 與 detail url
using (HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, "posts"))
{
    // 發出 post 並將回應內容轉為 string 再透過 linqpad 輸出
    await client.SendAsync(request)
    .ContinueWith(responseTask =>
    {
        responseTask.GetAwaiter().GetResult().Content.ReadAsStringAsync().Dump();
    });
}


POST
寫法 1 - 使用 PostAsync
//建立 HttpClient
HttpClient client = new HttpClient(){BaseAddress=new Uri("https://jsonbin.org/yowko/")};

// 指定 authorization header
client.DefaultRequestHeaders.Add("authorization", "token {api token}");
    
// 準備寫入的 data
PostData postData = new PostData() { userId = 123422, title = "yowko 中文", body = "yowko test body 中文" };
// 將 data 轉為 json
string json = JsonConvert.SerializeObject(postData);
// 將轉為 string 的 json 依編碼並指定 content type 存為 httpcontent
HttpContent contentPost = new StringContent(json, Encoding.UTF8, "application/json");
// 發出 post 並取得結果
HttpResponseMessage response = client.PostAsync("test", contentPost).GetAwaiter().GetResult();
// 將回應結果內容取出並轉為 string 再透過 linqpad 輸出
response.Content.ReadAsStringAsync().GetAwaiter().GetResult().Dump();

寫法 2 - 使用 SendAsync
// 建立 HttpClient
HttpClient client = new HttpClient();

// 指定 base url 
client.BaseAddress = new Uri("https://jsonbin.org/");
// 指定 authorization header
client.DefaultRequestHeaders.Add("authorization", "token {api token}");
// 指定 request 的 method 與 detail url
HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Post, "yowko/test");
// 準備寫入的 data
PostData postData = new PostData() { userId = 1, title = "yowko 中文", body = "yowko test body 中文" };
// 將 data 轉為 json
string json = JsonConvert.SerializeObject(postData);
// 將轉為 string 的 json 依編碼並指定 content type 存為 httpcontent
request.Content = new StringContent(json, Encoding.UTF8, "application/json");
// 發出 post 並將回應內容轉為 string 再透過 linqpad 輸出
await client.SendAsync(request)
.ContinueWith(responseTask =>
{
    responseTask.GetAwaiter().GetResult().Content.ReadAsStringAsync().Dump();
});


PUT
範例中 PUT 是將 jsonbin 的網址改為 public
寫法 1 - 使用 PutAsync
//建立 HttpClient
HttpClient client = new HttpClient() {BaseAddress= new Uri("https://jsonbin.org/yowko/")};

// 指定 authorization header
client.DefaultRequestHeaders.Add("authorization", "token {api token}");
// 發出 post 並取得結果
HttpResponseMessage response = client.PutAsync("test/_perms", null).Result;
// 將回應結果內容取出並轉為 string 再透過 linqpad 輸出
response.Content.ReadAsStringAsync().GetAwaiter().GetResult().Dump();

寫法 2 - 使用 SendAsync
// 建立 HttpClient
HttpClient client = new HttpClient();

// 指定 base url 
client.BaseAddress = new Uri("https://jsonbin.org/yowko/");
// 指定 authorization header
client.DefaultRequestHeaders.Add("authorization", "token {api token}");
// 指定 request 的 method 與 detail url
HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Put, "test/_perms");
// 發出 post 並將回應內容轉為 string 再透過 linqpad 輸出
await client.SendAsync(request)
.ContinueWith(responseTask =>
{
    responseTask.GetAwaiter().GetResult().Content.ReadAsStringAsync().Dump();
});

DELETE
範例中 DELETE 是將 jsonbin 的網址改為 private
寫法 1 - 使用 DeleteAsync
//建立 HttpClient
HttpClient client = new HttpClient() { BaseAddress = new Uri("https://jsonbin.org/yowko/") };
// 指定 authorization header
client.DefaultRequestHeaders.Add("authorization", "token {api token}");
// 發出 post 並取得結果
HttpResponseMessage response = client.DeleteAsync("test/_perms").GetAwaiter().GetResult();
// 將回應結果內容取出並轉為 string 再透過 linqpad 輸出
response.Content.ReadAsStringAsync().GetAwaiter().GetResult().Dump();

寫法 2 - 使用 SendAsync
// 建立 HttpClient
HttpClient client = new HttpClient();

// 指定 base url 
client.BaseAddress = new Uri("https://jsonbin.org/");
// 指定 authorization header
client.DefaultRequestHeaders.Add("authorization", "token {api token}");
// 指定 request 的 method 與 detail url
HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Delete, "yowko/test/_perms");
// 發出 post 並將回應內容轉為 string 再透過 linqpad 輸出
await client.SendAsync(request)
.ContinueWith(responseTask =>
{
    responseTask.GetAwaiter().GetResult().Content.ReadAsStringAsync().Dump();
});

PATCH
HttpClient 沒有專屬 PATCH 的用法，請參考 PUT

7. 使用 proxy
有時候程式的 host 環境無法直接上網或是我們想要確認傳出去的相關資訊，就需要設定 proxy

// 建立 HttpClientHandler
	HttpClientHandler handler = new HttpClientHandler()
	{
		// 指定 proxy uri
		Proxy = new WebProxy("http://127.0.0.1:8888"),
		// 指定 proxy Credentials
		Credentials = new NetworkCredential("{username}", "{password}"),
		// 使用 proxy
		UseProxy = true,
	};
	//建立 HttpClient
	HttpClient client = new HttpClient(handler) { BaseAddress = new Uri("https://jsonbin.org/yowko/") };

	// 指定 authorization header
	client.DefaultRequestHeaders.Add("authorization", "token {api token}");
	// 準備寫入的 data
	PostData postData = new PostData() { userId = 1, title = "yowko1", body = "yowko test body 中文" };
	// 將 data 轉為 json
	string json = JsonConvert.SerializeObject(postData);
	// 將轉為 string 的 json 依編碼並指定 content type 存為 httpcontent
	HttpContent contentPost = new StringContent(json, Encoding.UTF8, "application/json");
	// 發出 post 並取得結果
	HttpResponseMessage response = await client.PostAsync("test", contentPost);
	// 將回應結果內容取出並轉為 string 再透過 linqpad 輸出
	response.Content.ReadAsStringAsync().GetAwaiter().GetResult().Dump();
	
	

----------
20190711

https://blog.yowko.com/webrequest-and-httpwebrequest/
https://blog.yowko.com/webclient/
https://blog.yowko.com/httpclient/


1. .NET 4.5 以下 使用WebClient

https://docs.microsoft.com/en-us/dotnet/api/system.net.http.httpclient?view=netframework-4.7.2

HttpClient:
1. .NET 4.5以上支援.

2. 支援 DNS 解析快取、Cookie / 身分驗證設定，可同時發送多個 Request、基於 HttpWebRequest/HttpWebResponse(易於測試）、 IO 相關方法均採非同步等優點，缺點是不支援 FTP

3. 使用時, 不建議呼叫完畢立刻 dispose 釋放資源, 而應採用共用的方式. 原因是底層沒有實作(Connection Pool)的機制, 若重複socket連線時, 則每個socket連線在 dispose 之後, 會以 TIME_WAIT 狀態繼續存活 240 秒才被真的釋放. 當殘留連線數量龐大時，除了消耗記憶體資源，甚至可能用光可用 Socket Port 號碼，導致無法再建立新連線, 因此建議應該要重複使用連線.

4. 重複使用時的衍生問題:
參考如下:
https://blog.yowko.com/httpclient-not-respect-dns-change/
共用靜態 HttpClient 可共用連線避免 TIME_WAIT 連線殘留，但這也衍生新問題 - 當 HttpClient 使用 xxx.yyy.zzz DNS 名稱連上網站，它會記憶 DNS 解析結果，但因缺乏失效機制快取將永久有效，若 DNS 記錄修改，必須重新啟動程序才會重新解析 DNS 取得新 IP。 在一些實務情境，程式可沒法說重啟就重啟，針對此有個簡單解法是對特定網站指定 ConnectionLeaseTimeout，強迫 .NET 在一段時間後關閉連線，下次重建連線將可重新解析 DNS。
var sp = ServicePointManager.FindServicePoint(new Uri("http://xxx.yyy.zzz"));
sp.ConnectionLeaseTimeout = 600*1000; // 10分鐘

實務應用上，若 HttpClient 用於 Web API 客戶端，Web API URL 是固定的，可在 HttpClient 建構時一併指定 ConnectionLeaseTimeout；若為動態傳入 URL 參數，則需每次存取網站前針對該 URL 設定。除此之外，還有 Dispose HttpClient、指定 HttpClient.DefaultRequestHeaders.ConnectionClose = true 等做法，也可克服 HttpClient 不反映 DNS 異動問題。延伸閱讀：HttpClient 無法反應 DNS 異動的解決方式

5. 若為(ASP.NET Core 2.1 / .NET 4.6)以上, 則改用 HttpClientFactory. 
藉由 Connection Pool 機制一舉改善重複使用問題。詳情可參考 Yowko 的文章：在 .NET Core 與 .NET Framework 上使用 HttpClientFactory
ref:
https://blog.yowko.com/httpclientfactory-dotnet-core-dotnet-framework/

NET Core 因已預設參考 Microsoft.AspNetCore.App 的 metapackage，已內建 Microsoft.Extensions.Http plugin，故無須額外安裝套件

.NET Framework 需另外安裝 Microsoft.Extensions.Http NuGet 套件


WebClient:
1. .NET 4.5以上建議不再使用, 建議改用 System.Net.Http.HttpClient
2. 使用時採隨用隨建，用完即拋策略就對了，每次建立 WebClient 都會開新連線