通過HTTP請求WEBAPI的方式

　　平時工作中長期需要用到通過HTTP調用API進行數據獲取以及文件上傳下載(C#,JAVA...都會用到)。這里獲取的是包括網頁的所有信息。如果單純需要某些數據內容。可以自己構造函數甄別摳除出來！一般的做法是根據源碼的格式，用正則來過濾出你需要的內容部分。

　　C#中的調用：

　　　　方式一：webclient和httpclient

　　　　方式二：WebRequest和webresponse

　　　　方式三：通過js 直接訪問api接口，頁面通過jquery調用

　　　　方式四：WebBrowser

1.webclient和httpclient

　　實例①

#region webclient應用
        #region Controllers
        MyImageServerEntities db = new MyImageServerEntities();
        public ActionResult Index()
        {
            return View();
        }
        public ActionResult FileUpload()
        {
            HttpPostedFileBase file = Request.Files["fileUp"];
            string fileName = Path.GetFileName(file.FileName);
            string fileExt = Path.GetExtension(fileName);
            if (fileExt == ".jpg")
            {
                var list = db.ImageServerInfo.Where<ImageServerInfo>(u => u.FlgUsable == true).ToList();//找出可用的圖片服務器.
                int count = list.Count();
                Random random = new Random();
                int r = random.Next();
                int i = r % count;
                string serverUrl = list[i].ServerUrl;
                int serverId = list[i].ServerId;
                string url = "http://" + serverUrl + "/FileUp.ashx?serverId=" + serverId + "&fileExt=" + fileExt;
                WebClient webClient = new WebClient();
                webClient.UploadData(url, StreamToBytes(file.InputStream));

            }
            return Content("ok");

        }
        public ActionResult ShowImage()
        {
            var list = db.ImageServerInfo.Where<ImageServerInfo>(c => c.FlgUsable == true).ToList();
            ViewData["imageServerList"] = list;
            return View();
        }
        private byte[] StreamToBytes(Stream stream)
        {
            byte[] buffer = new byte[stream.Length];
            stream.Read(buffer, 0, buffer.Length);
            stream.Seek(0, SeekOrigin.Begin);
            return buffer;
        }
        #endregion

        #region Model
        context.Response.ContentType = "text/plain"; 
        int serverId = int.Parse(context.Request["serverId"]);
        string fileExt = context.Request["fileExt"];
        string dir = "/ImagePath/" + DateTime.Now.Year + "/" + DateTime.Now.Month + "/" + DateTime.Now.Day + "/";
        Directory.CreateDirectory(Path.GetDirectoryName(context.Request.MapPath(dir))); 
        string newfileName = Guid.NewGuid().ToString();
        string fullDir = dir + newfileName + fileExt;
        using (FileStream fileStream = File.Open(context.Request.MapPath(fullDir), FileMode.OpenOrCreate)) 
        { 
            context.Request.InputStream.CopyTo(fileStream);     
            MyImageServerEntities db = new MyImageServerEntities();
            ImageInfo imageInfo = new ImageInfo();
            imageInfo.ImageName = fullDir;     
            imageInfo.ImageServerId = serverId;     
            db.ImageInfo.Add(imageInfo);    
            db.SaveChanges(); 
         }
#endregion
#endregion

#region httpclient
創建並初始化對象：
    client.BaseAddress = new Uri(url);
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));

讀集合：
    HttpResponseMessage response = client.GetAsync(url).Result;
var userList = response.Content.ReadAsAsync<IEnumerable<數據類型>>().Result;

根據編號讀對象
    HttpResponseMessage response1 = client.GetAsync(url).Result;
    var userInfo = response1.Content.ReadAsAsync<數據類型>().Result;

增加：
    HttpResponseMessage response = client.PostAsJsonAsync("api/userinfo", userInfo).Result;
使用response.IsSuccessStatusCode判斷是否成功
使用response.Content.ToString()獲取返回值

修改：
     HttpResponseMessage response = client.PutAsJsonAsync("api/userinfo/" + userInfo.UserId, userInfo).Result;
使用response.IsSuccessStatusCode判斷是否成功
使用response.Content.ToString()獲取返回值

刪除：
    HttpResponseMessage response = client.DeleteAsync("api/userinfo/" + uid).Result;
使用response.IsSuccessStatusCode判斷是否成功
使用response.Content.ToString()獲取返回值
        #endregion

　　實例②

WebClient獲取網頁數據：
            //using System.IO;
            try
            {
                WebClient webClient = new WebClient();
                webClient.Credentials = CredentialCache.DefaultCredentials;//獲取或設置用於向Internet資源的請求進行身份驗證的網絡憑據
                Byte[] pageData = webClient.DownloadData("http://www.360doc.com/content/11/0427/03/1947337_112596569.shtml");
                //string pageHtml = Encoding.Default.GetString(pageData);  //如果獲取網站頁面采用的是GB2312，則使用這句       
                string pageHtml = Encoding.UTF8.GetString(pageData); //如果獲取網站頁面采用的是UTF-8，則使用這句
                using (StreamWriter sw = new StreamWriter("e:\\ouput.txt"))//將獲取的內容寫入文本
                {
                    htm = sw.ToString();//測試StreamWriter流的輸出狀態，非必須
                    sw.Write(pageHtml);
                }
            }
            catch (WebException webEx)
            {
                Console.W
            }

如果為了實際項目的效率考慮，需要考慮在函數中分配一個內存區域。大概寫法如下：
//MemoryStream是一個支持儲存區為內存的流。
 byte[] buffer = new byte[1024];
 using (MemoryStream memory = new MemoryStream())
    {
    int index = 1, sum = 0;
    while (index * sum < 100 * 1024)
    {
       index = reader.Read(buffer, 0, 1024);
       if (index > 0)
       {
           memory.Write(buffer, 0, index);
            sum += index;
       }
    }
    //網頁通常使用utf-8或gb2412進行編碼
    Encoding.GetEncoding("gb2312").GetString(memory.ToArray());
    if (string.IsNullOrEmpty(html))
    {
        return html;
    }
    else
    {
        Regex re = new Regex(@"charset=(? charset[/s/S]*?)[ |']");
        Match m = re.Match(html.ToLower());
        encoding = m.Groups[charset].ToString();
    }
    if (string.IsNullOrEmpty(encoding) || string.Equals(encoding.ToLower(), "gb2312"))
    {
       return html;
    }
}

　　實例③

使用WebClient進行文件下載，這里使用了Task異步方式，也可以改為普通方法或靜態方法：
/// <summary>
/// 下載文件
/// </summary>
/// <param name="fileUrl">文件地址</param>
/// <param name="filePath">文件的本地路徑</param>
/// <returns>文件在本地的存儲路徑</returns>
private Task GetFileLocalPath(string fileUrl, string filePath)
{
    return Task.Run(() =>
    {
        try
        {
            using (var mc = new WebClient())
            {
                mc.DownloadFile(new Uri(fileUrl), filePath);
            }
        }
        catch (Exception ex)
        {
            LogHelper.WriteErrorLog("下載文件時出現異常。", ex);
        }
    });
}

/// <summary>
/// 下載文件
/// </summary>
/// <param name="fileUrl">文件地址</param>
/// <param name="filePath">文件的本地路徑</param>
/// <returns>文件在本地的存儲路徑</returns>
private Task DownloadFile(string fileUrl, string filePath)
{
    return Task.Run(() =>
    {
        try
        {
            using (var webClient = new WebClient())
            {
                var netStream = webClient.OpenRead(fileUrl);
                if (netStream != null)
                {
                    FileStream fstr = new FileStream(filePath, FileMode.OpenOrCreate, FileAccess.Write);
                    byte[] readbyte = new byte[102400];
                    int realReadLen = netStream.Read(readbyte, 0, readbyte.Length);
                    while (realReadLen > 0)
                    {
                        fstr.Write(readbyte, 0, realReadLen);
                        realReadLen = netStream.Read(readbyte, 0, readbyte.Length);
                        Thread.Sleep(10);
                    }
                    netStream.Dispose();
                    fstr.Flush();
                    fstr.Close();
                }
            }
        }
        catch (Exception ex)
        {
            LogHelper.WriteErrorLog("下載文件時出現異常。", ex);
        }
    });
}

HttpClient，這個類提供的都是異步方法，下面包含了POST、GET、PUT、DELETE四個方法，還有一個SEND方法稍加改動即可實現：
public static async void AsyncPost(string url, string body, Action<RequestResult> callback, int timeoutSeconds = 10)
{
    var requestResult = new RequestResult();
    if (!IsConnectedInternet())
    {
        requestResult.Message = "網絡連接錯誤，請稍后再試。";
        callback?.Invoke(requestResult);
        return;
    }

    try
    {
        using (var client = new HttpClient())
        {
            client.DefaultRequestHeaders.Add("authorization", "LJQfL1A2oeP2fuEiOHo6");
            client.Timeout = new TimeSpan(0, 0, timeoutSeconds);
            //byte[] requestBody = Encoding.UTF8.GetBytes(body);
            HttpContent content = new StringContent(body);
            content.Headers.ContentType = new MediaTypeHeaderValue("application/json");
            var response = await client.PostAsync(url, content);
            //確保HTTP成功狀態值
            response.EnsureSuccessStatusCode();
            //await異步讀取最后的JSON
            await response.Content.ReadAsStringAsync().ContinueWith(t =>
            {
                if (t.IsCompleted)
                {
                    requestResult.IsSuccess = true;
                    requestResult.Result = t.Result;
                    callback?.Invoke(requestResult);
                }
            });
        }
    }
    catch (Exception e)
    {
        if (e.InnerException != null)
            requestResult.Message = e.InnerException.Message;
        else if (e.Message.Contains("已取消一個任務"))
            requestResult.Message = "連接服務器超時，請重試";
        else if (e.Message.Contains("404"))
            requestResult.Message = "連接服務器404，請重試";
        else
            requestResult.Message = e.Message;
        callback?.Invoke(requestResult);
    }
}

public static async void AsyncGet(string url, Action<RequestResult> callback, int timeoutSeconds = 10)
{
    var requestResult = new RequestResult();
    if (!IsConnectedInternet())
    {
        requestResult.Message = "網絡連接錯誤，請稍后再試。";
        callback?.Invoke(requestResult);
        return;
    }

    try
    {
        using (var client = new HttpClient())
        {
            client.DefaultRequestHeaders.Add("authorization", "LJQfL1A2oeP2fuEiOHo6");
            client.Timeout = new TimeSpan(0, 0, timeoutSeconds);
            var response = await client.GetAsync(url);
            //確保HTTP成功狀態值
            response.EnsureSuccessStatusCode();
            //await異步讀取最后的JSON
            await response.Content.ReadAsStringAsync().ContinueWith(t =>
            {
                if (t.IsCompleted)
                {
                    requestResult.IsSuccess = true;
                    requestResult.Result = t.Result;
                    callback?.Invoke(requestResult);
                }
            });
        }
    }
    catch (Exception e)
    {
        if (e.InnerException != null)
            requestResult.Message = e.InnerException.Message;
        else if (e.Message.Contains("已取消一個任務"))
            requestResult.Message = "連接服務器超時，請重試";
        else if (e.Message.Contains("404"))
            requestResult.Message = "連接服務器404，請重試";
        else
            requestResult.Message = e.Message;
        callback?.Invoke(requestResult);
    }
}

public static async void AsyncPut(string url, string body, Action<RequestResult> callback, int timeoutSeconds = 10)
{
    var requestResult = new RequestResult();
    if (!IsConnectedInternet())
    {
        requestResult.Message = "網絡連接錯誤，請稍后再試。";
        callback?.Invoke(requestResult);
        return;
    }

    try
    {
        using (var client = new HttpClient())
        {
            client.DefaultRequestHeaders.Add("authorization", "LJQfL1A2oeP2fuEiOHo6");
            client.Timeout = new TimeSpan(0, 0, timeoutSeconds);
            HttpContent content = new StringContent(body);
            content.Headers.ContentType = new MediaTypeHeaderValue("application/json");
            var response = await client.PutAsync(url, content);
            //確保HTTP成功狀態值
            response.EnsureSuccessStatusCode();
            //await異步讀取最后的JSON
            await response.Content.ReadAsStringAsync().ContinueWith(t =>
            {
                if (t.IsCompleted)
                {
                    requestResult.IsSuccess = true;
                    requestResult.Result = t.Result;
                    callback?.Invoke(requestResult);
                }
            });
        }
    }
    catch (Exception e)
    {
        if (e.InnerException != null)
            requestResult.Message = e.InnerException.Message;
        else if (e.Message.Contains("已取消一個任務"))
            requestResult.Message = "連接服務器超時，請重試";
        else if (e.Message.Contains("404"))
            requestResult.Message = "連接服務器404，請重試";
        else
            requestResult.Message = e.Message;
        callback?.Invoke(requestResult);
    }
}

public static async void AsyncDelete(string url, Action<RequestResult> callback, int timeoutSeconds = 10)
{
    var requestResult = new RequestResult();
    if (!IsConnectedInternet())
    {
        requestResult.Message = "網絡連接錯誤，請稍后再試。";
        callback?.Invoke(requestResult);
        return;
    }

    try
    {
        using (var client = new HttpClient())
        {
            client.DefaultRequestHeaders.Add("authorization", "LJQfL1A2oeP2fuEiOHo6");
            client.Timeout = new TimeSpan(0, 0, timeoutSeconds);
            var response = await client.DeleteAsync(url);
            //確保HTTP成功狀態值
            response.EnsureSuccessStatusCode();
            //await異步讀取最后的JSON
            await response.Content.ReadAsStringAsync().ContinueWith(t =>
            {
                if (t.IsCompleted)
                {
                    requestResult.IsSuccess = true;
                    requestResult.Result = t.Result;
                    callback?.Invoke(requestResult);
                }
            });
        }
    }
    catch (Exception e)
    {
        if (e.InnerException != null)
            requestResult.Message = e.InnerException.Message;
        else if (e.Message.Contains("已取消一個任務"))
            requestResult.Message = "連接服務器超時，請重試";
        else if (e.Message.Contains("404"))
            requestResult.Message = "連接服務器404，請重試";
        else
            requestResult.Message = e.Message;
        callback?.Invoke(requestResult);
    }
}

上面使用到的RequestResult類：
public class RequestResult : IDisposable
{
    public bool IsSuccess { get; set; }

    public string Result { get; set; }

    public string Message { get; set; }

    public RequestResult(bool isSuccess = false, string result = "", string message = "")
    {
        IsSuccess = isSuccess;
        Result = result;
        Message = message;
    }

    ~RequestResult()
    {
        Dispose();
    }

    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this);//不需要再調用本對象的Finalize方法
    }

    protected virtual void Dispose(Boolean disposing)
    {
        if (disposing)
        {
            //--- 清理托管資源 ---//
        }

        //--- 清理非托管資源 ---//
    }
}

2.WebRequest和webresponse

　　實例①

   public void GetHtml()
        {
            var url = "http://www.360doc.com/content/11/0427/03/1947337_112596569.shtml";
            string strBuff = "";//定義文本字符串，用來保存下載的html
            int byteRead = 0; 
            
            HttpWebRequest webRequest = (HttpWebRequest)WebRequest.Create(url);
            HttpWebResponse webResponse = (HttpWebResponse)webRequest.GetResponse();
            //若成功取得網頁的內容，則以System.IO.Stream形式返回，若失敗則產生ProtoclViolationException錯 誤。在此正確的做法應將以下的代碼放到一個try塊中處理。這里簡單處理 
            Stream reader = webResponse.GetResponseStream();
            ///返回的內容是Stream形式的，所以可以利用StreamReader類獲取GetResponseStream的內容，並以StreamReader類的Read方法依次讀取網頁源程序代碼每一行的內容，直至行尾（讀取的編碼格式：UTF8）
            StreamReader respStreamReader = new StreamReader(reader,Encoding.UTF8);
 
            ///分段，分批次獲取網頁源碼
            char[] cbuffer = new char[1024];
            byteRead = respStreamReader.Read(cbuffer,0,256);
 
            while (byteRead != 0)
            {
                string strResp = new string(char,0,byteRead);
                strBuff = strBuff + strResp;
                byteRead = respStreamReader.Read(cbuffer,0,256);
            }
            using (StreamWriter sw = new StreamWriter("e:\\ouput.txt"))//將獲取的內容寫入文本
            {
                htm = sw.ToString();//測試StreamWriter流的輸出狀態，非必須
                sw.Write(strBuff);
            }
        }

　　實例②

WebRequest的方式（該方式是post請求的時候傳入json字符串轉換成流的形式，無需再將json轉換成需要的實體對象了），所以這種方式只需寫一個公共的方法，每次調用的時候傳入地址和參數即可
公共方法如下：
public class WebRequestHelper
    {
        public static string GetRequest(string url)
        {
            string responseStr = string.Empty;


            WebRequest request = WebRequest.Create(url);
            request.Method = "Get";
            var response = request.GetResponse();
            Stream ReceiveStream = response.GetResponseStream();
            using (StreamReader stream = new StreamReader(ReceiveStream, Encoding.UTF8))
            {
                responseStr = stream.ReadToEnd();
            }

            return responseStr;
        }

        public static string PostRequest(string url, string postParameter)
        {
            string responseStr = string.Empty;

            WebRequest request = WebRequest.Create(url);
            request.Method = "Post";
            request.ContentType = "application/json";

            byte[] requestData = System.Text.Encoding.UTF8.GetBytes(postParameter);
            request.ContentLength = requestData.Length;

            Stream newStream = request.GetRequestStream();
            newStream.Write(requestData, 0, requestData.Length);
            newStream.Close();

            var response = request.GetResponse();
            Stream ReceiveStream = response.GetResponseStream();
            using (StreamReader stream = new StreamReader(ReceiveStream, Encoding.UTF8))
            {
                responseStr = stream.ReadToEnd();
            }

            return responseStr;
        }

        /// <summary>
        /// Http的 WebRequest的特定實現
        /// </summary>
        /// <param name="Url"></param>
        /// <param name="JSONData"></param>
        /// <returns></returns>
        public static string GetResponseData(string Url, string JSONData)
        {
            byte[] bytes = Encoding.UTF8.GetBytes(JSONData);
            HttpWebRequest request = (HttpWebRequest)WebRequest.Create(Url);
            request.Method = "POST";
            request.ContentLength = bytes.Length;
            request.ContentType = "application/json";
            Stream reqstream = request.GetRequestStream();
            reqstream.Write(bytes, 0, bytes.Length);

            //聲明一個HttpWebRequest請求  
            request.Timeout = 90000;
            //設置連接超時時間  
            request.Headers.Set("Pragma", "no-cache");
            HttpWebResponse response = (HttpWebResponse)request.GetResponse();
            Stream streamReceive = response.GetResponseStream();
            Encoding encoding = Encoding.UTF8;

            StreamReader streamReader = new StreamReader(streamReceive, encoding);
            string strResult = streamReader.ReadToEnd();
            streamReceive.Dispose();
            streamReader.Dispose();

            return strResult;
        }
    }

調用的使用方法

（1）Get請求

public ActionResult GetAll()
        {
            string result = WebRequestHelper.GetRequest(url + "api/goods/getlist?pageindex=0&pagesize=10");
            JavaScriptSerializer Serializer = new JavaScriptSerializer();
            var items = Serializer.DeserializeObject(result);
            return Json(items);
        }

（2）Post請求

[HttpPost]
        public ActionResult AddGood(string paramObj)
        {
            string result = WebRequestHelper.PostRequest(url + "api/goods/add", paramObj);
            JavaScriptSerializer Serializer = new JavaScriptSerializer();
            var items = Serializer.DeserializeObject(result);
            return Json(items);
        }

　　實例③

HttpWebRequest：
/// <summary>
/// 向服務器發送Request
/// </summary>
/// <param name="url">字符串</param>
/// <param name="method">枚舉類型的方法Get或者Post</param>
/// <param name="body">Post時必須傳值</param>
/// <param name="timeoutSeconds">超時時間，單位秒</param>
/// <returns></returns>
public static string Request(string url, MethodEnum method, string body = "", int timeoutSeconds = 15000)
{
    if (!IsConnectedInternet())
        return "網絡連接錯誤，請稍后再試。";

    try
    {
        GC.Collect();
        HttpWebRequest request = (HttpWebRequest)WebRequest.Create(url);
        request.Timeout = timeoutSeconds;
        request.Method = method.ToString();
        //如果是Post的話，則設置body
        if (method == MethodEnum.POST)
        {
            request.ContentType = "application/json";
            request.KeepAlive = false;
            byte[] requestBody = Encoding.UTF8.GetBytes(body);
            request.ContentLength = requestBody.Length;

            Stream requestStream = request.GetRequestStream();
            requestStream.Write(requestBody, 0, requestBody.Length);
        }

        return Response(request);
    }
    catch (Exception ex)
    {
        if (ex.InnerException != null)
            return ex.InnerException.Message;
        if (ex.Message.Contains("已取消一個任務"))
            return "連接服務器超時，請重試";
        if (ex.Message.Contains("404"))
            return "連接服務器404，請重試";
        return ex.Message;
    }
}

HttpWebResponse：
/// <summary>
/// 返回Response數據
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
private static string Response(HttpWebRequest request)
{
    HttpWebResponse response = (HttpWebResponse)request.GetResponse();

    string jsonRead = "";

    if (response.StatusCode != HttpStatusCode.OK)
    {
        return response.StatusCode.ToString();
    }
    //接收過程
    if (response.GetResponseStream() != null)
    {
        StreamReader myStreamReader = new StreamReader(response.GetResponseStream() ?? Stream.Null, Encoding.UTF8);
        jsonRead = myStreamReader.ReadToEnd();
        myStreamReader.Close();
    }
    response.Close();
    request.Abort();

    return jsonRead;
}

上面兩個方法需要配合使用，皆為同步方式。當然也可以將上面兩個方法合並到一個方法中，可以參見接下來這個方法。

另外是使用HttpWebRequest和HttpWebResponse進行文件上傳，采用同步方法異步回調方式：

public static void UploadFile(string url, string filePath, string fileName, 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;

    //文件
    FileStream fileStream = new FileStream(filePath, FileMode.Open, FileAccess.Read);
    BinaryReader binaryReader = new BinaryReader(fileStream);

    //頭信息
    string boundary = "--" + timeStamp;
    string dataFormat = boundary + "\r\nContent-Disposition: form-data; name=\"{0}\";filename=\"{1}\"\r\nContent-Type:application/octet-stream\r\n\r\n";
    string header = string.Format(dataFormat, "file", Path.GetFileName(filePath));
    byte[] postHeaderBytes = Encoding.UTF8.GetBytes(header);

    //結束邊界
    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();

        string returnValue = "";
        //獲取服務器端的響應
        using (HttpWebResponse response = (HttpWebResponse)httpReq.GetResponse())
        {
            Stream receiveStream = response.GetResponseStream();
            StreamReader readStream = new StreamReader(receiveStream, Encoding.UTF8);
            returnValue = readStream.ReadToEnd();
            response.Close();
            readStream.Close();
        }
        
        callback?.Invoke(returnValue);
    }
    catch (Exception)
    {
        callback?.Invoke("");
    }
    finally
    {
        fileStream.Close();
        binaryReader.Close();
    }
}

上面還用到一個enum叫MethodEnum，包含GET和POST兩個枚舉值。
還有一個比較特殊的POST方法：
public static string HttpPostFormData(string url, Dictionary<string, string> dic)
{
    try
    {
        GC.Collect();
        // 時間戳，用做boundary
        string timeStamp = DateTime.Now.Ticks.ToString("x");
        string boundary = "----" + timeStamp;

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

        var stream = new MemoryStream();

        //頭信息
        string dataFormat = "--" + boundary + "\r\nContent-Disposition: form-data; name=\"{0}\"\r\n\r\n{1}\r\n";
        foreach (string key in dic.Keys)
        {
            string s = string.Format(dataFormat, key, dic[key]);
            byte[] data = Encoding.UTF8.GetBytes(s);
            stream.Write(data, 0, data.Length);
        }

        //結束邊界
        byte[] boundaryBytes = Encoding.ASCII.GetBytes("--" + boundary + "--");
        stream.Write(boundaryBytes, 0, boundaryBytes.Length);

        request.ContentLength = stream.Length;//請求內容長度

        Stream requestStream = request.GetRequestStream(); //寫入請求數據
        stream.Position = 0L;
        stream.CopyTo(requestStream);
        stream.Close();

        requestStream.Close();

        return Response(request);
    }
    catch (Exception e)
    {
        return e.Message;
    }
}

3.通過js 直接訪問api接口，頁面通過jquery調用

$.ajax({
            type: "get",
            url: "/goods/getall",
            dataType: "json",
            data: null,
            //data: JSON.stringify({
            //    id: "382accff-57b2-4d6e-ae84-a61e00a3e3b6"
            //}),
            contentType: "application/json;charset-utf-8",
            success: function (data) {
                console.log(data);
            }
        });

        var paramObj = { Id: "382accff-57b2-4d6e-ae84-a61e00a3e3b8",Category:111};


        $.ajax({
            type: "post",
            url: "/goods/AddGood",
            dataType: "json",
            //data: null,
            data: JSON.stringify({
                paramObj: JSON.stringify(paramObj)
            }),
            contentType: "application/json;charset-utf-8",
            success: function (data) {
                console.log(data);
            }
        });

4.WebBrowser

相對來說，這是一種最簡單的獲取方式。拖WebBrowser控件進去，然后匹配下面這段代碼：
WebBrowser web = new WebBrowser();
web.Navigate("http://www.163.com");
web.DocumentCompleted += new WebBrowserDocumentCompletedEventHandler(web_DocumentCompleted);
void web_DocumentCompleted(object sender, WebBrowserDocumentCompletedEventArgs e)
{
     WebBrowser web = (WebBrowser)sender;
     HtmlElementCollection ElementCollection = web.Document.GetElementsByTagName("Table");
     foreach (HtmlElement item in ElementCollection)
     {
         File.AppendAllText("Kaijiang_xj.txt", item.InnerText);
     }
}

 

拓展(自己總結)：WebRequset和WebResponse

#region Post&&Get獨立的方式
        #region Post

        /// <summary>
        /// Post
        /// </summary>
        /// <param name="url">url地址</param>
        /// <param name="soapbody">提交的數據(XML字符串)</param>
        /// <param name="HeadersInfo">頭信息</param>
        /// <param name="ContentType">格式</param>
        /// <param name="userName">賬號</param>
        /// <param name="passWord">密碼</param>
        /// <returns></returns>
        public static String PostHTTP(string url, string soapbody, WebHeaderCollection HeadersInfo, string userName, string passWord)
        {
            string Result = string.Empty;
            try
            {
                HttpWebRequest webRequst = (HttpWebRequest)HttpWebRequest.Create(url);//創建URL
                webRequst.Method = "POST";//Post方式
                webRequst.Headers.Add(HeadersInfo);
                SetHeaderValue(webRequst.Headers, "Connection", "keep-alive");
                SetHeaderValue(webRequst.Headers, "Content-Length", soapbody.Length.ToString());
                SetHeaderValue(webRequst.Headers, "Accept", "*/*");
                SetHeaderValue(webRequst.Headers, "Cache-Control", "no-cache");
                SetHeaderValue(webRequst.Headers, "ProtocolVersion", "1.1");
                SetHeaderValue(webRequst.Headers, "User-Agent", "Provider User-Agent name");
                SetHeaderValue(webRequst.Headers, "Origin", "xxxxxx");
                SetHeaderValue(webRequst.Headers, "Authorization", "Basic " + Convert.ToBase64String(new ASCIIEncoding().GetBytes(userName + ":" + passWord)));

                //這個在Post的時候，一定要加上，如果服務器返回錯誤，他還會繼續再去請求，不會使用之前的錯誤數據，做返回數據
                webRequst.ServicePoint.Expect100Continue = false;

                //指定安全協議為3.0
                ServicePointManager.SecurityProtocol = SecurityProtocolType.Ssl3;

                using (Stream s = webRequst.GetRequestStream())
                {
                    using (StreamWriter sw = new StreamWriter(s))
                    {
                        sw.Write(soapbody);
                    }
                }

                HttpWebResponse webResponse = (HttpWebResponse)webRequst.GetResponse();
                using (Stream s = webResponse.GetResponseStream())
                {
                    using (StreamReader sr = new StreamReader(s))
                    {
                        Result = sr.ReadToEnd();
                    }
                }
            }
            catch (WebException ex)
            {
                var states = ((HttpWebResponse)ex.Response).StatusCode;
                var descripition = ((HttpWebResponse)ex.Response).StatusDescription;
                Result = "WebException =" + ex.Message + "\n WebStatus=" + states + "\n descripition=" + descripition;

            }
            catch (Exception ex)
            {
                Result = ex.Message;
            }

            return Result;
        }

        #endregion

        #region Get

        /// <summary>
        /// Get方式
        /// </summary>
        /// <returns></returns>
        public static String GetHTTP(string url, HttpContext httpContext)
        {
            string queryString = "?";
            string Result = string.Empty;
            try
            {

                foreach (string key in httpContext.Request.QueryString.AllKeys)
                {
                    queryString += key + "=" + httpContext.Request.QueryString[key] + "&";
                }

                queryString = queryString.Substring(0, queryString.Length - 1);

                HttpWebRequest httpWebRequest = (HttpWebRequest)WebRequest.Create(url + queryString);

                httpWebRequest.ContentType = "application/json";
                httpWebRequest.Method = "GET";
                httpWebRequest.Timeout = 20000;

                //byte[] btBodys = Encoding.UTF8.GetBytes(body);
                //httpWebRequest.ContentLength = btBodys.Length;
                //httpWebRequest.GetRequestStream().Write(btBodys, 0, btBodys.Length);

                HttpWebResponse httpWebResponse = (HttpWebResponse)httpWebRequest.GetResponse();
                StreamReader streamReader = new StreamReader(httpWebResponse.GetResponseStream());
                string responseContent = streamReader.ReadToEnd();

                httpWebResponse.Close();
                streamReader.Close();

                Result = responseContent;
            }
            catch (WebException ex)
            {
                var states = ((HttpWebResponse)ex.Response).StatusCode;
                var descripition = ((HttpWebResponse)ex.Response).StatusDescription;
                Result = "WebException =" + ex.Message + "\n WebStatus=" + states + "\n descripition=" + descripition;
            }
            catch (Exception ex)
            {
                Result = ex.Message;
            }
            return Result;
        }

        #endregion
        #endregion

        #region Post&&Get公用方式
        public static BookingResponse CreateAuth(string url, string HttpMethod, WebHeaderCollection HeadersInfo, string userName, string passWord, String requestBody = "")
        {
            BookingResponse Result = new BookingResponse() { Status = false, Message = "get method error" };//初始化結果集
            string responseBody = string.Empty;//定義響應體
            ServicePointManager.SecurityProtocol = (SecurityProtocolType)192 | (SecurityProtocolType)768 | (SecurityProtocolType)3072;

            try
            {
                HttpWebRequest webRequst = (HttpWebRequest)HttpWebRequest.Create(url);//創建URL
                webRequst.Method = HttpMethod;//HTTP請求方式

                //webRequst.Headers.Add(HeadersInfo);//加入之前請求信息

                webRequst.ContentType = HeadersInfo["ContentType"];
                webRequst.Headers["Accept-Encoding"] = HeadersInfo["Accept-Encoding"];
                webRequst.AutomaticDecompression = DecompressionMethods.GZip; //這兩句用來解決顯示亂碼

                SetHeaderValue(webRequst.Headers, "Connection", "keep-alive");
                SetHeaderValue(webRequst.Headers, "Content-Length", requestBody.Length.ToString());
                SetHeaderValue(webRequst.Headers, "Cache-Control", "no-cache");
                SetHeaderValue(webRequst.Headers, "Origin", "xxxxxx");
                SetHeaderValue(webRequst.Headers, "User-Agent", "Provider User-Agent name");
                //SetHeaderValue(webRequst.Headers, "Content-Type", "text/xml;charset=UTF-8");
                SetHeaderValue(webRequst.Headers, "Accept", "*/*");
                //SetHeaderValue(webRequst.Headers, "Accept-Encoding", "gzip,deflate");
                SetHeaderValue(webRequst.Headers, "Authorization", "Basic " + Convert.ToBase64String(new ASCIIEncoding().GetBytes(userName + ":" + passWord)));
                SetHeaderValue(webRequst.Headers, "ProtocolVersion", "1.1");

                HttpMethod = HttpMethod.Trim().ToUpper();


                switch (HttpMethod)
                {
                    case "GET":
                        responseBody = HttpGet(url);
                        break;
                    default:
                        webRequst.ServicePoint.Expect100Continue = false; //這個在Post的時候，一定要加上，如果服務器返回錯誤，他還會繼續再去請求，不會使用之前的錯誤數據，做返回數據
                        responseBody = HttpPost(webRequst, requestBody);
                        break;
                }
                if (!string.IsNullOrWhiteSpace(responseBody) && responseBody.Length > 7 && responseBody.Substring(0, 5) != "error")
                {
                    Result.Status = true;
                    Result.Message = "success";
                    Result.Data = responseBody;

                    LogHelper.WriteLog(responseBody);//記錄正常日志
                }
                else
                {
                    if (string.IsNullOrWhiteSpace(responseBody))
                        Result.Message = "error";
                    else
                        Result.Message = responseBody;
                }
            }
            catch (Exception ex)
            {
                LogHelper.WriteLog("錯誤日志記錄:", ex);
                Result.Message = ex.Message.ToString() + responseBody;
                Result.Status = false;
            }
            return Result;
        }

        /// <summary>
        /// 發送GET請求
        /// </summary>
        /// <param name="url"></param>
        /// <param name="refer"></param>
        /// <returns></returns>
        public static string HttpGet(string url)
        {
            return null;
        }

        /// <summary>
        /// 發送Post請求
        /// </summary>
        /// <param name="webRequst"></param>
        /// <returns></returns>
        public static string HttpPost(HttpWebRequest webRequst, string requsetbody)
        {
            string Result = string.Empty;
            try
            {
                using (Stream s = webRequst.GetRequestStream())
                {
                    using (StreamWriter sw = new StreamWriter(s))
                    {
                        sw.Write(requsetbody);
                    }
                }

                HttpWebResponse webResponse = (HttpWebResponse)webRequst.GetResponse();
                using (Stream s = webResponse.GetResponseStream())
                {
                    using (StreamReader sr = new StreamReader(s))
                    {
                        Result = sr.ReadToEnd();
                    }
                }
            }
            catch (WebException ex)
            {
                var states = ((HttpWebResponse)ex.Response).StatusCode;
                var descripition = ((HttpWebResponse)ex.Response).StatusDescription;
                Result = "WebException =" + ex.Message + "\n WebStatus=" + states + "\n descripition=" + descripition;

            }
            catch (Exception ex)
            {
                Result = ex.Message;
            }
            return Result;
        }

        //Uri url = new Uri(urlstring);//初始化uri資源
        //string requestMethod = HttpMethod;//設置請求方式 Post Get
        //string timezone = DateTime.UtcNow.ToString("s") + "Z";//獲取計算機上的時間
        //string path = url.PathAndQuery.Split('?')[0];//獲取URI的絕對路徑
        //string query = url.PathAndQuery.Split('?').Count() > 1 ? url.PathAndQuery.Split('?')[1] : "";//獲取查詢條件
        #endregion

        #region 請求報頭設置

        /// <summary>
        /// 請求報頭設置
        /// </summary>
        /// <param name="header"></param>
        /// <param name="name"></param>
        /// <param name="value"></param>
        public static void SetHeaderValue(WebHeaderCollection header, string name, string value)
        {
            var property = typeof(WebHeaderCollection).GetProperty("InnerCollection", BindingFlags.Instance | BindingFlags.NonPublic);
            if (property != null)
            {
                var collection = property.GetValue(header, null) as NameValueCollection;
                collection[name] = value;
            }
        }

        #endregion

 

借鑒鏈接：https://blog.csdn.net/jintougao/article/details/12948633#

　　　　　　    https://www.cnblogs.com/lgx5/p/9446763.html

　　　　　　　https://blog.csdn.net/zhailihua/article/details/75048992