WebAPIServiceHelper 请求帮助类

最新推荐文章于 2024-02-11 08:57:44 发布
最新推荐文章于 2024-02-11 08:57:44 发布
阅读量1.2k 收藏
点赞数
分类专栏： C#
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/luolian123456/article/details/73483339
版权

 public class WebAPIServiceHelper
    {
        /// <summary>
        /// 调用WebAPI的get方法
        /// </summary>
        /// <param name="uri">地址</param>
        /// <returns>Json数据</returns>
        /// <Remark>luol,2016-06-29,2016-06-29</ Remark >
        public static string GetResponseJson(string url)
        {
            HttpClient httpClient = new HttpClient();
            httpClient.DefaultRequestHeaders.Accept.Add(
               new MediaTypeWithQualityHeaderValue("application/json"));
            HttpResponseMessage response = httpClient.GetAsync(url).Result;


            if (response.IsSuccessStatusCode)
            {
                string responseJson = response.Content.ReadAsStringAsync().Result;
                return responseJson;
            }
            else
            {
                string sError = response.Content.ReadAsStringAsync().Result;
                throw new Exception(sError);
                //HttpClientError httpError = response.Content.ReadAsAsync<HttpClientError>().Result;
                //throw new Exception(httpError.ExceptionMessage == null ? httpError.MessageDetail : httpError.ExceptionMessage);
            }
        }


        /// <summary>
        /// 调用WebAPI的get方法
        /// </summary>
        /// <param name="uri">地址</param>
        /// <returns>Json数据</returns>
        /// <Remark>luol,2016-06-29,2016-06-29</Remark >
        public static T GetResponseJson<T>(string url)
        {
            using (HttpClient httpClient = new HttpClient())
            {
                httpClient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
                HttpResponseMessage response = httpClient.GetAsync(url).Result;


                if (response.IsSuccessStatusCode)
                {
                    T responseJson = response.Content.ReadAsAsync<T>().Result;
                    return responseJson;
                }
                else
                {
                    string sError = response.Content.ReadAsStringAsync().Result;
                    throw new Exception(sError);
                    //HttpClientError httpError = response.Content.ReadAsAsync<HttpClientError>().Result;
                    //throw new Exception(httpError.ExceptionMessage == null ? httpError.MessageDetail : httpError.ExceptionMessage);
                }
            }
        }


        /// <summary>
        /// 调用WebAPI的get方法
        /// </summary>
        /// <param name="uri"></param>
        /// <returns></returns>
        public static byte[] GetResponseStream(string uri)
        {
            using (HttpClient httpClient = new HttpClient())
            {
                var response = httpClient.GetAsync(uri).Result;
                if (response.IsSuccessStatusCode)
                {
                    byte[] bytes = response.Content.ReadAsByteArrayAsync().Result;
                    return bytes;
                }
                else
                {
                    string sError = response.Content.ReadAsStringAsync().Result;
                    throw new Exception(sError);
                    //HttpClientError httpError = response.Content.ReadAsAsync<HttpClientError>().Result;
                    //throw new Exception(httpError.ExceptionMessage == null ? httpError.MessageDetail : httpError.ExceptionMessage);
                }
            }
        }


        /// <summary>
        /// 将json数据Post到指定Uri
        /// </summary>
        /// <param name="uri">链接</param>
        /// <param name="json">数据</param>
        /// <returns></returns>
        /// <Remark>Luolian,2016-06-16,2016-06-29</ Remark >
        public static string PostResponseJson(string uri, string postJson)
        {
            using (HttpClient httpClient = new HttpClient())
            {
                HttpContent httpContent = new StringContent(postJson);
                httpContent.Headers.ContentType = new System.Net.Http.Headers.MediaTypeHeaderValue("application/json");
                var response = httpClient.PostAsync(uri, httpContent).Result;
                if (response.IsSuccessStatusCode)
                {
                    string responseJson = response.Content.ReadAsStringAsync().Result;
                    return responseJson;
                }
                else
                {
                    string sError = response.Content.ReadAsStringAsync().Result;
                    throw new Exception(sError);
                    //HttpClientError httpError = response.Content.ReadAsAsync<HttpClientError>().Result;
                    //throw new Exception(httpError.ExceptionMessage == null ? httpError.MessageDetail : httpError.ExceptionMessage);
                }
            }
        }
        #region  TrackID
        /// <summary>
        /// 将json数据Post到指定Uri 带TrackId
        /// </summary>
        /// <param name="uri">链接</param>
        /// <param name="json">数据</param>
        /// <returns></returns>
        /// <Remark>YYX,2017-01-05,2017-01-05</ Remark >
        public static string PostResponseJsonTrackId(string uri, string postJson)
        {
            var Base = new HttpContextWrapper(HttpContext.Current) as HttpContextBase;
            var _context = Base.Request.RequestContext.HttpContext;
            var hash = _context.GetHashCode();
            var apiId = HttpContext.Current.Session[(hash + 1).ToString()];
            uri = UpdateUrl(uri, apiId == null ? "11111111-1111-1111-1111-111111111111" : apiId.ToString());
            return  PostResponseJson(uri, postJson);
        }


         
        public static string UpdateUrl(string url, string apiId)
        {
            var Base = new HttpContextWrapper(HttpContext.Current) as HttpContextBase;
            var _context = Base.Request.RequestContext.HttpContext;
            var hash = _context.GetHashCode();
            var trackID = HttpContext.Current.Session[hash.ToString()];
            var trackid = trackID == null ? "" : trackID.ToString();
            //删除session
            //HttpContext.Current.Session[hash.ToString()] = null; 
            //HttpContext.Current.Session.Remove(hash.ToString());
            if (url.Contains("?"))
            {
                url = url + "&trackID=" + trackid + "&AppId=" + apiId;
            }
            else
            {
                url = url + "?trackID=" + trackid + "&AppId=" + apiId;
            }
            return url;
        }




        /// <summary>
        /// 调用WebAPI的get方法 带TrackId
        /// </summary>
        /// <param name="uri">地址</param>
        /// <returns>Json数据</returns>
        /// <Remark>YYX,2017-01-05,2017-01-05</ Remark >
        public static string GetResponseJsonTrackId(string url)
        {
            var Base = new HttpContextWrapper(HttpContext.Current) as HttpContextBase;
            var _context = Base.Request.RequestContext.HttpContext;
            var hash = _context.GetHashCode();
            var apiId = HttpContext.Current.Session[(hash + 1).ToString()];
            url = UpdateUrl(url, apiId == null ? "11111111-1111-1111-1111-111111111111" : apiId.ToString());
            return GetResponseJson(url);
        }




        public static T PostResponseJsonTrackId<T>(string uri, object content)
        {
            var Base = new HttpContextWrapper(HttpContext.Current) as HttpContextBase;
            var _context = Base.Request.RequestContext.HttpContext;
            var hash = _context.GetHashCode();
            var apiId = HttpContext.Current.Session[(hash + 1).ToString()];
            uri = UpdateUrl(uri, apiId == null ? "11111111-1111-1111-1111-111111111111" : apiId.ToString());
            return PostResponseJson<T>(uri, content);
        }




        public static T GetResponseJsonTrackId<T>(string url)
        {
            var Base = new HttpContextWrapper(HttpContext.Current) as HttpContextBase;
            var _context = Base.Request.RequestContext.HttpContext;
            var hash = _context.GetHashCode();
            var apiId = HttpContext.Current.Session[(hash + 1).ToString()];
            url = UpdateUrl(url, apiId == null ? "11111111-1111-1111-1111-111111111111" : apiId.ToString());
            return GetResponseJson<T>(url);
        }






        #endregion
        public static string PostResponseJson(string uri, string postJson, string cookie)
        {
            using (HttpClient httpClient = new HttpClient())
            {
                HttpContent httpContent = new StringContent(postJson);
                httpContent.Headers.ContentType = new System.Net.Http.Headers.MediaTypeHeaderValue("application/json");
                var response = httpClient.PostAsync(uri, httpContent).Result;
                if (response.IsSuccessStatusCode)
                {
                    string responseJson = response.Content.ReadAsStringAsync().Result;
                    return responseJson;
                }
                else
                {
                    string sError = response.Content.ReadAsStringAsync().Result;
                    throw new Exception(sError);
                    //HttpClientError httpError = response.Content.ReadAsAsync<HttpClientError>().Result;
                    //throw new Exception(httpError.ExceptionMessage == null ? httpError.MessageDetail : httpError.ExceptionMessage);
                }
            }
        }
        /// <summary>
        /// 将object数据Post到指定Uri
        /// </summary>
        /// <param name="uri">链接</param>
        /// <param name="content">数据</param>
        /// <returns></returns>
        /// <Remark>LGX,2016-06-16,2016-07-03
        /// LGX 2016-12-20 修改该方法，因为 System.Net.Http.Formatting使用的是4.0的System.Net.Http 版本冲突
        /// </Remark >
        public static T PostResponseJson<T>(string uri, object content)
        {
            using (var httpClient = new HttpClient())
            {
                //httpClient.DefaultRequestHeaders.Accept.Add(new System.Net.Http.Headers.MediaTypeWithQualityHeaderValue("application/json"));
                //HttpResponseMessage response = httpClient.PostAsJsonAsync(uri, content).Result;
                HttpContent httpContent = new StringContent(JSONHelper.ObjectToJSON(content));
                httpContent.Headers.ContentType = new System.Net.Http.Headers.MediaTypeHeaderValue("application/json");
                var response = httpClient.PostAsync(uri, httpContent).Result;                
                if (response.IsSuccessStatusCode)
                {
                    T t = response.Content.ReadAsAsync<T>().Result;
                    return t;
                }
                else
                {
                    string sError = response.Content.ReadAsStringAsync().Result;
                    throw new Exception(sError);
                    //HttpClientError httpError = response.Content.ReadAsAsync<HttpClientError>().Result;
                    //throw new Exception(httpError.ExceptionMessage == null ? httpError.MessageDetail : httpError.ExceptionMessage);
                }
            }
        }


        /// <summary>
        /// 将byte[]数据Post到指定Uri
        /// </summary>
        /// <param name="uri"></param>
        /// <param name="fileByte"></param>
        /// <param name="formData"></param>
        /// <returns></returns>
        public static string PostResponseFormData(string uri, Dictionary<string, byte[]> fileByte, Dictionary<string, string> formData = null)
        {
            using (HttpClient httpClient = new HttpClient())
            {
                var httpContent = new MultipartFormDataContent();
                httpClient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("text/json"));
                if (formData != null)
                {
                    foreach (var key in formData.Keys)
                    {
                        var dataContent = new ByteArrayContent(Encoding.UTF8.GetBytes(formData[key]));
                        dataContent.Headers.ContentDisposition = new ContentDispositionHeaderValue("attachment")
                        {
                            Name = key
                        };
                        httpContent.Add(dataContent);
                    }
                }
                foreach (var key in fileByte.Keys)
                {
                    var fileContent = new ByteArrayContent(fileByte[key]);
                    fileContent.Headers.ContentDisposition = new ContentDispositionHeaderValue("attachment")
                    {
                        FileName = key
                    };
                    httpContent.Add(fileContent);
                }
                var response = httpClient.PostAsync(uri, httpContent).Result;
                if (response.IsSuccessStatusCode)
                {
                    string responseJson = response.Content.ReadAsStringAsync().Result;
                    return responseJson;
                }
                else
                {
                    string sError = response.Content.ReadAsStringAsync().Result;
                    throw new Exception(sError);
                    //HttpClientError httpError = response.Content.ReadAsAsync<HttpClientError>().Result;
                    //throw new Exception(httpError.ExceptionMessage == null ? httpError.MessageDetail : httpError.ExceptionMessage);
                }
            }
        }


        /// <summary>
        /// 将json数据Post到指定Uri
        /// </summary>
        /// <param name="uri">链接</param>
        /// <param name="json">数据</param>
        /// <returns></returns>
        /// <Remark>Luolian,2016-06-16,2016-06-29</ Remark >
        public static byte[] PostResponseJson2Bytes(string uri, string postJson)
        {
            using (HttpClient httpClient = new HttpClient())
            {
                HttpContent httpContent = new StringContent(postJson);
                httpContent.Headers.ContentType = new System.Net.Http.Headers.MediaTypeHeaderValue("application/json");
                var response = httpClient.PostAsync(uri, httpContent).Result;
                if (response.IsSuccessStatusCode)
                {
                    byte[] bytes = response.Content.ReadAsByteArrayAsync().Result;
                    return bytes;
                }
                else
                {
                    string sError = response.Content.ReadAsStringAsync().Result;
                    throw new Exception(sError);
                    //HttpClientError httpError = response.Content.ReadAsAsync<HttpClientError>().Result;
                    //throw new Exception(httpError.ExceptionMessage == null ? httpError.MessageDetail : httpError.ExceptionMessage);
                }
            }
        }


        /// <summary>
        /// 将json数据Post到指定Uri
        /// </summary>
        /// <param name="uri">链接</param>
        /// <param name="json">数据</param>
        /// <returns></returns>
        /// <Remark>Luolian,2016-06-16,2016-06-29</ Remark >
        public static string PostResponseStream(string uri, string filename, Stream stream)
        {
            using (HttpClient httpClient = new HttpClient())
            {
                httpClient.MaxResponseContentBufferSize = 256000;
                //httpClient.DefaultRequestHeaders.Add("user-agent", "User-Agent    Mozilla/5.0 (Windows NT 10.0; WOW64; Trident/7.0; Touch; MALNJS; rv:11.0) like Gecko");//设置请求头
                MultipartFormDataContent mulContent = new MultipartFormDataContent();
                HttpContent fileContent = new StreamContent(stream);


                //fileContent.Headers.ContentType = MediaTypeHeaderValue.Parse("multipart/form-data");
                fileContent.Headers.ContentType = MediaTypeHeaderValue.Parse(" text/html; charset=utf-8");






                mulContent.Add(fileContent, "myFile", filename);


                var response = httpClient.PostAsync(uri, mulContent).Result;
                if (response.IsSuccessStatusCode)
                {
                    string responseJson = response.Content.ReadAsStringAsync().Result;
                    return responseJson;
                }
                else
                {
                    string sError = response.Content.ReadAsStringAsync().Result;
                    throw new Exception(sError);
                    //HttpClientError httpError = response.Content.ReadAsAsync<HttpClientError>().Result;
                    //throw new Exception(httpError.ExceptionMessage == null ? httpError.MessageDetail : httpError.ExceptionMessage);
                }
            }
        }
        public static string PostForm(string url, string postJson, string cookieStr)
        {
            CookieContainer cookies = new CookieContainer();
            string[] cookieStrs = cookieStr.Split('=');
            Cookie cookie = new Cookie(cookieStrs[0], cookieStrs[1]);
            string domain = Regex.Replace(url, "[a-zA-z]+://", "");
            domain = domain.Split('/')[0];
            domain = domain.Split(':')[0];
            cookie.Domain = domain.Equals("localhost") ? "127.0.0.1" : domain;
            cookies.Add(cookie);
            byte[] postData = Encoding.ASCII.GetBytes(postJson.Substring(0, postJson.Length - 1));
            HttpWebRequest request = (HttpWebRequest)WebRequest.Create(url);
            request.Method = "POST";
            request.AllowAutoRedirect = false;
            request.ContentType = "application/x-www-form-urlencoded;charset=gbk";
            request.CookieContainer = cookies;
            request.UserAgent = "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.11 (KHTML, like Gecko) Chrome/23.0.1271.95 Safari/537.11";
            request.ContentLength = postData.Length;


            Stream requestStream = request.GetRequestStream();
            requestStream.Write(postData, 0, postData.Length);
            requestStream.Close();


            //HttpWebResponse response = (HttpWebResponse)request.GetResponse();
            //Stream responseStream = response.GetResponseStream();
            //StreamReader reader = new StreamReader(responseStream);


            //string cookie = response.Headers.Get("Set-Cookie");
            //string resultPage = reader.ReadToEnd();
            //string html = getHtml(GetCookieName(cookie), GetCookieValue(cookie));
            //reader.Close();
            //responseStream.Close();
            //return html;
            return "ok";
        }


        /// <summary>
        /// 带令牌post指定Url
        /// </summary>
        /// <param name="url">地址</param>
        /// <param name="ticket">令牌</param>
        /// <returns></returns>
        /// <Remark>yuxuxuan,2016-12-14,2016-12-14</ Remark >
        public static string PostResponsewithToken(string url, string ticket)
        {
            WebRequest request = WebRequest.Create(url);
            request.ContentType = "application/json";
            request.Headers.Add(HttpRequestHeader.Authorization, "Bearer " + ticket);
            request.Method = "Get";
            request.ContentLength = 0;
            WebResponse response = request.GetResponse();
            using (StreamReader stream = new StreamReader(response.GetResponseStream()))
            {
                var s = stream.ReadToEnd();
                return s;
            }
        }


        //private sealed class HttpClientError
        //{
        //    public string ExceptionMessage { get; set; }
        //    public string ExceptionType { get; set; }
        //    public HttpClientError InnerException { get; set; }
        //    public string Message { get; set; }
        //    public string MessageDetail { get; set; }
        //    public HttpClientError ModelState { get; set; }
        //    public string StackTrace { get; set; }
        //}

    }

 

 

 

///带追踪ID

     public DealNowPayQZResponseNView PostFrontReturnInfo(DealNowPayQZResponseNView response)
        {
            const string URI = @"{0}/TradeApi/PostFrontReturnInfo";
            string uri = string.Format(URI, configName);
            string obj = JSONHelper.ObjectToJSON(response);
            string ReturnMsg = WebAPIServiceHelper.PostResponseJsonTrackId(uri, obj);
            return JSONHelper.JSONToObject<DealNowPayQZResponseNView>(ReturnMsg);
        }

 

///GetResponseJson 请求返回json对象

   public AppIdReturnMsg AppIdValidation(string AppID, string ApiID, string Guid)
        {
            const string url = "{0}?AppID={1}&ApiID={2}&Reserved={3}";
            AppIdReturnMsg returnMsg = null;
            string config = ConfigHelper.GetAppConfig("ValidationService");
            if (config != null)
            {
                string newurl = string.Format(url, config, AppID, ApiID, Guid);
                returnMsg = WebAPIServiceHelper.GetResponseJson<AppIdReturnMsg>(newurl);
            }
            return returnMsg;
        }

枫林街末
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Winform入门(五) WEBAPI请求
finedayforu的博客
08-11 1123
一. 需要引入: using System.Net; using System.IO; 二. 处理get请求 public static string HttpGet(string url, Dictionary<string, string> para) { Encoding encoding = Encoding.UTF8; ...
api-helper:卷曲配置文件以使用api
05-14
api助手 依存关系 发送数据 [可选]提供漂亮的输出和--json支持（如下所述） 为什么 许多API任务要求每个请求都发送相同的标头或数据 键入（或挖掘您的shell历史记录）相同的选项很繁琐 您希望能够保存API请求（例如到您的Shell rc），而不会在各处泄漏您的身份验证令牌 使用curl --config很麻烦 用法 usage: api [-vh] <profile> <action> <endpoint> [...data] profile是~/.config/api-helper中文件的名称，包含URL条目和任意curl选项 action是一个http动词，例如get ， put ， post等 endpoint是要附加到profile定义的url的路由 data是卷曲选项，例如--data随请求一起发送 详细程度分为三个级别： -v将curl命令打印到stderr
c#使用HttpClient调用WebApi
u011555996的博客
05-12 7710
调用WebApi 可以利用HttpClient来进行Web Api的调用。由于WebA Api的调用本质上就是一次普通的发送请求与接收响应的过程， 所有HttpClient其实可以作为一般意义上发送HTTP请求的工具。 using System; using System.Collections.Generic; using System.Linq; using System.Net.Http; using System.Text; using System.Threading.Tasks;
c# 简单搭建 WebAPI 项目
u012799456的博客
12-21 1458
C# 简单搭建WebAPI
C#调用WebApi（Get、Post、Delete、Put）
weixin_46990454的博客
04-15 3824
Get public static string GetData(string url) { HttpClient httpClient = new HttpClient(); return httpClient.GetStringAsync(url).Result; } Post、Delete、Put public static string PostData(string data, string uri) { return CommonHttpWebRequest(da
C#后端调用WEBAPI
easyboot的专栏
08-16 2244
后台调用WEBAPI
ajax参数传递之[HttpGet]/[HttpPost]/[HttpPut]/[HttpDelete]请求
weixin_34293911的博客
03-03 923
　　$.ajax({ type: "get", url: "http://localhost:27221/api/Charging/GetByModel", contentType: "application/json", data: { ID: "1", NAME: "Jim", CREATETIME: "1988-09.
C#系列-C#访问WebAPI（11）
最新发布
赵玉的专栏
02-11 1362
密钥），你可能还需要在请求中添加相应的认证头。以下是一个简单的示例，展示了如何使用。类应该已经包含在框架中。否则，你可能需要添加对应的。控制台应用程序示例，它调用一个假设的。方法读取响应内容作为一个字符串。或更高版本，你也可以使用内置的。响应的状态码，确保请求成功。首先，确保你的项目中包含了。需要身份验证（例如，使用。读取响应内容作为字符串。变量应该是你想要访问的。请注意，你可能需要安装。字符串反序列化为对象。或者，如果你使用的是。
C# 调用 WebApi 、 WebService
小小IT人的专栏
09-28 1097
C# 调用 WebApi 、 WebService。
resp.Content.ReadAsAsync报错
Acettest's Blogs
05-28 580
It looks like it is an extension method (in System.Net.Http.Formatting):HttpContentExtensions ClassUpdate:PM&gt; install-package Microsoft.AspNet.WebApi.ClientAccording to the System.Net.Http.Formatti...
WebAPIHelper 自动生成帮助文档
07-07
根据webapi的方法和注释自动生成帮助文档，还可以测试webapi方法，功能很是强大
C# .NET Web API 完整 Demo
11-04
麻雀虽小，五脏俱全，这是一个可直接用于生产的脚手架 包含： DBHelper：数据库操作类，使用原生SQL，查询结果映射到Model，操作数据库非常方便，支持异步，提供了Emit版本的属性赋值比反射性能高，但暂未使用，支持MySQL、Oracle、SQL Server、SQLite、Access Model生成器：用于生成和数据库表与字段一一对应的Model类，支持MySQL、Oracle、SQL Server、SQLite Token验证 在拦截器里统一处理异常 在拦截器里统一写操作日志 集成了kafka，但只写了生产者，消费者没写 集成了自己写的Socket工具类，业务耦合较重，可以自己改
API Server简介
热门推荐
u010453704的博客
12-05 1万+
API Server简介 一、API Server简介 1.1 API Server功能 k8s API Server提供了k8s各类资源对象（pod,RC,Service等）的增删改查及watch等HTTP Rest接口，是整个系统的数据总线和数据中心。 kubernetes API Server的功能： 1. 提供了集群管理的REST API接口(包括认证授权、数据校验以及集群状态变更)； 2. 提供其他模块之间的数据交互和通信的枢纽（其他模块通过API Server查询或修改数据，只.
ApiService常用四种方式简单封装 （kotlin）
......
06-19 3316
我们为什么要封装? 首先我们看一下我们不封装的图 然后可以看到我们每次请求都需要重写get post delete put 方法,这样会导致很累 浪费很多时间 我们在开发过程中肯定是节约时间,因此我们这边就用到了封装下面是封装的一张图片 interface ApiService { @POST() @FormUrlEncoded fun doPost(@Url ur...
API Demos 2.2 研读笔记（13）——Service
开启Android之路
10-24 127
Service是在后台运行，不可交互的一个组件。它不是一个独立进程，也不是一个线程。它一般在所属的application进程的主线程中运行，除非特别指定。   下面结合示例分析Service的主要特征。   Service Lifecycle   当startService和bindService同时存在：   此外Service可以自己调用stopSelf()或者stopSelfR...
k8s中的service、api-server、kube-proxy有什么区别
qq_33525062的博客
06-02 714
它是集群的控制平面，接收和处理用户（开发人员、管理员）的请求，管理集群中的资源对象（如Pod、Service、Deployment等）和配置信息。综上所述，Service、API Server和kube-proxy是Kubernetes中的三个核心组件，它们分别负责将请求转发给后端的Pod、管理集群的资源和配置信息，以及处理流量的路由和代理。总结起来，Pod是K8s中的一个概念，它提供了一种组织和管理容器的方式，类似于一个旅行团中的小组，它们共享资源和网络环境，方便沟通和协作，提高整体的效率和可管理性。
深入理解Kube-APIServer
BurningMyself
05-22 767
深入理解Kube-APIServer¶ 目录 - 认证 - 鉴权 - 准入 Mutating Validating Admission - 限流 - APIServer对象的实现 API Server¶ kube-apiserver是Kubernetes最重要的核心组件之一，主要提供以下的功能 提供集群管理的REST API接口，包括认证授权、数据校验以及集群状态变更 等 提供其他模块之间的数...
APIHelper的使用方法
qq1617176084的博客
05-15 1863
在UWP的网络请求中有一些现有的帮助类库可以帮助我们提高效率，在APIHelper当中封装了GET 和 POST方法以方便我们发起网络请求。 类库的github代码地址：https://github.com/1617176084/JP.Utils.UWP public async void initData() { string urlStr = U
C# HttpClient请求Webapi帮助类
weixin_30687811的博客
02-26 911
引用Newtonsoft.Json // Post请求 public string PostResponse(string url,string postData,out string statusCode) { string result = string.Empty; //设置H...
ApiHelper
weixin_33923148的博客
06-15 326
public static class ApiHelper { public static ReslultInfo&lt;K&gt; Try&lt;K&gt;(Action&lt;ReslultInfo&lt;K&gt;&gt; action) { var r = new ReslultInfo&lt;K&gt;...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值