在Core环境下用WebRequest连接上远程的web Api 实现数据的简单CRUD(附Git地址)

root

1 using Microsoft.AspNetCore.Mvc;　　

2 using Newtonsoft.Json;　　

3 using Newtonsoft.Json.Linq;　　

4 using System;　　

5 using System.Collections.Generic;　　

6 using System.IO;　　

7 using System.Linq;　　

8 using System.Net;　　

9 using System.Net.Http;　　

10 using System.Net.Http.Headers;　　

11 using System.Text;　　

12 using System.Threading.Tasks;　　

13 using TestAPI.Models;　　

14　　
15 namespace TestAPI.Controllers
　　
16 {

　　
17     public>　　
18     {
　　
19         #region 成员变量
　　
20         //这个baseURL是我的webApi的地址
　　
21         private static string baseURL = "http://localhost:56853/api/users";
　　
22         //用于存放所有的用户
　　
23         private static IList<Users> _context;
　　
24
　　
25         #endregion
　　
26
　　
27         #region 构造函数
　　
28         public UsersController()
　　
29         {
　　
30             //实例化对象
　　
31             _context = new List<Users>();
　　
32             //获取所有的用户的信息
　　
33             _context = GetAllUserList();
　　
34
　　
35         }
　　
36
　　
37         #endregion
　　
38
　　
39         #region 类内方法
　　
40
　　
41
　　
42         ///  https://docs.microsoft.com/en-us/aspnet/web-api/overview/advanced/calling-a-web-api-from-a-net-client
　　
43
　　
44
　　
45
　　
46         /// <summary>
　　
47         /// 通过api获取所有的用户的信息
　　
48         /// </summary>
　　
49         /// <returns>JSON String</returns>
　　
50         private string GetALLUserInfoFromAPI()
　　
51         {
　　
52             HttpClient client = new HttpClient();
　　
53             var con = client.GetStringAsync(baseURL);
　　
54             return con.Result;
　　
55         }
　　
56
　　
57         private string UsersConvertToJson(Users u)
　　
58         {
　　
59             return JsonConvert.SerializeObject(u);
　　
60         }
　　
61         /// <summary>
　　
62         /// 传递数据到远程API的数据库中
　　
63         /// </summary>
　　
64         /// <param name="u"></param>
　　
65         /// <returns></returns>
　　
66         private async Task<string> CreateAsync(Users u)
　　
67         {
　　
68             string url = baseURL;
　　
69             string requestMethod = "post";
　　
70             return await HandleData(u, url, requestMethod);
　　
71         }
　　
72
　　
73         private async Task<string> UpdateAsync(Users u)
　　
74         {
　　
75             string url = baseURL + @"/" + u.ID;
　　
76             string requestMethod = "put";
　　
77             return await HandleData(u, url, requestMethod);
　　
78         }
　　
79         /// <summary>
　　
80         /// 处理数据
　　
81         /// </summary>
　　
82         /// <param name="Data">User实体类</param>
　　
83         /// <param name="Url">远程API的URL</param>
　　
84         /// <param name="RequestMethod">请求的方法</param>
　　
85         /// <returns></returns>
　　
86         private async Task<string> HandleData(Users Data, string Url, string RequestMethod)
　　
87         {
　　
88             string UsersJson = UsersConvertToJson(Data);
　　
89             var request = WebRequest.CreateHttp(Url);
　　
90             request.Accept = "application/json";
　　
91             //下边这行不设置会出现无法识别mediaType 415 这个错误
　　
92             request.ContentType = "application/json";
　　
93             request.Method = RequestMethod;
　　
94             //向request提交数据
　　
95             using (StreamWriter writer = new StreamWriter(await request.GetRequestStreamAsync()))
　　
96             {
　　
97                 writer.Write(UsersJson);
　　
98             }
　　
99             //获取响应
　　
100             var reponse = await request.GetResponseAsync();
　　
101             //返回响应数据
　　
102             using (StreamReader reader = new StreamReader(reponse.GetResponseStream()))
　　
103             {
　　
104                 return reader.ReadToEnd();
　　
105             }
　　
106         }
　　
107         private async Task<string> DeleteAsync(Users u)
　　
108         {
　　
109             string url = baseURL + @"/" + u.ID;
　　
110             string requestMethod = "delete";
　　
111             return await HandleData(u, url, requestMethod);
　　
112         }

　　
113         private bool UsersExist(int>　　
114         {

　　
115             return _context.Any(u => u.ID ==>　　
116         }
　　
117
　　
118         /// <summary>
　　
119         /// 获取所有用户的List
　　
120         /// </summary>
　　
121         private IList<Users> GetAllUserList()
　　
122         {
　　
123             IList<Users> userslist = new List<Users>();
　　
124             var JsonString = GetALLUserInfoFromAPI();
　　
125             JArray UsersArray = JArray.Parse(JsonString);
　　
126             for (int i = 0; i < UsersArray.Count; i++)
　　
127             {
　　
128                 userslist.Add(StringConvertToUser(UsersArray.ToString()));
　　
129             }
　　
130             return userslist;
　　
131         }
　　
132         /// <summary>
　　
133         /// 将Json对象的字符串转化为users对象
　　
134         /// </summary>
　　
135         /// <param name="JsonString">json对象的字符串</param>
　　
136         /// <returns>Users对象</returns>
　　
137         private Users StringConvertToUser(string JsonString)
　　
138         {
　　
139             return JsonConvert.DeserializeObject<Users>(JsonString);
　　
140         }
　　
141         #endregion
　　
142
　　
143         #region Index
　　
144         // GET: Users
　　
145         public async Task<IActionResult> Index()
　　
146         {
　　
147             return View(_context);
　　
148         }
　　
149
　　
150
　　
151
　　
152         #endregion
　　
153
　　
154         #region Details
　　
155
　　
156         // GET: Users/Details/5

　　
157         public async Task<IActionResult> Details(int?>　　
158         {
　　
159             if (id == null)
　　
160             {
　　
161                 return BadRequest();
　　
162             }

　　
163             var users = _context.FirstOrDefault(u => u.ID ==>　　
164             if (users == null)
　　
165             {
　　
166                 return NotFound();
　　
167             }
　　
168             return View(users);
　　
169         }
　　
170
　　
171         #endregion
　　
172
　　
173         #region Create
　　
174
　　
175         // GET: Users/Create
　　
176         public IActionResult Create()
　　
177         {
　　
178             return View();
　　
179         }
　　
180
　　
181         // POST: Users/Create
　　
182         // To protect from overposting attacks, please enable the specific properties you want to bind to, for
　　
183         // more details see http://go.microsoft.com/fwlink/?LinkId=317598.
　　
184         [HttpPost]
　　
185         [ValidateAntiForgeryToken]
　　
186         public async Task<IActionResult> Create([Bind("ID,name,pwd")] Users users)
　　
187         {
　　
188             if (ModelState.IsValid)
　　
189             {
　　
190
　　
191                 await CreateAsync(users);
　　
192                 return RedirectToAction("Index");
　　
193             }
　　
194             return View();
　　
195         }
　　
196
　　
197         #endregion
　　
198
　　
199         #region Edit
　　
200
　　
201         // GET: Users/Edit/5

　　
202         public async Task<IActionResult> Edit(int?>　　
203         {
　　
204             if (id == null)
　　
205             {
　　
206                 return BadRequest();
　　
207             }

　　
208             var users = _context.FirstOrDefault(u => u.ID ==>　　
209             if (users == null)
　　
210             {
　　
211                 return NotFound();
　　
212             }
　　
213             return View(users);
　　
214         }
　　
215
　　
216         // POST: Users/Edit/5
　　
217         // To protect from overposting attacks, please enable the specific properties you want to bind to, for
　　
218         // more details see http://go.microsoft.com/fwlink/?LinkId=317598.
　　
219         [HttpPost]
　　
220         [ValidateAntiForgeryToken]

　　
221         public async Task<IActionResult> Edit(int>　　
222         {
　　
223
　　
224             if (ModelState.IsValid)
　　
225             {
　　
226                 if (id != users.ID)
　　
227                 {
　　
228                     return BadRequest();
　　
229                 }
　　
230                 try
　　
231                 {
　　
232                     await UpdateAsync(users);
　　
233                     return RedirectToAction("Index");
　　
234                 }
　　
235                 catch
　　
236                 {
　　
237                     if (UsersExist(users.ID))
　　
238                     {
　　
239                         return NotFound();
　　
240                     }
　　
241                     throw;
　　
242                 }
　　
243
　　
244             }
　　
245             return View();
　　
246         }
　　
247
　　
248
　　
249         #endregion
　　
250
　　
251         #region Delete
　　
252
　　
253
　　
254         // GET: Users/Delete/5

　　
255         public async Task<IActionResult> Delete(int?>　　
256         {
　　
257             if (id == null)
　　
258             {
　　
259                 return BadRequest();
　　
260             }

　　
261             var users = _context.FirstOrDefault(u => u.ID ==>　　
262             if (users == null)
　　
263             {
　　
264                 return NotFound();
　　
265             }
　　
266
　　
267             return View(users);
　　
268         }
　　
269
　　
270         // POST: Users/Delete/5
　　
271         [HttpPost, ActionName("Delete")]
　　
272         [ValidateAntiForgeryToken]

　　
273         public async Task<IActionResult> DeleteConfirmed(int>　　
274         {

　　
275             var users = _context.SingleOrDefault(u => u.ID ==>　　
276             await DeleteAsync(users);
　　
277             return RedirectToAction("Index");
　　
278         }
　　
279         #endregion
　　
280
　　
281     }
　　
282 }