.NET HttpClient 二次封装

已于 2024-01-05 14:05:35 修改
阅读量399 收藏 7
点赞数 7
分类专栏： c# 反射 特性 文章标签： .net 前端 c# .netcore
于 2024-01-05 14:03:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46193339/article/details/135408065
版权
c# 同时被 3 个专栏收录
4 篇文章 0 订阅
订阅专栏
反射
2 篇文章 0 订阅
订阅专栏
特性
2 篇文章 0 订阅
订阅专栏

1. 创建请求类型特性

/// <summary>
/// 
/// </summary>
[AttributeUsage(AttributeTargets.Method, AllowMultiple = false)]
public class PostAttribute : Attribute
{
    public PostAttribute(string url)
    {

        Url = url;

    }

    public string Url { get; set; }
}


[AttributeUsage(AttributeTargets.Method, AllowMultiple = false)]
public class GetAttribute : Attribute
{
    public GetAttribute(string url)
    {

        Url = url;

    }

    public string Url { get; set; }
}


[AttributeUsage(AttributeTargets.Method, AllowMultiple = false)]
public class DeleteAttribute : Attribute
{
    public DeleteAttribute(string url)
    {

        Url = url;

    }

    public string Url { get; set; }
}


[AttributeUsage(AttributeTargets.Method, AllowMultiple = false)]
public class PutAttribute : Attribute
{
    public PutAttribute(string url)
    {

        Url = url;

    }

    public string Url { get; set; }
}

2. 创建参数类型特性

 [AttributeUsage(AttributeTargets.Parameter, AllowMultiple = false)]
 public class QueryAttribute : Attribute
 {
     public QueryAttribute(string source)
     {
         Source = source;
     }

     public string Source { get; set; }
 }



 [AttributeUsage(AttributeTargets.Parameter, AllowMultiple = false)]
 public class BodyAttribute : Attribute
 {
     public BodyAttribute()
     {

     }
 }


 [AttributeUsage(AttributeTargets.Parameter, AllowMultiple = false)]
 public class PathAttribute : Attribute
 {
     public PathAttribute(string source)
     {
         Source = source;
     }

     public string Source { get; set; }
 }
 [AttributeUsage(AttributeTargets.Parameter, AllowMultiple = false)]
 public class FormAttribute : Attribute
 {
 }

3. 创建一个代理
 

public class ApiClientFactory
{

    public static T CreateClient<T>() where T : class
    {

        var proxy = DispatchProxy.Create<T, ClientProxy>();
        return proxy;
    }


    public class ClientProxy : DispatchProxy
    {
        private readonly HttpClient _httpClient = HttpClientSingleton.GetFactory();

        protected override object? Invoke(MethodInfo? targetMethod, object?[]? args)
        {

            try
            {
                // 获取异步调用的结果
                var task = InvokeAsync(targetMethod, args);
                if (targetMethod?.ReturnType == typeof(Task))
                {
                    task.Wait();
                    return task;
                }
                if (targetMethod?.ReturnType == typeof(string))
                {
                    task.Wait();
                    return Convert.ToString(task.Result);
                }
                if (targetMethod?.ReturnType?.IsValueType == true)
                {
                    var returnType = targetMethod?.ReturnType;
                    task.Wait();
                    return Convert.ChangeType(task.Result, returnType!);
                }

                var resultProperty = task.GetType().GetProperty("Result");
                task.Wait(); // 确保任务完成
                var result = resultProperty?.GetValue(task);

                // 检查目标方法是否期望返回 Task<T>
                if (targetMethod?.ReturnType.IsGenericType == true &&
                    targetMethod.ReturnType.GetGenericTypeDefinition() == typeof(Task<>))
                {
                    // 获取返回类型 Task<T> 的泛型参数类型
                    var resultType = targetMethod.ReturnType.GetGenericArguments()[0];

                    if (resultType.Name == "String")
                    {
                        if (result != null)
                        {
                            return Task.FromResult(Convert.ToString(result)!);
                        }
                        else
                        {
                            return Task.FromResult<string>(null);
                        }

                    }
                    if (resultType.IsValueType)
                    {
                        Task.FromResult(Convert.ChangeType(result, resultType));
                    }


                    // 创建 Task<T> 的实例
                    var taskCompletionSource = typeof(TaskCompletionSource<>)
                        ?.MakeGenericType(resultType)
                        ?.GetConstructor(Type.EmptyTypes)
                        ?.Invoke(null);

                    typeof(TaskCompletionSource<>)
                        ?.MakeGenericType(resultType)
                        ?.GetMethod("SetResult")
                        ?.Invoke(taskCompletionSource, new[] { Convert.ChangeType(result, resultType) });

                    return typeof(TaskCompletionSource<>)
                        ?.MakeGenericType(resultType)
                        ?.GetProperty("Task")
                        ?.GetValue(taskCompletionSource);
                }

                // 对于非泛型 Task，返回原始 Task
                return task;
            }
            catch (Exception ex)
            {

                throw new Exception(ex.Message);
            }

        }

        private async Task<object?> InvokeAsync(MethodInfo? targetMethod, object[] args)
        {
            try
            {
                var get = targetMethod?.GetCustomAttribute<GetAttribute>();
                var post = targetMethod?.GetCustomAttribute<PostAttribute>();
                var delete = targetMethod?.GetCustomAttribute<DeleteAttribute>();
                var put = targetMethod?.GetCustomAttribute<PutAttribute>();

                string? url = "";
                if (get != null)
                {
                    url = get?.Url;
                }
                else if (post != null)
                {
                    url = post?.Url;
                }
                else if (delete != null)
                {
                    url = delete?.Url;
                }
                else if (put != null)
                {
                    url = put?.Url;
                }
                else
                {
                    throw new Exception("接口得请求头必须包含一个POST GET PUT DELETE 特性");
                }

                var parameters = targetMethod?.GetParameters().ToList();
                int i = 0;
                var queryBuilder = new StringBuilder();
                HttpContent? payloadContent = null;

                parameters?.ForEach(item =>
                {
                    if (item.GetCustomAttribute<PathAttribute>() is PathAttribute pathAttr)
                    {
                        url = url?.Replace($"{{{pathAttr.Source}}}", args[i].ToString());
                    }
                    else if (item.GetCustomAttribute<QueryAttribute>() is QueryAttribute queryAttr)
                    {
                        queryBuilder.AppendFormat("{0}={1}", queryAttr.Source, HttpUtility.UrlEncode(args[i].ToString()));
                        queryBuilder.Append('&');
                    }
                    else if (parameters[i].GetCustomAttribute<BodyAttribute>() is BodyAttribute)
                    {
                        payloadContent = new StringContent(JsonConvert.SerializeObject(args[i]), Encoding.UTF8, "application/json");
                    }
                    else if (parameters[i].GetCustomAttribute<FormAttribute>() is FormAttribute)
                    {
                        Dictionary<string, string> formData = new Dictionary<string, string>();
                        if (args[i] != null)
                        {
                            foreach (var property in args[i].GetType().GetProperties())
                            {
                                //公共属性添加到表单数据中
                                var value = property.GetValue(args[i]);
                                if (value != null)
                                {
                                    formData.Add(property.Name, value?.ToString() ?? "");
                                }
                            }
                        }
                        payloadContent = new FormUrlEncodedContent(formData);

                    }

                    i++;
                });

                if (queryBuilder.Length > 0)
                {
                    // 移除最后一个 '&' 字符
                    queryBuilder.Length--;
                    url = $"{url}?{queryBuilder}";
                }

                // 根据请求类型发送 HTTP 请求
                Task<HttpResponseMessage>? responseTask = null;
                responseTask = _httpClient.GetAsync(url);
                if (get != null)
                {
                    responseTask = _httpClient.GetAsync(url);
                }
                else if (post != null)
                {
                    responseTask = _httpClient.PostAsync(url, payloadContent);
                }
                else if (delete != null)
                {
                    responseTask = SendDeleteRequestWithPayloadAsync(url, payloadContent);
                }
                else if (put != null)
                {
                    responseTask = _httpClient.PutAsync(url, payloadContent);
                }
                else
                {
                    throw new Exception("接口得请求必须包含一个POST GET PUT DELETE 特性");

                }


                var response = await responseTask;
                if (response.IsSuccessStatusCode)
                {
                    response.EnsureSuccessStatusCode();
                    var responseContent = await response.Content.ReadAsStringAsync();

                    var returnType = targetMethod?.ReturnType;

                    if (returnType == typeof(Task)) return Task.CompletedTask;

                    if (returnType?.Name == "String") return responseContent;

                    if (returnType?.IsValueType == true) return Convert.ChangeType(responseContent, returnType);

                    if (returnType?.GenericTypeArguments[0].Name == "String")
                    {
                        return responseContent;
                    }
                    if (returnType == null) return null;
                    return JsonConvert.DeserializeObject(responseContent, returnType?.GenericTypeArguments[0]!);
                }
                else 
                {
                    return null;
                }
               
            }
            catch (Exception ex)
            {

                throw new Exception($"{ex.Message}");
            }

        }


        private async Task<HttpResponseMessage> SendDeleteRequestWithPayloadAsync(string? url, HttpContent? content)
        {
            var request = new HttpRequestMessage(HttpMethod.Delete, url)
            {
                Content = content
            };

            return await _httpClient.SendAsync(request);
        }

    }


}

4. 创建接口比如

 public interface IApiService
 {


     [Post("WeatherForecast/Post")]
     Task<PostTest> GetPost([Body] PostTest test);


     [Post("WeatherForecast/FromPost")]
     int GetFromPost([Form] PostTest test);

     [Post("WeatherForecast/Post/{id}/{name}")]
     Task<PostTest> GetPostPath([Path("id")] string id, [Path("name")] string name);


     [Delete("WeatherForecast/Delete")]
     Task<PostTest> GetDelete([Body]PostTest test);


     [Delete("WeatherForecast/Delete/{id}/{name}")]
     Task<PostTest> GetDelete([Path("id")] string id, [Path("name")] string name);


     [Delete("WeatherForecast/DeleteP")]
     Task<PostTest> GetDeleteP([Query("id")] string id, [Query("name")] string name);

 }

5. 调用接口
 

var apiService = ApiClientFactory.CreateClient<IApiService>();
var result = await apiService.GetDeleteP("11", "22");

var result1 = await apiService.GetDelete("11", "22");


 var a =  apiService.GetFromPost(new Scheduling.Test.PostTest() { id = "11", name = "2323" });

6. 补上获取单例得方法

public class HttpClientSingleton
{
    private static HttpClient _httpClient;
    private HttpClientSingleton()
    {

    }

    private static object o_lock = new object();

    public static HttpClient GetFactory()
    {
        if (_httpClient is null)
        {
            lock (o_lock)
            {
                if (_httpClient is null)
                {
                    HttpClientHandler clientHandler = new HttpClientHandler();
                    clientHandler.ServerCertificateCustomValidationCallback += (sender, cert, chain, sslPolicyErrors) => { return true; };
                    clientHandler.SslProtocols = SslProtocols.None;
                    _httpClient = new HttpClient(clientHandler);
                    _httpClient.BaseAddress = new Uri("http://localhost:5119/");
                }

            }
        }
        return _httpClient;
    }

}

7.代码可能有问题请谨慎使用

锤锤锤锤锤子
关注
  • 7
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
对于C#（HttpClient）方式网络请求的封装
06-28
详细说明在https://blog.csdn.net/zyf2533/article/details/118294101?spm=1001.2014.3001.5501
C# http Get/POST请求封装类
08-29
C# http Get/POST请求封装类
HttpClient封装get/post请求含json入参
qq_56967382的博客
06-06 1367
调用封装的方法带JSON入参。
HttpClient常用操作及封装工具类
rqz__的博客
07-30 1418
HttpClient 是一个用于发送 HTTP 请求和接收 HTTP 响应的类库/模块，可以用于编写客户端应用程序，通过 HTTP 与服务器进行通信。 HttpClient 提供了一组方法和类，使得发送 HTTP 请求变得简单和方便。它支持各种 HTTP 方法，例如 GET、POST、PUT、DELETE 等，并可以设置请求的头部信息、请求参数、请求体等。
HttpClient的使用与封装
憨憨小江的博客
01-25 478
封装httpclient
高性能高可用的全能httpclient方法封装
是我的温柔啊
11-21 255
废话不多说，直接干代码 一、http请求配置 /** * HttpClientConfig http请求配置 */ public class HttpClientConfig { /** * 连接时间 ms */ protected int CONNECT_TIMING_OUT = 300000; /** * 请求响应时间 ms */ protected int RESPONSE_TIMING_OUT = 300000;
封装HTTP请求
m0_50304006的博客
03-09 246
【代码】封装HTTP请求。
.net服务器端发起请求封装
weixin_30292843的博客
04-23 110
写一个静态类封装类似客户端的请求 public static class HttpHelper { #region Get public static string HttpGet(string url, Encoding encoding = null) { WebClient clie...
基于HttpClient封装的请求类
stupid_leilei的专栏
02-28 425
基于HttpClient封装的请求类
.net core基于HttpClient实现的网络请求库
qq_41146932的博客
07-24 115
有时需要全局配置 Authentication，如果在代码中请求中独立配置了 Authentication 则会覆盖全局 Authentication。预载配置并不是必须的，但是有助于我们进行一些通用基础设置，例如Headers、Accept、BaseUrl等等。如果你是塞到 Header 里的这种做法。封装的 Http 请求库。，如果想要使用，直接在。，直接填写接口即可。
.NET HttpClient的有用实用程序。-.NET开发
05-27
HttpClientGoodies.NET .NET HttpClient的一组有用的实用程序。 安装Install-Package HttpClientGoodies的用途是什么？ 这些小而有用的实用程序将使HttpClient的生活变得更加轻松。HttpClientGoodies.NET一组.NET ...
【ASP.NET编程知识】.NET CORE HttpClient的使用方法.docx
05-14
.NET CORE HttpClient 的使用方法 .NET CORE 中的 HttpClient 是一个非常重要的组件，它提供了一个强大且灵活的方式来发送 HTTP 请求。然而，在使用 HttpClient 时，我们需要注意一些重要的配置和使用方法，以避免...
详解.NET Core 使用HttpClient SSL请求出错的解决办法
01-20
问题 使用 HTTP Client 请求 HTTPS 的 API 时出现 The certificate cannot be verified up to ... 下面就是问题代码： public class Program { public static void Main(string[] args) { ... var handler = new HttpC
【ASP.NET编程知识】通过HttpClient 调用ASP.NET Web API示例.docx
05-21
ASP.NET 编程知识 - 通过 HttpClient 调用 ASP.NET Web API 示例 在本文中，我们将学习如何使用 HttpClient 调用 ASP.NET Web API。HttpClient 是一个强大的 HTTP 客户端库，能够发送 HTTP 请求并接收响应。在 ASP...
一个封装好的Asp.Net C# HttpRequest请求类
05-11 6457
HTTP请求类： 双击代码全选 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 4
封装一套好用的http请求方法？逐步解析请求封装[根据Axios]
m0_46470372的博客
09-09 175
相信大家在组织大型项目的时候都不会直接去使用原生的请求，哪怕是axios，那样无论修改起来还是使用起来都不够方便 在携带token 响应拦截 更换服务器地址等方面，封装请求具有明显优势 话不多说 直接开写 请求封装 逐步分析版 // 引入axios import axios from 'axios' const service = axios.create({ // 服务器地址 我的配置方式 可以在 .env.development（开发环境） .env.production（生产环境）两个文.
httpclient工具类封装
dream_xin2013的专栏
11-09 349
分享基于apache的httpclient工具类封装，可以在项目中直接引入HttpUtils当做工具类使用
HttpPost请求的完美封装
淮师杨建波
05-25 3175
摘要： /*** * 封装了post请求的方法： * 1.使用了异步AsyncTask + Handler的处理模式； * 2.适用于仅仅一条数据的请求，最大的优势在于:能够同时适用于多条数据的请求，并保证数据不出现紊乱； * 3.这里面也同时使用了 * compile 'com.jakewharton:butterknife:7.0.0' * compile '
【HarmonyOS Arkts笔记】http网络请求封装
最新发布
风度
03-05 437
【代码】【HarmonyOS Arkts笔记】http网络请求封装
.net httpclient
10-14
好的，您的问题是 ".net httpclient"。 HttpClient是一个在.NET Framework中提供的用于发送HTTP请求的类。它提供了一种简单、灵活、高效的方式来与Web API进行通信。使用HttpClient，您可以发送HTTP GET、POST、PUT、DELETE等请求，并处理响应数据。 HttpClient的优点包括： 1. 支持异步操作，可以提高应用程序的性能和响应速度。 2. 可以设置请求头、请求体、超时时间等参数。 3. 可以处理HTTP响应，包括状态码、响应头和响应体等信息。 以下是一个使用HttpClient发送GET请求的示例代码： ``` using System; using System.Net.Http; using System.Threading.Tasks; class Program { static async Task Main(string[] args) { using (var client = new HttpClient()) { var response = await client.GetAsync("https://www.example.com"); var content = await response.Content.ReadAsStringAsync(); Console.WriteLine(content); } } } ```

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值