C#实现http协议GET、POST

最新推荐文章于 2024-08-02 03:52:39 发布
最新推荐文章于 2024-08-02 03:52:39 发布
阅读量1.9k 收藏 1
点赞数
分类专栏： 编程技巧与代码 文章标签： c# string buffer url 服务器 encoding

using System;
using System.Collections.Generic;
using System.Text;
using System.Net;
using System.Net.Sockets;
using System.Collections;
using System.IO;
using System.Text.RegularExpressions;
using RE = System.Text.RegularExpressions.Regex;
using System.Security.Cryptography.X509Certificates;


namespace HttpProc
{
    ///<summary>
    ///上传事件委托
    ///</summary>
    ///<param name="sender"></param>
    ///<param name="e"></param>
    public delegate void WebClientUploadEvent(object sender, HttpProc.UploadEventArgs e);

    ///<summary>
    ///下载事件委托
    ///</summary>
    ///<param name="sender"></param>
    ///<param name="e"></param>
    public delegate void WebClientDownloadEvent(object sender, HttpProc.DownloadEventArgs e);


    ///<summary>
    ///上传事件参数
    ///</summary>
    public struct UploadEventArgs
    {
        ///<summary>
        ///上传数据总大小
        ///</summary>
        public long totalBytes;
        ///<summary>
        ///已发数据大小
        ///</summary>
        public long bytesSent;
        ///<summary>
        ///发送进度(0-1)
        ///</summary>
        public double sendProgress;
        ///<summary>
        ///发送速度Bytes/s
        ///</summary>
        public double sendSpeed;
    }

    ///<summary>
    ///下载事件参数
    ///</summary>
    public struct DownloadEventArgs
    {
        ///<summary>
        ///下载数据总大小
        ///</summary>
        public long totalBytes;
        ///<summary>
        ///已接收数据大小
        ///</summary>
        public long bytesReceived;
        ///<summary>
        ///接收数据进度(0-1)
        ///</summary>
        public double ReceiveProgress;
        ///<summary>
        ///当前缓冲区数据
        ///</summary>
        public byte[] receivedBuffer;
        ///<summary>
        ///接收速度Bytes/s
        ///</summary>
        public double receiveSpeed;
    }

    ///<summary>
    ///实现向WEB服务器发送和接收数据
    ///</summary>
    public class WebClient
    {
        private WebHeaderCollection requestHeaders, responseHeaders;
        private TcpClient clientSocket;
        private MemoryStream postStream;
        private Encoding encoding = Encoding.Default;
        private const string BOUNDARY = "--HEDAODE--";
        private const int SEND_BUFFER_SIZE = 10245;
        private const int RECEIVE_BUFFER_SIZE = 10245;
        private string cookie = "";
        private string respHtml = "";
        private string strRequestHeaders = "";
        private string strResponseHeaders = "";
        private int statusCode = 0;
        private bool isCanceled = false;
        public event WebClientUploadEvent UploadProgressChanged;
        public event WebClientDownloadEvent DownloadProgressChanged;

        ///<summary>
        ///初始化WebClient类
        ///</summary>
        public WebClient()
        {
            responseHeaders = new WebHeaderCollection();
            requestHeaders = new WebHeaderCollection();
        }


        ///<summary>
        ///读取指定URL的文本
        ///</summary>
        ///<param name="URL">请求的地址</param>
        ///<returns>服务器响应文本</returns>
        public string OpenRead(string URL)
        {
            requestHeaders.Add("Connection", "close");
            SendRequestData(URL, "GET");
            return GetHtml();
        }


        //解决证书过期无法访问的问题
        class CertPolicy : ICertificatePolicy
        {
            public bool CheckValidationResult(ServicePoint srvpt, X509Certificate cert, WebRequest req, int certprb)
            { return true; }
        }

        ///<summary>
        ///采用https协议访问网络
        ///</summary>
        ///<param name="URL">url地址</param>
        ///<param name="strPostdata">发送的数据</param>
        ///<returns></returns>
        public string OpenReadWithHttps(string URL,string strPostdata)
        {
            ServicePointManager.CertificatePolicy = new CertPolicy();
            HttpWebRequest request = (HttpWebRequest)WebRequest.Create(URL);
            request.CookieContainer = new CookieContainer();
            request.Method = "POST";
            request.Accept = "*/*";
            request.ContentType="application/x-www-form-urlencoded";
            byte[] buffer = this.encoding.GetBytes(strPostdata);
            request.ContentLength = buffer.Length;
            request.GetRequestStream().Write(buffer, 0, buffer.Length);
            HttpWebResponse response = (HttpWebResponse)request.GetResponse();
            StreamReader reader = new StreamReader(response.GetResponseStream(), encoding);
            this.respHtml = reader.ReadToEnd();
            foreach (System.Net.Cookie ck in response.Cookies)
            {
                this.cookie += ck.Name + "=" + ck.Value + ";";
            }
            reader.Close();
            return respHtml;
        }

        ///<summary>
        ///读取指定URL的文本
        ///</summary>
        ///<param name="URL">请求的地址</param>
        ///<param name="postData">向服务器发送的文本数据</param>
        ///<returns>服务器响应文本</returns>
        public string OpenRead(string URL, string postData)
        {
            byte[] sendBytes = encoding.GetBytes(postData);
            postStream = new MemoryStream();
            postStream.Write(sendBytes, 0, sendBytes.Length);

            requestHeaders.Add("Content-Length", postStream.Length.ToString());
            requestHeaders.Add("Content-Type", "application/x-www-form-urlencoded");
            requestHeaders.Add("Connection", "close");

            SendRequestData(URL, "POST");
            return GetHtml();
        }


        ///<summary>
        ///读取指定URL的流
        ///</summary>
        ///<param name="URL">请求的地址</param>
        ///<param name="postData">向服务器发送的数据</param>
        ///<returns>服务器响应流</returns>
        public Stream GetStream(string URL, string postData)
        {
            byte[] sendBytes = encoding.GetBytes(postData);
            postStream = new MemoryStream();
            postStream.Write(sendBytes, 0, sendBytes.Length);

            requestHeaders.Add("Content-Length", postStream.Length.ToString());
            requestHeaders.Add("Content-Type", "application/x-www-form-urlencoded");
            requestHeaders.Add("Connection", "close");

            SendRequestData(URL, "POST");

            MemoryStream ms = new MemoryStream();
            SaveNetworkStream(ms);
            return ms;
        }


        ///<summary>
        ///上传文件到服务器
        ///</summary>
        ///<param name="URL">请求的地址</param>
        ///<param name="fileField">文件域(格式如:file1=C:/test.mp3&file2=C:/test.jpg)</param>
        ///<returns>服务器响应文本</returns>
        public string UploadFile(string URL, string fileField)
        {
            return UploadFile(URL, "", fileField);
        }

        ///<summary>
        ///上传文件和数据到服务器
        ///</summary>
        ///<param name="URL">请求地址</param>
        ///<param name="textField">文本域(格式为:name1=value1&name2=value2)</param>
        ///<param name="fileField">文件域(格式如:file1=C:/test.mp3&file2=C:/test.jpg)</param>
        ///<returns>服务器响应文本</returns>
        public string UploadFile(string URL, string textField, string fileField)
        {
            postStream = new MemoryStream();

            if (textField != "" && fileField != "")
            {
                WriteTextField(textField);
                WriteFileField(fileField);
            }
            else if (fileField != "")
            {
                WriteFileField(fileField);
            }
            else if (textField != "")
            {
                WriteTextField(textField);
            }
            else
                throw new Exception("文本域和文件域不能同时为空。");

            //写入结束标记
            byte[] buffer = encoding.GetBytes("--" + BOUNDARY + "--/r/n");
            postStream.Write(buffer, 0, buffer.Length);

            //添加请求标头
            requestHeaders.Add("Content-Length", postStream.Length.ToString());
            requestHeaders.Add("Content-Type", "multipart/form-data; boundary=" + BOUNDARY);
            requestHeaders.Add("Connection", "Keep-Alive");

            //发送请求数据
            SendRequestData(URL, "POST", true);

            //返回响应文本
            return GetHtml();
        }


        ///<summary>
        ///分析文本域，添加到请求流
        ///</summary>
        ///<param name="textField">文本域</param>
        private void WriteTextField(string textField)
        {
            string[] strArr = RE.Split(textField, "&");
            textField = "";
            foreach (string var in strArr)
            {
                Match M = RE.Match(var, "([^=]+)=(.+)");
                textField += "--" + BOUNDARY + "/r/n";
                textField += "Content-Disposition: form-data; name=/"" + M.Groups[1].Value + "/"/r/n/r/n" + M.Groups[2].Value + "/r/n";
            }
            byte[] buffer = encoding.GetBytes(textField);
            postStream.Write(buffer, 0, buffer.Length);
        }

        ///<summary>
        ///分析文件域，添加到请求流
        ///</summary>
        ///<param name="fileField">文件域</param>
        private void WriteFileField(string fileField)
        {
            string filePath = "";
            int count = 0;
            string[] strArr = RE.Split(fileField, "&");
            foreach (string var in strArr)
            {
                Match M = RE.Match(var, "([^=]+)=(.+)");
                filePath = M.Groups[2].Value;
                fileField = "--" + BOUNDARY + "/r/n";
                fileField += "Content-Disposition: form-data; name=/"" + M.Groups[1].Value + "/"; filename=/"" + Path.GetFileName(filePath) + "/"/r/n";
                fileField += "Content-Type: image/jpeg/r/n/r/n";

                byte[] buffer = encoding.GetBytes(fileField);
                postStream.Write(buffer, 0, buffer.Length);

                //添加文件数据
                FileStream fs = new FileStream(filePath, FileMode.Open, FileAccess.Read);
                buffer = new byte[50000];

                do
                {
                    count = fs.Read(buffer, 0, buffer.Length);
                    postStream.Write(buffer, 0, count);

                } while (count > 0);

                fs.Close();
                fs.Dispose();
                fs = null; 
                buffer = encoding.GetBytes("/r/n");
                postStream.Write(buffer, 0, buffer.Length);
            }
        }

        ///<summary>
        ///从指定URL下载数据流
        ///</summary>
        ///<param name="URL">请求地址</param>
        ///<returns>数据流</returns>
        public Stream DownloadData(string URL)
        {
            requestHeaders.Add("Connection", "close");
            SendRequestData(URL, "GET");
            MemoryStream ms = new MemoryStream();
            SaveNetworkStream(ms, true);
            return ms;
        }


        ///<summary>
        ///从指定URL下载文件
        ///</summary>
        ///<param name="URL">文件URL地址</param>
        ///<param name="fileName">文件保存路径,含文件名(如:C:/test.jpg)</param>
        public void DownloadFile(string URL, string fileName)
        {
            requestHeaders.Add("Connection", "close");
            SendRequestData(URL, "GET");
            FileStream fs = new FileStream(fileName, FileMode.Create);
            SaveNetworkStream(fs, true);
            fs.Close();
            fs = null;
        }

        ///<summary>
        ///向服务器发送请求
        ///</summary>
        ///<param name="URL">请求地址</param>
        ///<param name="method">POST或GET</param>
        ///<param name="showProgress">是否显示上传进度</param>
        private void SendRequestData(string URL, string method, bool showProgress)
        {
            clientSocket = new TcpClient();
            Uri URI = new Uri(URL);
            clientSocket.Connect(URI.Host, URI.Port);

            requestHeaders.Add("Host", URI.Host);
            byte[] request = GetRequestHeaders(method + " " + URI.PathAndQuery + " HTTP/1.1");
            clientSocket.Client.Send(request);

            //若有实体内容就发送它
            if (postStream != null)
            {
                byte[] buffer = new byte[SEND_BUFFER_SIZE];
                int count = 0;
                Stream sm = clientSocket.GetStream();
                postStream.Position = 0;

                UploadEventArgs e = new UploadEventArgs();
                e.totalBytes = postStream.Length;
                System.Diagnostics.Stopwatch timer = new System.Diagnostics.Stopwatch();//计时器
                timer.Start();
                do
                {
                    //如果取消就推出
                    if (isCanceled) { break; }

                    //读取要发送的数据
                    count = postStream.Read(buffer, 0, buffer.Length);
                    //发送到服务器
                    sm.Write(buffer, 0, count);

                    //是否显示进度
                    if (showProgress)
                    {
                        //触发事件
                        e.bytesSent += count;
                        e.sendProgress = (double)e.bytesSent / (double)e.totalBytes;
                        double t = timer.ElapsedMilliseconds / 1000;
                        t = t <= 0 ? 1 : t;
                        e.sendSpeed = (double)e.bytesSent / t;
                        if (UploadProgressChanged != null) { UploadProgressChanged(this, e); }
                    }

                } while (count > 0);
                timer.Stop();
                postStream.Close();
                //postStream.Dispose();
                postStream = null;

            }//end if

        }

        ///<summary>
        ///向服务器发送请求
        ///</summary>
        ///<param name="URL">请求URL地址</param>
        ///<param name="method">POST或GET</param>
        private void SendRequestData(string URL, string method)
        {
            SendRequestData(URL, method, false);
        }


        ///<summary>
        ///获取请求头字节数组
        ///</summary>
        ///<param name="request">POST或GET请求</param>
        ///<returns>请求头字节数组</returns>
        private byte[] GetRequestHeaders(string request)
        {
            requestHeaders.Add("Accept", "*/*");
            requestHeaders.Add("Accept-Language", "zh-cn");
            requestHeaders.Add("User-Agent", "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.2; SV1; .NET CLR 1.1.4322; .NET CLR 2.0.50727)");

           string headers = request + "/r/n";

            foreach (string key in requestHeaders)
            {
                headers += key + ":" + requestHeaders[key] + "/r/n";
            }

            //有Cookie就带上Cookie
            if (cookie != "") { headers += "Cookie:" + cookie + "/r/n"; }

            //空行，请求头结束
            headers += "/r/n";

            strRequestHeaders = headers;
            requestHeaders.Clear();
            return encoding.GetBytes(headers);
        }



        ///<summary>
        ///获取服务器响应文本
        ///</summary>
        ///<returns>服务器响应文本</returns>
        private string GetHtml()
        {
            MemoryStream ms = new MemoryStream();
            SaveNetworkStream(ms);//将网络流保存到内存流
            StreamReader sr = new StreamReader(ms, encoding);
            respHtml = sr.ReadToEnd();
            sr.Close(); ms.Close();
            return respHtml;
        }

        ///<summary>
        ///将网络流保存到指定流
        ///</summary>
        ///<param name="toStream">保存位置</param>
        ///<param name="needProgress">是否显示进度</param>
        private void SaveNetworkStream(Stream toStream, bool showProgress)
        {
            //获取要保存的网络流
            NetworkStream NetStream = clientSocket.GetStream();

            byte[] buffer = new byte[RECEIVE_BUFFER_SIZE];
            int count = 0, startIndex = 0;

            MemoryStream ms = new MemoryStream();
            for (int i = 0; i < 3; i++)
            {
                count = NetStream.Read(buffer, 0, 500);
                ms.Write(buffer, 0, count);
            }

            if (ms.Length == 0) { NetStream.Close(); throw new Exception("远程服务器没有响应"); }

            buffer = ms.GetBuffer();
            count = (int)ms.Length;

            GetResponseHeader(buffer, out startIndex);//分析响应，获取响应头和响应实体
            count -= startIndex;
            toStream.Write(buffer, startIndex, count);

            DownloadEventArgs e = new DownloadEventArgs();

            if (responseHeaders["Content-Length"] != null)
            { e.totalBytes = long.Parse(responseHeaders["Content-Length"]); }
            else
            { e.totalBytes = -1; }

            //启动计时器
            System.Diagnostics.Stopwatch timer = new System.Diagnostics.Stopwatch();
            timer.Start();

            do
            {
                //如果取消就推出
                if (isCanceled) { break; }

                //显示下载进度
                if (showProgress)
                {
                    e.bytesReceived += count;
                    e.ReceiveProgress = (double)e.bytesReceived / (double)e.totalBytes;

                    byte[] tempBuffer = new byte[count];
                    Array.Copy(buffer, startIndex, tempBuffer, 0, count);
                    e.receivedBuffer = tempBuffer;

                    double t = (timer.ElapsedMilliseconds + 0.1)/1000;
                    e.receiveSpeed = (double)e.bytesReceived / t;

                    startIndex = 0;
                    if (DownloadProgressChanged != null) { DownloadProgressChanged(this, e); }
                }

                //读取网路数据到缓冲区
                count = NetStream.Read(buffer, 0, buffer.Length);

                //将缓存区数据保存到指定流
                toStream.Write(buffer, 0, count);
            } while (count > 0);

            timer.Stop();//关闭计时器

            if (responseHeaders["Content-Length"] != null)
            {
                toStream.SetLength(long.Parse(responseHeaders["Content-Length"]));
            }
            //else
            //{
            //    toStream.SetLength(toStream.Length);
            //    responseHeaders.Add("Content-Length", toStream.Length.ToString());//添加响应标头
            //}

            toStream.Position = 0;

            //关闭网络流和网络连接
            NetStream.Close();
            clientSocket.Close();
        }


        ///<summary>
        ///将网络流保存到指定流
        ///</summary>
        ///<param name="toStream">保存位置</param>
        private void SaveNetworkStream(Stream toStream)
        {
            SaveNetworkStream(toStream, false);
        }



        ///<summary>
        ///分析响应流，去掉响应头
        ///</summary>
        ///<param name="buffer"></param>
        private void GetResponseHeader(byte[] buffer, out int startIndex)
        {
            responseHeaders.Clear();
            string html = encoding.GetString(buffer);
            StringReader sr = new StringReader(html);

            int start = html.IndexOf("/r/n/r/n") + 4;//找到空行位置
            strResponseHeaders = html.Substring(0, start);//获取响应头文本

            //获取响应状态码
            //
            if (sr.Peek() > -1)
            {
                //读第一行字符串
                string line = sr.ReadLine();

                //分析此行字符串,获取服务器响应状态码
                Match M = RE.Match(line, @"/d/d/d");
                if (M.Success)
                {
                    statusCode = int.Parse(M.Value);
                }
            }

            //获取响应头
            //
            while (sr.Peek() > -1)
            {
                //读一行字符串
                string line = sr.ReadLine();

                //若非空行
                if (line != "")
                {
                    //分析此行字符串，获取响应标头
                    Match M = RE.Match(line, "([^:]+):(.+)");
                    if (M.Success)
                    {
                        try
                        {        //添加响应标头到集合
                            responseHeaders.Add(M.Groups[1].Value.Trim(), M.Groups[2].Value.Trim());
                        }
                        catch
                        { }


                        //获取Cookie
                        if (M.Groups[1].Value == "Set-Cookie")
                        {
                            M = RE.Match(M.Groups[2].Value, "[^=]+=[^;]+");
                            cookie += M.Value.Trim() + ";";
                        }
                    }

                }
                //若是空行，代表响应头结束响应实体开始。（响应头和响应实体间用一空行隔开）
                else
                {
                    //如果响应头中没有实体大小标头，尝试读响应实体第一行获取实体大小
                    if (responseHeaders["Content-Length"] == null && sr.Peek() > -1)
                    {
                        //读响应实体第一行
                        line = sr.ReadLine();

                        //分析此行看是否包含实体大小
                        Match M = RE.Match(line, "~[0-9a-fA-F]{1,15}");

                        if (M.Success)
                        {
                            //将16进制的实体大小字符串转换为10进制
                            int length = int.Parse(M.Value, System.Globalization.NumberStyles.AllowHexSpecifier);
                            responseHeaders.Add("Content-Length", length.ToString());//添加响应标头
                            strResponseHeaders += M.Value + "/r/n";
                        }
                    }
                    break;//跳出循环
                }//End If
            }//End While

            sr.Close();

            //实体开始索引
            startIndex = encoding.GetBytes(strResponseHeaders).Length;
        }


        ///<summary>
        ///取消上传或下载,要继续开始请调用Start方法
        ///</summary>
        public void Cancel()
        {
            isCanceled = true;
        }

        ///<summary>
        ///启动上传或下载，要取消请调用Cancel方法
        ///</summary>
        public void Start()
        {
            isCanceled = false;
        }

        //*************************************************************
        //以下为属性
        //*************************************************************

        ///<summary>
        ///获取或设置请求头
        ///</summary>
        public WebHeaderCollection RequestHeaders
        {
            set { requestHeaders = value; }
            get { return requestHeaders; }
        }

        ///<summary>
        ///获取响应头集合
        ///</summary>
        public WebHeaderCollection ResponseHeaders
        {
            get { return responseHeaders; }
        }

        ///<summary>
        ///获取请求头文本
        ///</summary>
        public string StrRequestHeaders
        {
            get { return strRequestHeaders; }
        }

        ///<summary>
        ///获取响应头文本
        ///</summary>
        public string StrResponseHeaders
        {
            get { return strResponseHeaders; }
        }

        ///<summary>
        ///获取或设置Cookie
        ///</summary>
        public string Cookie
        {
            set { cookie = value; }
            get { return cookie; }
        }

        ///<summary>
        ///获取或设置编码方式(默认为系统默认编码方式)
        ///</summary>
        public Encoding Encoding
        {
            set { encoding = value; }
            get { return encoding; }
        }

        ///<summary>
        ///获取服务器响应文本
        ///</summary>
        public string RespHtml
        {
            get { return respHtml; }
        }


        ///<summary>
        ///获取服务器响应状态码
        ///</summary>
        public int StatusCode
        {
            get { return statusCode; }
        }
    }
}

netfere8
关注
专栏目录
C#实现HTTP GET和POST 样例代码
01-28
C#实现HTTP GET和POST 样例代码
C#实现http协议GET、POST请求
04-06
C#实现http协议GET、POST请求 C#实现http协议GET、POST请求 C#实现http协议GET、POST请求 C#实现http协议GET、POST请求 C#实现http协议GET、POST请求
C# Http 请求接口 Get / Post
热门推荐
熊思雨的博客
06-22 2万+
get 和 post 请求，最早被用来做浏览器与服务器之间交互HTML和表单的通讯协议，后来又被广泛的扩充到接口格式的定义上，到目前为止，get / post 请求依然应用在各大网站中，比如在用户登录时，调用 get / post 请求将用户名、密码传到服务器，由服务器进行判断，是否允许用户登录，再将结果返回给浏览器，这样就实现了登录的功能。在后期的 pc 软件开发中，get / post 请求偶尔也会用到，做为一个程序员，http 协议也是我们必须要学的知识点。
C#-Http协议通讯（五）-HttpClient
最新发布
weixin_42087578的博客
08-02 40
登录后复制 /** *┌──────────────────────────────────────────────────────────────┐ *│　描 述：C#-HttpClient帮助类 *│　作 ...
C# Http协议 Get与Post
zengxin2008的专栏
11-24 1662
<br />文章来源：http://dotnet.cnblogs.com/page/64558/<br /> 引言<br />HTTP协议我想任何IT人士都耳熟能详了，大家都能说出个所以然来。但是如果我问你HTTP协议的请求方法有哪些？POST与GET的差异？GET或POST传送数据量的大小有限制吗？HTTP响应的状态有哪些？以及在C#中你如何使用？如果你不能清楚地回答其中的大部分问题，那么这篇文章就是为你准备的！大纲如下：1、HTTP概述 1.1、HTTP协议的客户端与服务器的交互1.2、HTTP消息
[C#]网络编程 HTTP协议详解
wangyizhi58的专栏
08-25 738
我们在用Asp.net技术开发Web应用程序后，当用户在浏览器输入一个网址时就是再向服务器发送一个HTTP请求，此时就使用了应用层的HTTP协议，在上一个专题我们简单介绍了网络协议的知识，主要是为了后面讲HTTP协议做一个铺垫的，只有对HTTP协议有一个清楚的认识，这样当我们用Asp.net技术开发Web应用程序时，我们可以多从网络协议的方面去思考我们的应用程序，而不是只是单单停留在对服务器控件的
C#实现HTTP协议POST请求
我的Unity3D
01-28 5782
步骤   1. 编辑并Encoding提交的数据，格式类似 表单域名称1=值1&表单域名称2=值2&表单域名称3=值3……； 2. 发送请求（HttpWebRequest）； 3. 获得回复（HttpWebResponse）。   [c-sharp] view plaincopy private string Pos
HTTP协议及其POST与GET操作差异 & C#中如何使用POST、GET等
凯文逊的专栏
04-24 546
<br />引言<br />HTTP 协议我想任何IT人士都耳熟能详了，大家都能说出个所以然来。但是如果我问你HTTP协议的请求方法有哪些？POST与GET的差异？GET或POST传 送数据量的大小有限制吗？HTTP响应的状态有哪些？以及在C#中你如何使用？如果你不能清楚地回答其中的大部分问题，那么这篇文章就是为你准备的！大纲 如下： 1、HTTP概述 1.1、HTTP协议的客户端与服务器的交互1.2、HTTP消息1.3、HTTP请求的方法1.4、HTTP响应的代码2、抓包分析3、POST与GET的
c# http协议，实现get或post发送请求 并返回内容
04-28
本篇将详细介绍如何在C#中利用HTTP协议实现GET和POST请求，并获取返回的内容。 首先，让我们了解GET和POST的基本概念： 1. GET：GET请求是最常见的HTTP方法，用于从服务器获取资源。参数通常附加在URL后面，可见且...
C#的http发送post和get请求源码
02-04
在C#编程中，HTTP（超文本传输协议）是用于客户端和服务器之间通信的主要协议，主要涉及GET和POST两种常见的请求方法。本文将详细介绍如何在C#中实现这两种请求，并结合给定的文件名，推测这是一个简单的C#桌面应用...
C# httpPost
02-25
C# httpPost简单的demo，就是一个测试demo。http post的使用
基于C#的HTTP通信协议
07-10
基于C#的HTTP通信协议设计~~~~能够实现浏览器端和服务器端的通信
C# 常用的HTTP请求中Post方法的实现
weixin_42393604的博客
03-11 4951
HTTP的工作方式是客户端与服务器之间的请求-应答协议。 而在客户端与服务器之间进行请求-响应时，Post是经常被用到的方法。 下面是C#中Post的具体实现 /// <summary> /// Post 相关数据 /// </summary> /// <param name="url">POST请求地址 </param> /// <param name="postData">...
C#实现http协议GET、POST请求教程
高性价比服务器就选：蓝易云
10-28 561
以上是使用C#实现HTTP协议的GET和POST请求的简单示例。你可以根据实际需要进行更详细的配置和处理。需要注意的是，上述代码中使用了异步操作。类来实现HTTP协议的GET和POST请求。关键字，这可以提高程序的性能和响应能力。
C#使用HTTP协议
TBViwer
08-04 3044
HTTP的工作过程大体上分连接、请求、响应和断开连接四个步骤。C#语言对HTTP协议提供了良好的支持，在.NET类库中提供了WebRequest和WebResponse类，这两个类都包含在System.Net命名空间中，利用这两个类可以实现很多高级的网络功能，本文中多线程文件下载就是利用这两个类实现的。 WebRequest和WebResponse都是抽象基类，因此在程序中不能直接作为对象使用，必须
c# http协议
nbspzs的专栏
02-15 107
HTTP/2 （原名HTTP/2.0）即超文本传输协议 2.0，是下一代HTTP协议。是由互联网工程任务组（IETF）的Hypertext Transfer Protocol Bis (httpbis)工作小组进行开发。是自1999年http1.1发布后的首个更新。HTTP 2.0在2013年8月进行首次合作共事性测试。在开放互联网上HTTP 2.0将只用于https://网址，而 http://网址将继续使用HTTP/1，目的是在开放互联网上增加使用加密技术，以提供强有力的保护去遏制主动攻击。DANE R
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值