C# 通过 HttpWebRequest发送数据以及服务器通过Request请求获取数据_c# request

作者：你好赵伟 | 2024-06-23 02:12:28

踩

c# request

C# 通过 HttpWebRequest发送数据以及服务器通过Request请求获取数据, 后台请求的三种类型"application/x-www-form-urlencoded"和"multipart/form-data"以及"application/json"，对应的服务器端应该获取数据参数的方法

C#中HttpWebRequest的用法详解可参考：

C#中HttpWebRequest的用法详解
 C# HttpWebRequest详解
C# 服务器通过Request获取参数可参考：
C# WebService 接口通过Request请求获取json参数

一、客户端和服务器传输数据的类

1、后台程序发送HTTP请求的Class，服务器端也要添加该类

namespace WebApiInvoke
{
    /// <summary>
    /// 后台程序发送HTTP请求数据的类
    /// </summary>
    class RequestDataModel
    {
        /// <summary>
        /// 姓名
        /// </summary>
        public string DataName { get; set; }
        /// <summary>
        /// 性别
        /// </summary>
        public string DataSex { get; set; }
        /// <summary>
        /// 结果
        /// </summary>
        public string DataResult { get; set; }
        /// <summary>
        /// 年龄
        /// </summary>
        public int DataAge { get; set; }
    }
}
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

2、服务端返回HTTP请求的数据class，客户端也要有

namespace ServiceTest
{
    /// <summary>
    /// WebService 服务端返回的类
    /// </summary>
    public class WebServiceWriteBack
    {
        public bool Success { get; set; } = true;
        public string Data { get; set; } = string.Empty;
    }
}
1
2
3
4
5
6
7
8
9
10
11

二、“application/json”：

1、后台程序(客户端)发送HTTP请求(request.Method = “POST”、request.ContentType = “application/json”),

a.客户端代码：

namespace WebApiInvoke
{
    class HttpApiRequestHelper
    {
        /// <summary>
        /// 使用HttpWebRequest发送一个POST请求 
        /// </summary>
        /// <param name="url">请求的地址</param>
        /// <param name="dto">发送的数据对象</param>
        /// <returns></returns>
        public static string HttpJsonPost(string url, object dto)
        {
            HttpWebRequest request = (HttpWebRequest)WebRequest.Create(url);

            request.Method = "POST";
            request.KeepAlive = false;
            request.AllowAutoRedirect = true;
            request.Accept = "application/json";
            request.ContentType = "application/json";
            string strContent = JsonConvert.SerializeObject(dto); //序列化为字符串，可以使用自己项目中封装的json方法
            using (StreamWriter dataStream = new StreamWriter(request.GetRequestStream()))
            {
                dataStream.Write(strContent);
            }
            //  获取服务器返回的响应体
            HttpWebResponse response = (HttpWebResponse)request.GetResponse();
            string encoding = response.ContentEncoding;
            if (encoding == null || encoding.Length < 1)
            {
                encoding = "UTF-8"; //默认编码  
            }
            StreamReader reader = new StreamReader(response.GetResponseStream(), Encoding.GetEncoding(encoding));
            string retString = reader.ReadToEnd();
            return retString;
        }
   	}
}
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

服务器端通过Request.InputStream获取json数据，并做相应的处理；
需要NuGet程序包中安装Microsoft.AspNetCore.Mvc.WebApiCompatShim，并usingSystem.Web.Http; 请添加图片描述

b.服务器端对应的代码

using Newtonsoft.Json;
using System;
using System.IO;
using System.Web;
using System.Web.Http;

namespace ServiceTest
{
    /// WebService 接口 通过Request请求获取json参数
    class GetRequestDataHelper : ApiController
    {
        /// <summary>
        /// 通过Request请求获取json参数
        /// 对应request.ContentType = "application/json"
        /// </summary>
        /// <returns></returns>
        public WebServiceWriteBack GetRequestJsonData()
        {
        	// 服务器端回写数据库的类
            WebServiceWriteBack writeBack = new WebServiceWriteBack();
            HttpContextBase context = Request.Properties["MS_HttpContext"] as HttpContextBase;
            HttpRequestBase request = context.Request;

            string data = string.Empty;
            using (Stream stream = request.InputStream)// 读取Json数据
            {
                stream.Position = 0;
                using (StreamReader streamReader = new StreamReader(stream))
                {
                    data = streamReader.ReadToEnd();
                }
            }
            // 将Json数据转换为对象
            RequestDataModel data1 = JsonConvert.DeserializeObject<RequestDataModel>(data);
            #region 对传进来的 DataModel 进行处理 并对要回写的WebServiceWriteBack类进行赋值
            if (string.IsNullOrEmpty(data1.DataSex))
            {
                writeBack.Success = true;
                writeBack.Data = "成功了！";
            }
            #endregion

            return writeBack;
        }
    }
}
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
46

三、表单：

1、传统的表单数据是"DataName=1&DataSex=dadada&DataResult=S201FR&DataAge=1"一个字符串中间用‘&’分割；

后台程序(客户端)发送HTTP请求(request.Method = “POST”、request.ContentType = “application/x-www-form-urlencoded”),

a.客户端代码：

        /// <summary>
        /// HttpWebRequest Post请求
        /// application/x-www-form-urlencoded
        /// "DataName=1&DataSex=dadada&DataResult=S201FR&DataAge=1"
        /// </summary>
        /// <param name="postUrl">请求地址</param>
        /// <param name="postData">请求参数(json格式请求数据时contentType必须指定为application/json)</param>
        /// <param name="result">返回结果</param>
        /// <param name="contentType">请求类型</param>
        /// <returns>返回结果</returns>
        public static bool WebHttpPost(string postUrl, string postData, out string result, string contentType = "application/x-www-form-urlencoded")
        {
            try
            {
                Encoding encoding = Encoding.GetEncoding("gb2312");
                byte[] byteArray = encoding.GetBytes(postData);

                HttpWebRequest httpWebRequest = (HttpWebRequest)WebRequest.Create(postUrl);
                httpWebRequest.Method = "POST";
                httpWebRequest.ContentType = contentType;
                httpWebRequest.ContentLength = byteArray.Length;
                httpWebRequest.AllowAutoRedirect = true;

                using (Stream stream = httpWebRequest.GetRequestStream())
                {
                    stream.Write(byteArray, 0, byteArray.Length); // 写入参数                  
                }
				//  获取服务器返回的响应体
                HttpWebResponse httpWebResponse = httpWebRequest.GetResponse() as HttpWebResponse;
                using (Stream responseStream = httpWebResponse.GetResponseStream())
                {
                    StreamReader streamReader = new StreamReader(responseStream, Encoding.GetEncoding("UTF-8"));
                    result = streamReader.ReadToEnd(); // 请求返回的数据
                    streamReader.Close();
                }

                return true;
            }
            catch (Exception ex)
            {
                result = ex.Message;
                return false;
            }
        }
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

b.服务器端通过Request.Form获取表单数据，并做相应的处理；

using Newtonsoft.Json;
using System;
using System.IO;
using System.Web;
using System.Web.Http;

namespace ServiceTest
{
        /// <summary>
        /// 通过Request请求获取表单参数
        /// 对应contentType = "application/x-www-form-urlencoded"和contentType =  "multipart/form-data"
        /// </summary>
        /// <returns></returns>

        public WebServiceWriteBack GetRequestFromData()
        {
            // 服务器端回写数据库的类
            WebServiceWriteBack writeBack = new WebServiceWriteBack();
            HttpContextBase context = Request.Properties["MS_HttpContext"] as HttpContextBase;
            HttpRequestBase request = context.Request;
            
            RequestDataModel data1 = new RequestDataModel()
            {
                DataName = request.Form["DataName"]?.ToString(),
                DataSex = request.Form["DataSex"]?.ToString(),
                DataAge = Convert.ToInt32(request.Form["DataAge"]?.ToString()),
                DataResult = request.Form["DataResult"]?.ToString()
            };
            #region 对传进来的 DataModel 进行处理 并对要回写的WebServiceWriteBack类进行赋值
            if (string.IsNullOrEmpty(data1.DataSex))
            {
                writeBack.Success = true;
                writeBack.Data = "成功了！";
            }
            #endregion

            return writeBack;
        }
    }
}

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

2、“multipart/form-data”

包含异步请求方法HttpPostAsync和HttpPostFromData方法

a.客户端代码，两个方法

using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Net;
using System.Text;

namespace WebApiInvoke
{
    class HttpApiRequestHelper
    {
        /// <summary>
        /// Async异步请求 POST
        /// </summary>
        /// <param name="urlStr">请求的地址</param>
        /// <param name="jsonStr">Json字符串</param>
        /// <returns></returns>
        public static string HttpPostAsync(string urlStr, string jsonStr)
        {
            string content = "";
            try
            {
                Dictionary<string, string> map = JsonStringToKeyValuePairs(jsonStr);

                var mfdc = new System.Net.Http.MultipartFormDataContent();
                mfdc.Headers.Add("ContentType", "multipart/form-data");//声明头部
                foreach (string key in map.Keys)
                {
                    mfdc.Add(new System.Net.Http.StringContent(map[key]), key);//参数, 内容在前,参数名称在后
                }
                var clientTask = new System.Net.Http.HttpClient().PostAsync(urlStr, mfdc);//发起异步请求
                clientTask.Wait();//等待请求结果
                if (clientTask.Result.IsSuccessStatusCode)
                {
                    //请求正常
                    var resultTask = clientTask.Result.Content.ReadAsStringAsync();//异步读取返回内容
                    resultTask.Wait();//等读取返回内容
                    content = resultTask.Result;//返回内容字符串
                }
                else
                {
                    //请求异常
                    content = "失败";
                }
            }
            catch (Exception ex)
            {
                content = ex.Message;
            }
            return content;
        }

        /// <summary>
        /// multipart/form-data POST请求
        /// </summary>
        /// <param name="url">请求的地址</param>
        /// <param name="jsonStr">Json字符串</param>
        /// <returns></returns>
        public static string HttpPostFromData(string url, string jsonStr)
        {
            string content = "";
            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");

                HttpWebRequest request = (HttpWebRequest)HttpWebRequest.Create(url);
                request.ContentType = "multipart/form-data; boundary=" + boundary;
                request.Method = WebRequestMethods.Http.Post;
                request.KeepAlive = true;
                request.Timeout = -1;

                CredentialCache credentialCache = new CredentialCache();
                credentialCache.Add(new Uri(url), "Basic", new NetworkCredential("user", "user"));
                request.Credentials = credentialCache;

                request.ServicePoint.Expect100Continue = false;
                Dictionary<string, string> map = JsonStringToKeyValuePairs(jsonStr);
                using (Stream stream = request.GetRequestStream())
                {
                    //1.1 key/value
                    string formdataTemplate = "Content-Disposition: form-data; name=\"{0}\"\r\n\r\n{1}";
                    if (map != null)
                    {
                        foreach (string key in map.Keys)
                        {
                            stream.Write(boundarybytes, 0, boundarybytes.Length);
                            string formitem = string.Format(formdataTemplate, key, map[key]);
                            byte[] formitembytes = Encoding.GetEncoding("UTF-8").GetBytes(formitem);
                            stream.Write(formitembytes, 0, formitembytes.Length);
                        }
                    }
                    stream.Write(endbytes, 0, endbytes.Length);
                }
                //2.WebResponse
                HttpWebResponse response = request.GetResponse() as HttpWebResponse;
                using (Stream responsestream = response.GetResponseStream())
                {
                    using (StreamReader sr = new StreamReader(responsestream))
                    {
                        content = sr.ReadToEnd();
                    }
                }
            }
            catch (Exception ex)
            {
                content = ex.Message;
            }
            return content;
        }

        /// <summary>
        /// JSON格式转Dictionary
        /// </summary>
        /// <param name="jsonStr"></param>
        /// <returns></returns>
        public static Dictionary<string, string> JsonStringToKeyValuePairs(string jsonStr)
        {
            char jsonBeginToken = '{';
            char jsonEndToken = '}';

            if (string.IsNullOrEmpty(jsonStr))
            {
                return null;
            }
            //验证json字符串格式
            if (jsonStr[0] != jsonBeginToken || jsonStr[jsonStr.Length - 1] != jsonEndToken)
            {
                throw new ArgumentException("非法的Json字符串!");
            }

            var resultDic = new Dictionary<string, string>();
            var jobj = JObject.Parse(jsonStr);
            JsonOn(jobj, resultDic);
            return resultDic;
        }

        private static Dictionary<string, string> JsonOn(JToken jobT, Dictionary<string, string> Dic)
        {

            //找出包含嵌套的字段列
            if (jobT is JObject jobj && jobj.Properties().Count() > 0)
            {
                foreach (var item in jobj.Properties())
                {
                    JsonProperties(item, Dic);
                }
            }
            else
            {
                Dic.Add(jobT.Path, jobT.ToString());

                return Dic;
            }
            return Dic;
        }

        private static Dictionary<string, string> JsonProperties(JProperty jobj, Dictionary<string, string> Dic)
        {
            return JsonOn(jobj.Value, Dic);
        }

    }
}
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
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167

b. 服务器方法同1.b 这里不再赘述

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/你好赵伟/article/detail/748390