c# http

C#代码

客户端：

NETCore提供了三种不同类型用于生产的REST API： HttpWebRequest;WebClient;HttpClient

HttpWebRequest

这是.NET创建者最初开发用于使用HTTP请求的标准类。使用HttpWebRequest可以让开发者控制请求/响应流程的各个方面，如 timeouts, cookies, headers, protocols。另一个好处是HttpWebRequest类不会阻塞UI线程。例如，当您从响应很慢的API服务器下载大文件时，您的应用程序的UI不会停止响应。然而，强大的个性化操作带来了极大的复杂性。

主要是使用HttpWebRequest请求、使用HttpWebResponse接收响应。

1.使用application/json作为请求头，用来告诉服务端消息主体是序列化的JSON字符串。

/*

*  url:POST请求地址

*  postData:json格式的请求报文,例如：{"key1":"value1","key2":"value2"}

*/

public static string PostUrl(string url, string postData)

{

    HttpWebRequest req = (HttpWebRequest)WebRequest.Create(url);

    req.Method = "POST";

    req.TimeOut = "800";//设置请求超时时间，单位为毫秒

    req.ContentType = "application/json";

    byte[] data = Encoding.UTF8.GetBytes(postData);

    req.ContentLength = data.Length;

    using (Stream reqStream = req.GetRequestStream())

    {

        reqStream.Write(data, 0, data.Length);

        reqStream.Close();

    }

    HttpWebResponse resp = (HttpWebResponse)req.GetResponse();

    Stream stream = resp.GetResponseStream();

    //获取响应内容

    string result = "";

    using (StreamReader reader = new StreamReader(stream, Encoding.UTF8))

    {

        result = reader.ReadToEnd();

}

stream .Close();

 if (resp != null)

 {

    resp .Close();

  }

 if (req!= null)

 {

    req.Abort();

 }

    return result;

}

2.使用multipart/form-data作为请求头，用来告诉服务器消息主体是 多发文件 格式。

/// <summary>

/// 上传文件请求

/// </summary>

/// <param name="url">Url</param>

/// <param name="filePath">文件路径</param>

/// <param name="formDatas">表单数据（字典格式）</param>

/// <param name="callback">上传回调</param>

public static void UploadRequest(string url, string filePath, Dictionary<string,string> formDatas, Action<string> callback)

{

    // 时间戳，用做boundary

    string timeStamp = DateTime.Now.Ticks.ToString("x");

    //根据uri创建HttpWebRequest对象

    HttpWebRequest httpReq = (HttpWebRequest) WebRequest.Create(new Uri(url));

    httpReq.Method = "POST";

    httpReq.AllowWriteStreamBuffering = false; //对发送的数据不使用缓存

    httpReq.Timeout = 300000; //设置获得响应的超时时间（300秒）

    httpReq.ContentType = "multipart/form-data; boundary=" + timeStamp;

    //读取file文件

    FileStream fileStream = new FileStream(filePath, FileMode.Open, FileAccess.Read);

    BinaryReader binaryReader = new BinaryReader(fileStream);

    //表单信息

    string boundary = "--" + timeStamp;

    string form = "";

    string formFormat = boundary + "\r\nContent-Disposition: form-data; name=\"{0}\"\r\n\r\n{1}\r\n";

    string formEnd = boundary + "\r\nContent-Disposition: form-data; name=\"{0}\"; filename=\"{1}\";\r\nContent-Type:application/octet-stream\r\n\r\n";

    foreach (var pair in formDatas)

    {

        form += string.Format(formFormat, pair.Key, pair.Value);

    }

    form += string.Format(formEnd,"file", Path.GetFileName(filePath));

    byte[] postHeaderBytes = Encoding.UTF8.GetBytes(form);

    //结束边界

    byte[] boundaryBytes = Encoding.ASCII.GetBytes("\r\n--" + timeStamp + "--\r\n");

    long length = fileStream.Length + postHeaderBytes.Length + boundaryBytes.Length;

    httpReq.ContentLength = length; //请求内容长度

    try

    {

        //每次上传4k

        int bufferLength = 4096;

        byte[] buffer = new byte[bufferLength];

        //已上传的字节数

        long offset = 0;

        int size = binaryReader.Read(buffer, 0, bufferLength);

        Stream postStream = httpReq.GetRequestStream();

        //发送请求头部消息

        postStream.Write(postHeaderBytes, 0, postHeaderBytes.Length);

        while (size > 0)

        {

            postStream.Write(buffer, 0, size);

            offset += size;

            size = binaryReader.Read(buffer, 0, bufferLength);

        }

        //添加尾部边界

        postStream.Write(boundaryBytes, 0, boundaryBytes.Length);

        postStream.Close();

        //获取服务器端的响应

        using (HttpWebResponse response = (HttpWebResponse) httpReq.GetResponse())

        {

            Stream receiveStream = response.GetResponseStream();

            StreamReader readStream = new StreamReader(receiveStream, Encoding.UTF8);

            string returnValue = readStream.ReadToEnd();

            Debug.Log("upload result:"+returnValue);

            callback?.Invoke(returnValue);

            response.Close();

            readStream.Close();

        }

    }

    catch (Exception ex)

    {

        Debug.Log("文件传输异常： " + ex.Message);

    }

    finally

    {

        fileStream.Close();

        binaryReader.Close();

    }

}

1. 使用multipart/form-data作为请求头 自己写的例子

Content-Type: multipart/form-data; boundary=AaB03x

 --AaB03x

 Content-Disposition: form-data; name="submit-name1"

 Larry1

 --AaB03x

 Content-Disposition: form-data; name="submit-name2"

 Larry2

 --AaB03x--

格式

1. Content-Type: multipart/form-data; boundary=AaB03x

首先声明数据类型为multipart/form-data, 然后定义边界字符串AaB03x，这个边界字符串就是用来在下面来区分各个数据的，可以随便定义，但是最好是用破折号等数据中一般不会出现的字符。然后是换行符。

1. --AaB03x

这个是边界字符串，注意每一个边界符前面都需要加2个连字符“--”，然后跟上换行符。

1. Content-Disposition: form-data; name="submit-name"

这里是Key-Value数据中字符串类型的数据。 submit-name 是这个Key-Value数据中的Key。当然也需要换行符。

1. Larry1

这个就是刚才Key-Value数据中的value。

1. --AaB03x

边界符,表示数据结束。

1. --AaB03x--

数据结束后的分界符，注意因为这个后面没有数据了所以需要在后面追加一个“--”表示结束。

public static string GetToken(string strUrl, Dictionary<string, string> kVDatas)

        {

            string strtoken = "";

            if (string.IsNullOrEmpty(strUrl) || kVDatas.Count <= 0)

            {

                string strTip = "获取token的参数为空，请设置配置文件的url、uid、sid.";

                Logger.WriteError(strTip);

                return "";

            }

            try

            {

                string boundary = "---------------------------" + DateTime.Now.Ticks.ToString("x");

                byte[] boundarybytes = Encoding.ASCII.GetBytes("\r\n--" + boundary + "\r\n");

                byte[] endbytes = Encoding.ASCII.GetBytes("\r\n--" + boundary + "--\r\n");

                //1.HttpWebRequest

                HttpWebRequest request = (HttpWebRequest)WebRequest.Create(strUrl);

                request.ContentType = "multipart/form-data; boundary=" + boundary;

                request.Method = "POST";

                request.KeepAlive = true;

                request.Timeout = s_nLinkTime*1000;

                CredentialCache credentialCache = new CredentialCache();

                credentialCache.Add(new Uri(strUrl), "Basic", new NetworkCredential("member", "secret"));

                request.Credentials = credentialCache;

                request.ServicePoint.Expect100Continue = false;

                using (Stream stream = request.GetRequestStream())

                {

                    //1.1 key/value

                    string formdataTemplate = "Content-Disposition: form-data; name=\"{0}\"\r\n\r\n{1}";

                    if (kVDatas != null)

                    {

                        foreach (string key in kVDatas.Keys)

                        {

                            stream.Write(boundarybytes, 0, boundarybytes.Length);

                            string formitem = string.Format(formdataTemplate, key, kVDatas[key]);

                            byte[] formitembytes = Encoding.GetEncoding("UTF-8").GetBytes(formitem);

                            stream.Write(formitembytes, 0, formitembytes.Length);

                        }

                    }

                    stream.Write(endbytes, 0, endbytes.Length);

                    //stream.Close();//已通过using 自动释放，不需要手动释放资源

                }

                //2.WebResponse

                HttpWebResponse response = (HttpWebResponse)request.GetResponse();

                using (StreamReader stream = new StreamReader(response.GetResponseStream()))

                {

                    string strRecvData = stream.ReadToEnd();

                    JObject obj = (JObject)JsonConvert.DeserializeObject(strRecvData);//将刚才一大串字符串转换成一个大对象

                    string strSuc = obj["success"].ToString();

                    if (strSuc.Equals("true", StringComparison.OrdinalIgnoreCase))

                    {

                        strtoken = obj["data"]["token"].ToString();

                    }

                    //stream.Close();//已通过using 自动释放，不需要手动释放资源

                }

                if (request != null)

                {

                    request.Abort();

                }

                if (response != null)

                {

                    response.Close();

                }

            }

            catch (Exception e)

            {

                Logger.WriteError("获取token" + e.Message);

                return "";

            }

            return strtoken;

        }

WebClient：

WebClient一种更高级别的抽象，是HttpWebRequest为了简化最常见任务而创建的，使用过程中你会发现他缺少基本的header，timeoust的设置，不过这些可以通过继承httpwebrequest来实现。相对来说，WebClient比WebRequest更加简单，它相当于封装了request和response方法，不过需要说明的是，Webclient和WebRequest继承的是不同类，两者在继承上没有任何关系。

using (WebClient webClient = new WebClient())

   {

       webClient.DownloadFile("http://example.com", "路径");

   }

HttpClient

HttpClient是.NET4.5引入的一个HTTP客户端库，其命名空间为 System.Net.Http ，.NET 4.5之前我们可能使用WebClient和HttpWebRequest来达到相同目的。HttpClient利用了最新的面向任务模式，使得处理异步请求非常容易。它适合用于多次请求操作，一般设置好默认头部后，可以进行重复多次的请求，基本上用一个实例可以提交任何的HTTP请求。HttpClient有预热机制，第一次进行访问时比较慢，所以不应该用到HttpClient就new一个出来，应该使用单例或其他方式获取HttpClient的实例。

public Task<HttpResponseMessage> GetAsync(Uri requestUri, HttpCompletionOption completionOption);

public Task<HttpResponseMessage> PostAsync(Uri requestUri, HttpContent content);

HttpRequestMessage类：表示用户请求消息；

public HttpContent Content { get; set; } //请求报文内容

Public HttpMethod Method { get; set; } //方法

public Uri RequestUri { get; set; }  //url

public HttpRequestHeaders Headers { get; } //请求头

HttpResponseMessage类：表示http响应消息；

public HttpContent Content { get; set; }  //响应的协议内容

public HttpStatusCode StatusCode { get; set; }响应的状态码

Public HttpRequestMessage RequestMessage { get; set; }请求信息

public HttpResponseHeaders Headers { get; } 响应头

HttpContent 类型用于表示 HTTP 实体正文和相应的内容标头。

Object<-HttpContent<-ByteArrayContent<-StringContent（字符串）基于字符串提供 HTTP 内容 用于application/json

或者FormUrlEncodedContent 键值对  用于application/x-www-form-urlencoded

或者MultipartFormDataContent 用于  multipart/form-data

public Task<string> ReadAsStringAsync();

public StringContent(string content, Encoding encoding);

通过Get请求数据

var httpClient = new HttpClient();

var url = "http://localhost:9000/index.html";

var response = await httpClient.GetAsync(url);

var str = await response.Content.ReadAsStringAsync();

通过Post请求数据： application/x-www-form-urlencoded

var httpClient = new HttpClient();

var url = "http://192.168.0.9:9000/Demo/PostUrlCode";

var response = await httpClient.PostAsync(url, new FormUrlEncodedContent(new List<KeyValuePair<string, string>>()

{

    new KeyValuePair<string, string>("name","小明"),

    new KeyValuePair<string, string>("age","20")

}));

var str = await response.Content.ReadAsStringAsync();

上面的请求报文:

POST /Demo/PostUrlCode HTTP/1.1

Host: 192.168.0.9:9000

Content-Type: application/x-www-form-urlencoded

Content-Length: 30

name=%E5%B0%8F%E6%98%8E&age=20

使用Post请求数据：application/json

var httpClient = new HttpClient();

var url = "http://192.168.0.9:9000/Demo/PostUrlJson"

var response = await httpClient.PostAsync(

    url,

    new StringContent(

        Newtonsoft.Json.JsonConvert.SerializeObject(new { Name = "小明", Id = 1 }),

        Encoding.UTF8,

        "application/json")

    );

var str = await response.Content.ReadAsStringAsync();

POST /Demo/PostUrlJson HTTP/1.1

Host: 192.168.0.9:9000

Content-Type: application/json; charset=utf-8

Content-Length: 24

{"Name":"小明","Id":1}

通过Post上传文件：multipart/form-data

var httpClient = new HttpClient();

var url = "http://localhost:9000/Demo/PostMulti";

var content = new MultipartFormDataContent();

content.Add(new StringContent("小明"), "name");

content.Add(new StringContent("18"), "age");

//注意：要指定filename，即：test.txt，否则后台不认为是一个文件，而是普通的参数

content.Add(new ByteArrayContent(System.IO.File.ReadAllBytes("e:\\test.txt")), "file", "test.txt");

var response = await httpClient.PostAsync(url, content);

var str = await response.Content.ReadAsStringAsync();

产生的请求报文如下：

POST /Demo/PostMulti HTTP/1.1

Host: 192.168.0.9:9000

Content-Type: multipart/form-data; boundary="ecc429f8-1f51-43a6-af5b-0fc8a88da513"

Content-Length: 451

--ecc429f8-1f51-43a6-af5b-0fc8a88da513

Content-Type: text/plain; charset=utf-8

Content-Disposition: form-data; name=name

小明

--ecc429f8-1f51-43a6-af5b-0fc8a88da513

Content-Type: text/plain; charset=utf-8

Content-Disposition: form-data; name=age

18

--ecc429f8-1f51-43a6-af5b-0fc8a88da513

Content-Disposition: form-data; name=file; filename=test.txt; filename*=utf-8''test.txt

this is file.

--ecc429f8-1f51-43a6-af5b-0fc8a88da513--

 //使用HttpClient 对应后面GetToken，一样的效果

        public static async Task<string>  GetTokenname(string strUrl, Dictionary<string, string> kVDatas)

        {

            string strtoken = "";

            try

            {

                var content = new MultipartFormDataContent();

                foreach (string key in kVDatas.Keys)

                {

                    content.Add(new StringContent(kVDatas[key]), key);

                }

                using (var httpClient = new HttpClient())

                {

                    using (HttpResponseMessage response = await httpClient.PostAsync(strUrl, content))

                    {

                        if (response.IsSuccessStatusCode)

                        {

                            var str = await response.Content.ReadAsStringAsync();

                            JObject obj = (JObject)JsonConvert.DeserializeObject(str);//将刚才一大串字符串转换成一个大对象

                            string strSuc = obj["success"].ToString();

                            if (strSuc.Equals("true", StringComparison.OrdinalIgnoreCase))

                            {

                                strtoken = obj["data"]["token"].ToString();

                            }

                        }

                    }

                }

            }

            catch (Exception e)

            {

                Logger.WriteError("获取token" + e.Message);

                return "";

            }   

            return strtoken;

        }