GVKun编程网logo

测试CSS兼容性：HttpClientFactory 使用说明 及 对 HttpClient 的回顾和对比（css兼容性问题汇总）

20

如果您想了解测试CSS兼容性：HttpClientFactory使用说明及对HttpClient的回顾和对比的相关知识，那么本文是一篇不可错过的文章，我们将对css兼容性问题汇总进行全面详尽的解释，并

如果您想了解测试CSS兼容性：HttpClientFactory 使用说明 及 对 HttpClient 的回顾和对比的相关知识，那么本文是一篇不可错过的文章，我们将对css兼容性问题汇总进行全面详尽的解释，并且为您提供关于.net core 中使用 httpclient,HttpClientFactory 的问题、.net Core 使用IHttpClientFactory请求、.net Core 使用IHttpClientFactory请求实现、.Net Core下HTTP请求IHttpClientFactory示例详解的有价值的信息。

本文目录一览：

测试CSS兼容性：HttpClientFactory 使用说明 及 对 HttpClient 的回顾和对比（css兼容性问题汇总）

测试CSS兼容性：HttpClientFactory 使用说明 及 对 HttpClient 的回顾和对比（css兼容性问题汇总）

目录

  • HttpClient 日常使用及坑点：
    • HttpClientFactory 优势：
  • HttpClientFactory 使用方法：
    • 实战用法1：常规用法
      • 1. 在 Startup.cs 中进行注册
      • 2. 使用，这里直接以 controller 为例，其他地方自行 DI
    • 实战用法2：使用自定义类执行 HttpClientFactory 请求
      • 1. 自定义 HttpClientFactory 请求类
      • 2. 在 Startup.cs 中 ConfigureService 方法中注册 SampleClient，代码如下，
      • 3. 调用：
    • 实战用法3：完全封装 HttpClient 可以使用下面方法
      • 1. 自定义 HttpClientFactory 请求类
      • 2. 在 Startup.cs 中 ConfigureService 方法中注册 SampleClient，代码如下，
      • 3. 调用：

HttpClient 日常使用及坑点：

在 C# 中，平时我们在使用 HttpClient 的时候，会将 HttpClient 包裹在 using 内部进行声明和初始化，如：

using(var httpClient = new HttpClient())
{
    //other codes
}

至于为什么？无外乎是：项目代码中就是这样写的，依葫芦画瓢/别人就是这样用的/在微软官方的 ASP.NET 教程中也是这么干的。

说的技术范点：当你使用继承了 Idisposable 接口的对象时，建议在 using 代码块中声明和初始化，当 using 代码段执行完成后，会自动释放该对象而不需要手动进行显示 dispose 操作。

但这里，HttpClient 这个对象有点特殊，虽然继承了 Idisposable 接口，但它是可以被共享的（或者说可以被复用），且线程安全。从项目经验来看，倒是建议在整个应用的生命周期内，复用 HttpClient 实例，而不是每次 RPC 请求的时候就实例化一个。（之前在优化公司一个 web 项目的时候，也曾经因为 HttpClient 载过一次坑，后面我会进行简述。）

我们先来用个简单的例子做下测试，看为什么不要每次 RPC 请求都实例化一个 HttpClient：

public class Program
    {
        static void Main(string[] args)
        {
            HttpAsync();
            Console.WriteLine("Hello World!");
            Console.Read();
        }

        public static async void HttpAsync()
        {
            for (int i = 0; i < 10; i++)
            {
                using (var client = new HttpClient())
                {
                    var result = await client.GetAsync("http://www.baidu.com");
                    Console.WriteLine($"{i}:{result.StatusCode}");
                }
            }
        }
    }

运行项目输出结果后，通过 netstate 查看下 TCP 连接情况：

e92bde19-eae0-41a4-83ed-08c2038fdd0f.png

  • 虽然项目已经运行结束，但是连接依然存在，状态为 "TIME_WAIT"（继续等待看是否还有延迟的包会传输过来。）。

    默认在 windows 下，TIME_WAIT 状态将会使系统将会保持该连接 240s。

  • 这里也就引出了我上面说的载过的一次坑：在高并发的情况下，连接来不及释放，socket 被耗尽，耗尽之后就会出现喜闻乐见的一个错误：

#使用jemter压测复现错误信息：
Unable to connect to the Remote ServerSystem.Net.sockets.socketException: Only one usage of each socket address (protocol/network address/port) is normally permitted.

说白话：就是会出现“各种套接字问题”。（码WCF的童鞋可能更加记忆尤新，问题追根溯源都是换汤不换药。）

熊厂里面能够搜索出来的解决方法，基本都是“减少超时时间”，但人为减少了超时时间会出现各种莫名其妙的错误。且无法避免服务器迟早崩溃的问题。

可以通过注册表进行修改默认值：[HKEY_LOCAL_MACHINE\SYstem\CurrentControlSet\Services\Tcpip\Parameters\TcpTimedWaitDelay]）

那么如何处理这个问题？答案已经在上面说了，“复用 HttpClient”即可。如：

public class Program
    {
        private static readonly HttpClient _client = new HttpClient();
        static void Main(string[] args)
        {
            HttpAsync();
            Console.WriteLine("Hello World!");
            Console.Read();
        }

        public static async void HttpAsync()
        {
            for (int i = 0; i < 10; i++)
            {
                var result = await _client.GetAsync("http://www.baidu.com");
                Console.WriteLine($"{i}:{result.StatusCode}");
            }
        }
    }

232f7b9e-b9f3-4444-9697-e0108c3b09fe.png

  • 可以看到，原先 10 个连接变成了 1 个连接。（请不要在意两次示例的目标 IP 不同---SLB 导致的，都是百度的ip）

  • 另外，因为复用了 HttpClient，每次 RPC 请求的时候，实际上还节约了创建通道的时间，在性能压测的时候也是很明显的提升。曾经因为这一举动，将 web 项目的 TPS 从单台 600 瞬间提升到了 2000+，页面请求时间也从 1-3s 减少至 100-300ms，甚是让测试组小伙伴膜拜（当然也包括了一些业务代码的细调。），但知道个中缘由后，一个小改动带来的项目性能提升。。。会让人上瘾：）

  • 至于如何创建一个静态 HttpClient 进行复用，大家可以按项目实际来，如直接创建一个“全局”静态对象，或者通过各类 DI 框架来创建均可。

但这么调整 HttpClient 的引用后，依然存在一些问题可能会影响到你的项目（尚未影响到我:P），如：

  • 因为是复用的 HttpClient，那么一些公共的设置就没办法灵活的调整了，如请求头的自定义。
  • 因为 HttpClient 请求每个 url 时，会缓存该url对应的主机 ip，从而会导致 DNS 更新失效（TTL 失效了）

那么有没有办法解决 HttpClient 的这些个问题？直到我遇到了 HttpClientFactory，瞬间写代码幸福感倍升，也感慨新时代的童鞋们真的太幸福了，老一辈踩的坑可以“完美”规避掉了。

HttpClientFactory 优势：

HttpClientFactory 是 ASP.NET CORE 2.1 中新增加的功能。

  • “完美”解决了我多年来遇到的这些坑，可以更加专注于业务代码。
  • HttpClientFacotry 很高效，可以最大程度上节省系统 socket。（“JUST USE IT AND FXXK SHUT UP”:P）

  • Factory，顾名思义 HttpClientFactory 就是 HttpClient 的工厂，内部已经帮我们处理好了对 HttpClient 的管理，不需要我们人工进行对象释放，同时，支持自定义请求头，支持 DNS 更新等等等。

    从微软源码分析，HttpClient 继承自 HttpMessageInvoker，而 HttpMessageInvoker 实质就是httpclienthandler。

    HttpClientFactory 创建的 HttpClient，也即是 httpclienthandler，只是这些个 HttpClient 被放到了“池子”中，工厂每次在 create 的时候会自动判断是新建还是复用。(默认生命周期为 2min)

    还理解不了的话，可以参考 Task 和 Thread 的关系，以前碰到 HttpClient 这个问题的时候，就一直在想微软什么时候官方出一个 HttpClient 的 Factory，虽然时隔了这么多年直到 .NET CORE 2.1 才出，但也很是兴奋。

HttpClientFactory 使用方法：

借助 ASP.NET CORE MVC，可以很方便的进行 HttpClient 的使用

实战用法1：常规用法

统一在发布项目中声明和配置。

1. 在 Startup.cs 中进行注册

public class Startup
    {
        public Startup(IConfiguration configuration)
        {
            Configuration = configuration;
        }

        public IConfiguration Configuration { get; }

        // This method gets called by the runtime. Use this method to add services to the container.
        public void ConfigureServices(IServiceCollection services)
        {
            //other codes
            
            services.AddHttpClient("client_1",config=>  //这里指定的name=client_1，可以方便我们后期服用该实例
            {
                config.BaseAddress= new Uri("http://client_1.com");
                config.DefaultRequestHeaders.Add("header_1","header_1");
            });
            services.AddHttpClient("client_2",config=>
            {
                config.BaseAddress= new Uri("http://client_2.com");
                config.DefaultRequestHeaders.Add("header_2","header_2");
            });
            services.AddHttpClient();

            //other codes
            services.AddMvc().AddFluentValidation();
        }
      }

2. 使用，这里直接以 controller 为例，其他地方自行 DI

public class TestController : ControllerBase
    {
        private readonly IHttpClientFactory _httpClient;
        public TestController(IHttpClientFactory httpClient)
        {
            _httpClient = httpClient;
        }

        public async Task<ActionResult> test()
        {
            var client = _httpClient.CreateClient("client_1"); //复用在Startup中定义的client_1的httpclient
            var result = await client.GetStringAsync("/page1.html");

            var client2 = _httpClient.CreateClient(); //新建一个HttpClient
            var result2 = await client.GetStringAsync("http://www.site.com/XXX.html");

            return null;
        }
    }

实战用法2：使用自定义类执行 HttpClientFactory 请求

1. 自定义 HttpClientFactory 请求类

public class SampleClient
{
    public HttpClient Client { get; private set; }
    
    public SampleClient(HttpClient httpClient)
    {
        httpClient.BaseAddress = new Uri("https://api.SampleClient.com/");
        httpClient.DefaultRequestHeaders.Add("Accept","application/json");
        httpClient.DefaultRequestHeaders.Add("User-Agent","HttpClientFactory-Sample");
        Client = httpClient;
    }
}

2. 在 Startup.cs 中 ConfigureService 方法中注册 SampleClient，代码如下，

services.AddHttpClient<SampleClient>();

3. 调用：

public class ValuesController : Controller
{
    private readonly SampleClient  _sampleClient;;
  
    public ValuesController(SampleClient  sampleClient)
    {
        _sampleClient = sampleClient;
    }
  
    [HttpGet]
    public async Task<ActionResult> Get()
    {
        string result = await  _sampleClient.client.GetStringAsync("/");
        return Ok(result);
    }
}

实战用法3：完全封装 HttpClient 可以使用下面方法

1. 自定义 HttpClientFactory 请求类

public interface ISampleClient
{
    Task<string> GetData();
}
 
public class SampleClient : ISampleClient
{
    private readonly HttpClient _client;
 
    public SampleClient(HttpClient httpClient)
    {
        httpClient.BaseAddress = new Uri("https://api.SampleClient.com/");
        httpClient.DefaultRequestHeaders.Add("Accept","HttpClientFactory-Sample");
        _client = httpClient;
    }
 
    public async Task<string> GetData()
    {
        return await _client.GetStringAsync("/");
    }
}

2. 在 Startup.cs 中 ConfigureService 方法中注册 SampleClient，代码如下，

services.AddHttpClient<ISampleClient,SampleClient>();

3. 调用：

public class ValuesController : Controller
{
    private readonly ISampleClient  _sampleClient;;
     
    public ValuesController(ISampleClient  sampleClient)
    {
        _sampleClient = sampleClient;
    }
     
    [HttpGet]
    public async Task<ActionResult> Get()
    {
        string result = await _sampleClient.GetData();
        return Ok(result);
    }
}

.net core 中使用 httpclient,HttpClientFactory 的问题

.net core 中使用 httpclient,HttpClientFactory 的问题

Microsoft 在.Net Framework 4.5 中引入了 HttpClient，并且是在.NET 服务器端代码中使用 Web API 的最常用方法。但它有一些严重的问题，如释放 HttpClient 对象不立即关闭套接字，太多实例影响性能和单个的 HttpClient 或共享 HttpClient 实例不尊重 DNS 生存时间（TTL）设置。当并没有大批量或者并发调用时，选择 HttpClient 还行：

private static readonly HttpClient HttpClient = new HttpClient();//定义




 var res = await HttpClient.GetStringAsync(url);//调用

　.net core 2.1 引入了 HttpClientFactory 的一些问题，当高并发时可以使用 HttpClientFactory，例子链接里有，我只介绍一个在类库中使用方法：

1. 类库中建封装类：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Net.Http;
using System.Threading.Tasks;

namespace Oss.Utils
{
    public class HttpClientFactory
    {
        public HttpClient Client { get; private set; }

        public HttpClientFactory(HttpClient httpClient)
        {

                           httpClient.BaseAddress = new Uri("https://api.github.com/");
                          httpClient.DefaultRequestHeaders.Add("Accept", "application/vnd.github.v3+json");
                          httpClient.DefaultRequestHeaders.Add("User-Agent", "HttpClientFactory-Sample");
                          httpClient.Timeout = TimeSpan.FromSeconds(60);
                         Client = httpClient;

}
    }
}

2. 其他类中调用就好了:

private static readonly HttpClient HttpClient = new HttpClient();
  private static readonly HttpClientFactory HttpClientFactory = new HttpClientFactory(HttpClient);
...
...
...


var res = await HttpClientFactory.Client.GetStringAsync(url);

okay，调用完成。

说明一下：在.net core 项目中使用 HttpClientFactory 的时候，要是在 Startup.cs 注册时，要安装:

Microsoft.Extensions.Http   nuget 包，

直接搜索即可。

具体使用方法和参考链接如下:https://www.cjavapy.com/article/150/

.net Core 使用IHttpClientFactory请求

.net Core 使用IHttpClientFactory请求

        导读：本文已添加在晨曦微服务之旅，现在自己在尝试微服务架构，一边学边做项目快速的进入状态。当然在学习的过程中会将自己学到的知识进行分享。

一、为什么不用HttpClient

        1.HttPClient使用完之后不会立即关闭开启网络连接时会占用底层socket资源，但在HttpClient调用其本身的Dispose方法时，并不能立刻释放该资源

         2.如果频繁的使用HttpClient,频繁的打开链接，关闭链接消耗就会很大。

二、解决方案

        1.我们可以延长HttpClient的生命周期，比如对其建一个静态的对象

private static HttpClient Client = new HttpClient();

          2.或者使用单例模式，至于你使用哪一种单例模式就看你自己了，这里就不细将了。因为这样感觉起来不是很舒服

三、HttpClientFactory

       1.在.NET Core 2.1版本之后引入的 HttpClientFactory解决了HttpClient的所有痛点。有了 HttpClientFactory，我们不需要关心如何创建HttpClient，又如何释放它。通过它可以创建具有特定业务的HttpClient，而且可以很友好的和 DI 容器结合使用，更为灵活。

　　  2.HttpClientFactory 创建的HttpClient，也即是HttpClientHandler，只是这些个HttpClient被放到了“池子”中，工厂每次在create的时候会自动判断是新建还是复用。(默认生命周期为2min，默认的生命周期可以修改） 
   //修改默认的生命周期
   services.AddHttpClient()
  .SetHandlerLifetime(TimeSpan.FromMinutes(5));

四、HttpClientFactory的使用 

    一、第一种使用方式

  1. 在Startup.cs中进行注册 
    //注册http请求服务
            services.AddHttpClient();

         2.Httphelper请求辅助类中使用

/// <summary>
        /// 注入http请求
        /// </summary>
        private readonly IHttpClientFactory httpClientFactory;
        public HttpHelp(IHttpClientFactory _httpClientFactory)
        {
            httpClientFactory = _httpClientFactory;
        }

        // <summary>
        // Get请求数据
        // <para>最终以url参数的方式提交</para>
        // </summary>
        // <param name="parameters">参数字典,可为空</param>
        // <param name="requestUri">例如/api/Files/UploadFile</param>
        // <returns></returns>
        public async Task<string> Get(Dictionary<string, string> parameters, string requestUri, string token)
        {
            //从工厂获取请求对象
            var client = httpClientFactory.CreateClient();
            //添加请求头
            if (!string.IsNullOrWhiteSpace(token))
            {
                client.DefaultRequestHeaders.Add("Authorization", "Bearer " + token);
            }
            client.DefaultRequestHeaders.Add("Content-Type", "application/json; charset=utf-8");
            //拼接地址
            if (parameters != null)
            {
                var strParam = string.Join("&", parameters.Select(o => o.Key + "=" + o.Value));
                requestUri = string.Concat(requestUri, ''?'', strParam);
            }
            client.BaseAddress = new Uri(requestUri);
            return client.GetStringAsync(requestUri).Result;
        }

             3.然后我们在Startup.cs对相对的类进行注册就可以了使用了。

      二、使用命名客户端

　　　  1.在Startup.cs中进行注册，这个注册可以存在多个。以创建名字区分

services.AddHttpClient("github", c =>
{
    c.BaseAddress = new Uri("https://xxxxxxx.com/");
    // Github API versioning
    c.DefaultRequestHeaders.Add("Content-Type", "application/json; charset=utf-8");
    // Github requires a user-agent
    c.DefaultRequestHeaders.Add("Authorization", "asfasfasdsgdsfsdfsdafasfas");
});

           2.使用方式和上面的一样只要

/// <summary>
        /// 注入http请求
        /// </summary>
        private readonly IHttpClientFactory httpClientFactory;
        public HttpHelp(IHttpClientFactory _httpClientFactory)
        {
            httpClientFactory = _httpClientFactory;
        }

        // <summary>
        // Get请求数据
        // <para>最终以url参数的方式提交</para>
        // </summary>
        // <param name="parameters">参数字典,可为空</param>
        // <param name="requestUri">例如/api/Files/UploadFile</param>
        // <returns></returns>
        public async Task<string> Get(Dictionary<string, string> parameters, string requestUri, string token)
        {
            //从工厂获取请求对象   声明自己创建哪一个httpClient客户端
            var client = httpClientFactory.CreateClient("github");
            //添加请求头
            if (!string.IsNullOrWhiteSpace(token))
            {
                client.DefaultRequestHeaders.Add("Authorization", "Bearer " + token);
            }
            client.DefaultRequestHeaders.Add("Content-Type", "application/json; charset=utf-8");
            //拼接地址
            if (parameters != null)
            {
                var strParam = string.Join("&", parameters.Select(o => o.Key + "=" + o.Value));
                requestUri = string.Concat(requestUri, ''?'', strParam);
            }
            client.BaseAddress = new Uri(requestUri);
            return client.GetStringAsync(requestUri).Result;
        }

         三、类型化客户端

           1.创建一个类

public class HttpClienService
{
    public HttpClient Client { get; }
    public HttpClienService(HttpClient client)
    {
        client.BaseAddress = new Uri("https://xxxx.com/");
        // GitHub API versioning
        client.DefaultRequestHeaders.Add("Authorization",
            "xxxxxxxxxxxx");
        // GitHub requires a user-agent
        client.DefaultRequestHeaders.Add("Content-Type",
            "application/json; charset=utf-8");
        Client = client;
    }

    //这个下面就是编写自己方法，进行调用
}

             2.在Startup.cs中进行注册，这个注册可以存在多个。

services.AddHttpClient<classHttp>();
//注册之后，使用依赖注入的方式进行注入，进行使用。

原文出处：https://www.cnblogs.com/chenxi001/p/12203731.html

.net Core 使用IHttpClientFactory请求实现

.net Core 使用IHttpClientFactory请求实现

     导读：本文已添加在 晨曦微服务之旅 ，现在自己在尝试微服务架构，一边学边做项目快速的进入状态。当然在学习的过程中会将自己学到的知识进行分享。

一、为什么不用HttpClient

        1.HttPClient使用完之后不会立即关闭开启网络连接时会占用底层socket资源，但在HttpClient调用其本身的Dispose方法时，并不能立刻释放该资源

2.如果频繁的使用HttpClient,频繁的打开链接，关闭链接消耗就会很大。

二、解决方案

        1.我们可以延长HttpClient的生命周期，比如对其建一个静态的对象

private static HttpClient Client = new HttpClient();

2.或者使用单例模式，至于你使用哪一种单例模式就看你自己了，这里就不细将了。因为这样感觉起来不是很舒服

三、HttpClientFactory

        1.在.NET Core 2.1版本之后引入的 HttpClientFactory解决了HttpClient的所有痛点。有了 HttpClientFactory，我们不需要关心如何创建HttpClient，又如何释放它。通过它可以创建具有特定业务的HttpClient，而且可以很友好的和 DI 容器结合使用，更为灵活。

2.HttpClientFactory 创建的HttpClient，也即是HttpClientHandler，只是这些个HttpClient被放到了“池子”中，工厂每次在create的时候会自动判断是新建还是复用。(默认生命周期为2min，默认的生命周期可以修改）

  //修改默认的生命周期
  services.AddHttpClient()
 .SetHandlerLifetime(TimeSpan.FromMinutes(5));

四、HttpClientFactory的使用

一、第一种使用方式

在Startup.cs中进行注册

 //注册http请求服务
 services.AddHttpClient();

2.Httphelper请求辅助类中使用

/// <summary>
    /// 注入http请求
    /// </summary>
    private readonly IHttpClientFactory httpClientFactory;
    public HttpHelp(IHttpClientFactory _httpClientFactory)
    {
      httpClientFactory = _httpClientFactory;
    }

    // <summary>
    // Get请求数据
    // <para>最终以url参数的方式提交</para>
    // </summary>
    // <param name="parameters">参数字典,可为空</param>
    // <param name="requestUri">例如/api/Files/UploadFile</param>
    // <returns></returns>
    public async Task<string> Get(Dictionary<string, string> parameters, string requestUri, string token)
    {
      //从工厂获取请求对象
      var client = httpClientFactory.CreateClient();
      //添加请求头
      if (!string.IsNullOrWhiteSpace(token))
      {
        client.DefaultRequestHeaders.Add("Authorization", "Bearer " + token);
      }
      client.DefaultRequestHeaders.Add("Content-Type", "application/json; charset=utf-8");
      //拼接地址
      if (parameters != null)
      {
        var strParam = string.Join("&", parameters.Select(o => o.Key + "=" + o.Value));
        requestUri = string.Concat(requestUri, ''?'', strParam);
      }
      client.BaseAddress = new Uri(requestUri);
      return client.GetStringAsync(requestUri).Result;
    }

3.然后我们在Startup.cs对相对的类进行注册就可以了使用了。

二、使用命名客户端

1.在Startup.cs中进行注册， 这个注册可以存在多个 。以创建名字区分

services.AddHttpClient("github", c =>
{
  c.BaseAddress = new Uri("https://xxxxxxx.com/");
  // Github API versioning
  c.DefaultRequestHeaders.Add("Content-Type", "application/json; charset=utf-8");
  // Github requires a user-agent
  c.DefaultRequestHeaders.Add("Authorization", "asfasfasdsgdsfsdfsdafasfas");
});

2.使用方式和上面的一样只要

/// <summary>
    /// 注入http请求
    /// </summary>
    private readonly IHttpClientFactory httpClientFactory;
    public HttpHelp(IHttpClientFactory _httpClientFactory)
    {
      httpClientFactory = _httpClientFactory;
    }

    // <summary>
    // Get请求数据
    // <para>最终以url参数的方式提交</para>
    // </summary>
    // <param name="parameters">参数字典,可为空</param>
    // <param name="requestUri">例如/api/Files/UploadFile</param>
    // <returns></returns>
    public async Task<string> Get(Dictionary<string, string> parameters, string requestUri, string token)
    {
      //从工厂获取请求对象  声明自己创建哪一个httpClient客户端
      var client = httpClientFactory.CreateClient("github");
      //添加请求头
      if (!string.IsNullOrWhiteSpace(token))
      {
        client.DefaultRequestHeaders.Add("Authorization", "Bearer " + token);
      }
      client.DefaultRequestHeaders.Add("Content-Type", "application/json; charset=utf-8");
      //拼接地址
      if (parameters != null)
      {
        var strParam = string.Join("&", parameters.Select(o => o.Key + "=" + o.Value));
        requestUri = string.Concat(requestUri, ''?'', strParam);
      }
      client.BaseAddress = new Uri(requestUri);
      return client.GetStringAsync(requestUri).Result;
    }

三、类型化客户端

1.创建一个类

public class HttpClienService
{
  public HttpClient Client { get; }
  public HttpClienService(HttpClient client)
  {
    client.BaseAddress = new Uri("https://xxxx.com/");
    // GitHub API versioning
    client.DefaultRequestHeaders.Add("Authorization",
      "xxxxxxxxxxxx");
    // GitHub requires a user-agent
    client.DefaultRequestHeaders.Add("Content-Type",
      "application/json; charset=utf-8");
    Client = client;
  }

  //这个下面就是编写自己方法，进行调用
}

2.在Startup.cs中进行注册， 这个注册可以存在多个。

services.AddHttpClient<classHttp>();
//注册之后，使用依赖注入的方式进行注入，进行使用。

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持。

您可能感兴趣的文章:
  • asp.net core为IHttpClientFactory添加动态命名配置
  • 详解如何在ASP.NET Core中使用IHttpClientFactory
  • .Net Core下HTTP请求IHttpClientFactory示例详解
  • ASP.NET Core使用IHttpClientFactory发出HTTP请求

.Net Core下HTTP请求IHttpClientFactory示例详解

.Net Core下HTTP请求IHttpClientFactory示例详解

使用方式

IHttpClientFactory有四种模式：

  • 基本用法
  • 命名客户端
  • 类型化客户端
  • 生成的客户端

基本用法

在 Startup.ConfigureServices 方法中，通过在 IServiceCollection 上调用 AddHttpClient 扩展方法可以注册 IHttpClientFactory

services.AddHttpClient();

注册之后可以像依赖注入DI似得在类中通过构造函数注入形式使用，伪代码：

class A
{
 private readonly IHttpClientFactory _clientFactory;
 public A(IHttpClientFactory clientFactory)
 {
  _clientFactory = clientFactory;
 }
 
 Public void Use()
 {
   var request=new HttpRequestMessage(HttpMethod.Get,"www.baidu.com") ;
   var client = _clientFactory.CreateClient();
   var response = await client.SendAsync(request); 
   if (response.IsSuccessStatusCode)
   {
   Branches = await response.Content.ReadAsAsync<IEnumerable<GitHubBranch>>();
   }
  else
  {
   GetBranchesError = true;
   Branches = Array.Empty<GitHubBranch>();
  }  
 }
}

命名客户端

也是在基本用法的基础上增加配置参数：例如增加一个baidu下的客户端：

services.AddHttpClient("baidu",c=>
{
 c.BaseAddress = new Uri("https://api.baidu.com/");
 //其他一些参数
});

然后在使用的时候只是需要传递客户端名称就自动使用baidu这个地址的基础地址配置：

 var client = _clientFactory.CreateClient("baidu");

类型化客户端

说的明白一点就是在使用类的构造函数中可以直接接受HttpClient 类型，不用在使用IHttpClientFactory 接口的CreateClient方法创建，但是首要条件就是要先创建注入类型，然后在ConfigureServices 方法同时注入：

services.AddHttpClient<classHttp>();

注入类型：

public class classHttp
{
   public HttpClient Client { get; }
   public GitHubService(HttpClient client)
   {
      client.BaseAddress = new Uri("https://api.baidu.com/");
      //同ConfigureServices 中一样设置一些其他参数
      Client = client;
   }
}

生成的客户端

这个我个人理解为就是配置使用第三方库，然后可以注入接口类型，接口中可以写一些方法接口。然后通过接口类直接调用接口。

个人理解：就是类似于一个接口映射，地址映射似得。通过结合第三方库（官方推荐Refit）实现请求一个地址别名的方式，别名就是指定义的接口。然后别名通过增加特性Get(“路径”)或者post("路径)的形式重新指向真实的请求接口地址。通过请求这个本地接口方法实现转化请求的真实地址。

举例定义接口：

public interface IHelloClient
{
  [Get("/MyInterFace")]
  Task<Reply> GetMessageAsync();
}

配置Refit插件：

也是和正常配置类似，在后面增加接口的服务注入。

public void ConfigureServices(IServiceCollection services)
{
  services.AddHttpClient("hello", c =>
  {
    c.BaseAddress = new Uri("http://localhost:5000");
  })
  .AddTypedClient(c => Refit.RestService.For<IHelloClient>(c));

  services.AddMvc();
}

然后再说接口上面的Get("/MyInterFace")方法;这个我们就不做另一个项目就在当前项目下，所以可以直接就在api项目下创建一个名为MyInterFace的方法。

[ApiController]
public class TestController : ControllerBase
{
   [HttpGet("/")]
  public async Task<sting> MyInterFace()
  {
    return "ceshi";
  }
}

然后就可以使用接口了：

[ApiController]
public class ValuesController : ControllerBase
{
  private readonly IHelloClient _client;

  public ValuesController(IHelloClient client)
  {
    _client = client;
  }

  [HttpGet("/")]
  public async Task<ActionResult<Reply>> Index()
  {
    return await _client.GetMessageAsync();
  }
}

在这了的_client.GetMessageAsync()方法就是调用了接口方法，看着是调用了GetMessageAsync方法其实是做了映射，映射地址就是上面特性写的MyInterFace方法。通过断点也可以验证此结论。然后不同项目下也是同一个意思，假如我们请求百度的地址：www.baidu.com/api/b这个接口

我们在配置出把请求地址http://localhost:5000改为www.baidu.com/api，然后再把GetMessageAsync方法上面的MyInterFace改为b即可。

出站请求中间件

个人理解为请求返回前处理程序，就是继承 DelegatingHandler派生类重写SendAsync 方法。在将请求传递至管道中的下一个处理程序之前执行代码：

public class ValidateHeaderHandler : DelegatingHandler
{
  protected override async Task<HttpResponseMessage> SendAsync(
    HttpRequestMessage request,
    CancellationToken cancellationToken)
  {
    if (!request.Headers.Contains("X-API-KEY"))
    {
      return new HttpResponseMessage(HttpStatusCode.BadRequest)
      {
        Content = new StringContent(
          "You must supply an API key header called X-API-KEY")
      };
    }

    return await base.SendAsync(request, cancellationToken);
  }
}

然后在ConfigureServices中：

services.AddTransient<ValidateHeaderHandler>();//注册处理程序
services.AddHttpClient("externalservice", c =>
{
  // Assume this is an "external" service which requires an API KEY
  c.BaseAddress = new Uri("https://localhost:5000/");
})
.AddHttpMessageHandler<ValidateHeaderHandler>();/注入到http请求管道

可以同时注册多个处理程序。

HttpClient和生存周期

每次对 IHttpClientFactory 调用 CreateClient 都会返回一个新 HttpClient 实例。 每个命名的客户端都具有一个 HttpMessageHandler。 工厂管理 HttpMessageHandler 实例的生存期。

 HttpClient实例不是与HttpMessageHandler一起销毁的，HttpMessageHandler在池中生存，如果生命周期未到不会被销毁，会被新的HttpClient 实例使用。

处理程序的默认生存周期是2分钟，可以通过配置修改：

services.AddHttpClient("extendedhandlerlifetime")
  .SetHandlerLifetime(TimeSpan.FromMinutes(5));

总结

以上就是这篇文章的全部内容了，希望本文的内容对大家的学习或者工作具有一定的参考学习价值，谢谢大家对的支持。

您可能感兴趣的文章:
  • asp.net core为IHttpClientFactory添加动态命名配置
  • 详解如何在ASP.NET Core中使用IHttpClientFactory
  • .net Core 使用IHttpClientFactory请求实现
  • ASP.NET Core使用IHttpClientFactory发出HTTP请求

关于测试CSS兼容性：HttpClientFactory 使用说明 及 对 HttpClient 的回顾和对比和css兼容性问题汇总的问题就给大家分享到这里，感谢你花时间阅读本站内容，更多关于.net core 中使用 httpclient,HttpClientFactory 的问题、.net Core 使用IHttpClientFactory请求、.net Core 使用IHttpClientFactory请求实现、.Net Core下HTTP请求IHttpClientFactory示例详解等相关知识的信息别忘了在本站进行查找喔。

本文标签：

上一篇什么是最好的CSS技巧,以减少您需要多少HTML？

下一篇css – 必须在中途切换HTML人员（css页面切换）

相关文章