HttpWebRequest 辅助类

最新推荐文章于 2023-04-20 10:55:06 发布
最新推荐文章于 2023-04-20 10:55:06 发布
阅读量237 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wpyok168/article/details/123039767
版权

HTTP请求 Cookie管理 SSL证书 代理 C#
关键词由CSDN通过智能技术生成 
using System;
using System.IO;
using System.IO.Compression;
using System.Net;
using System.Text;
using System.Text.RegularExpressions;

namespace WebRequestHellp
{
    public class RequestHellp
    {
        private static CookieContainer ckContainer = new CookieContainer();
        private static string location = string.Empty;
        private static bool allowautoRedirect = true;
        private static string aspcookie = string.Empty;
        private static IWebProxy proxy;

        /// <summary>
        /// 获取或设置CookieContainer
        /// </summary>
        public static CookieContainer CkContainer { get => ckContainer; set => ckContainer = value; }
        /// <summary>
        /// Response后跳转链接
        /// </summary>
        public static string Location { get => location; set => location = value; }
        /// <summary>
        /// 设置Request是否自动跳转
        /// </summary>
        public static bool AllowautoRedirect { get => allowautoRedirect; set => allowautoRedirect = value; }
        /// <summary>
        /// 保留项
        /// </summary>
        public static string Aspcookie { get => aspcookie; set => aspcookie = value; }
        /// <summary>
        /// 设置代理服务器，如果需要socks5，请Nuget项目HttpToSocks5Proxy 后 using MihaZupan
        /// </summary>
        public static IWebProxy Proxy { get => proxy; set => proxy = value; }

        private static bool AcceptAllCertifications(object sender, System.Security.Cryptography.X509Certificates.X509Certificate certification, System.Security.Cryptography.X509Certificates.X509Chain chain, System.Net.Security.SslPolicyErrors sslPolicyErrors)
        {
            return true;
        }
        public static int HttpHelp(string url, string method, string postdata, string referer, string ContentType, WebHeaderCollection webHeaderCollection, ref string outhtml, string Accept= null)
        {
            //解决https不安全提示
            //ServicePointManager.SecurityProtocol = (System.Net.SecurityProtocolType)4080; //SecurityProtocolType.Tls ; //Or SecurityProtocolType.Ssl3 Or SecurityProtocolType.Tls11 Or SecurityProtocolType.Tls;
            ServicePointManager.SecurityProtocol = SecurityProtocolType.Ssl3 | SecurityProtocolType.Tls12 | SecurityProtocolType.Tls11 | SecurityProtocolType.Tls | SecurityProtocolType.Ssl3 | SecurityProtocolType.SystemDefault;
            ServicePointManager.ServerCertificateValidationCallback = new System.Net.Security.RemoteCertificateValidationCallback(AcceptAllCertifications);
            ServicePointManager.DefaultConnectionLimit = 50;

            string text = string.Empty;
            string text2 = Regex.Match(url, "^(?:\\w+://)?([^/?]*)").Groups[1].Value;
            if (text2.Contains("www."))
            {
                text2 = text2.Replace("www.", "");
            }
            else
            {
                //text2 = "." + text2;
            }
            HttpWebRequest hwr = (HttpWebRequest)HttpWebRequest.Create(url);
            if (Proxy != null)
            {
                //hwr.Proxy = new WebProxy(new Uri("socks5://" + RequestHellp.ProxyIP + ":" + RequestHellp.proxyPort));
                hwr.Proxy = Proxy;
            }
            hwr.Method = method;
            hwr.AllowAutoRedirect = AllowautoRedirect;
            hwr.KeepAlive = true;
            if (string.IsNullOrEmpty(Accept))
            {
                hwr.Accept = "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9";
            }
            else
            {
                hwr.Accept = Accept;
            }
            if (string.IsNullOrEmpty(ContentType))
            {
                //hwr.ContentType = "application/json; charset=utf-8;application/x-www-form-urlencoded";
                hwr.ContentType = "application/x-www-form-urlencoded;application/json; charset=UTF-8";
            }
            else
            {
                hwr.ContentType = ContentType;
            }
            //hwr.Headers.Add("accept-language", "zh-CN,zh;q=0.9,en;q=0.8,ru;q=0.7,de;q=0.6");
            hwr.Headers.Add("accept-language", "en,en-US;q=0.9,en;q=0.8,ru;q=0.7,de;q=0.6");
            hwr.Headers.Add("accept-encoding", "gzip, deflate, br");
            hwr.Headers.Add("Upgrade-Insecure-szRequests", "1");
            hwr.Headers.Add("Cache-Control", "max-age=0");
            hwr.UserAgent = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/93.0.4577.82 Safari/537.36";
            //hwr.ContentType = "";
            if (!string.IsNullOrEmpty(referer))
            {
                hwr.Referer = referer;
            }
            if (webHeaderCollection != null)
            {
                if (webHeaderCollection.Count > 0)
                {
                    hwr.Headers.Add(webHeaderCollection);
                }
            }
            //hwr.CookieContainer = new CookieContainer();
            hwr.CookieContainer = RequestHellp.CkContainer;
            //if (string.IsNullOrEmpty(Aspcookie))
            //{
            //    hwr.Headers.Set("Cookie", Aspcookie);
            //}
            if (!string.IsNullOrEmpty(postdata))
            {
                byte[] bytes = UTF8Encoding.UTF8.GetBytes(postdata);
                hwr.ContentLength = bytes.Length;
                using (Stream stream = hwr.GetRequestStream())
                {
                    stream.Write(bytes, 0, bytes.Length);
                    stream.Close();
                }
            }
            if (string.IsNullOrEmpty(postdata) && method.ToLower().Equals("post"))
            {
                hwr.ContentLength = 0L;
            }
            
            HttpWebResponse hwrs = null;
            try
            {
                hwrs = (HttpWebResponse)hwr.GetResponse();
            }
            catch (WebException ex)
            {
                outhtml = ex.Message;
                //using (WebResponse response = ex.Response)
                //{
                //    hwrs = response as HttpWebResponse;
                //    Debug.Print(hwrs.StatusCode.ToString());
                //    outhtml = new StreamReader(hwrs.GetResponseStream()).ReadToEnd();
                //}
                return 0;
                //throw;
            }

            //string httpresponedata = string.Empty;
            if (hwrs.ContentEncoding.ToLower().Contains("gzip"))
            {
                outhtml = new StreamReader(new GZipStream(hwrs.GetResponseStream(), CompressionMode.Decompress)).ReadToEnd();
            }
            else if (hwrs.ContentEncoding.ToLower().Contains("deflate"))
            {
                outhtml = new StreamReader(new DeflateStream(hwrs.GetResponseStream(), CompressionMode.Decompress)).ReadToEnd();
            }
            else
            {
                outhtml = new StreamReader(hwrs.GetResponseStream()).ReadToEnd();
            }
            //WebHeaderCollection webHeaderCollection = hwrs.Headers;
            //if (!string.IsNullOrEmpty(webHeaderCollection.Get("Set-Cookie")))
            //取cookie方法一
            //CookieContainer cc = new CookieContainer();
            //if (hwrs.Cookies.Count>0)
            //{
            //    foreach (Cookie cookie in hwrs.Cookies)
            //    {
            //        if (string.IsNullOrEmpty(cookie.Domain))
            //        {
            //            cookieContainer.Add(new UriBuilder(text2).Uri, cookie);
            //        }
            //        else
            //        {
            //            cookieContainer.Add(cookie);
            //        }
            //    }
            //    Form1.cookieContainer = cookieContainer;
            //    //cc = Form1.cookieContainer;
            //}
            if (!string.IsNullOrEmpty(hwrs.Headers[HttpResponseHeader.Location]))
            {
                RequestHellp.Location = hwrs.Headers[HttpResponseHeader.Location];
            }

            if (!string.IsNullOrEmpty(hwrs.Headers[HttpResponseHeader.SetCookie]))
            {
                //if (hwrs.Headers[HttpResponseHeader.SetCookie].Contains(text2))
                //{
                //    cookieContainer.SetCookies(new UriBuilder(text2).Uri, hwrs.Headers[HttpResponseHeader.SetCookie]);
                //    Form1.cookieContainer.Add(cookieContainer.GetCookies(new UriBuilder(text2).Uri));
                //    //cc = Form1.cookieContainer;
                //}
                //if (hwrs.Headers[HttpResponseHeader.SetCookie].Contains("AspNetCore.OpenIdConnect"))
                //{
                //    //Aspcookie = hwrs.Headers[HttpResponseHeader.SetCookie];
                //    //fixCookies(hwr, hwrs);
                //    FixCookies(hwr, hwrs);
                //    //string aspcookie = hwrs.Headers[HttpResponseHeader.SetCookie];
                //    //cookieContainer.SetCookies(new UriBuilder(text2).Uri, aspcookie);
                //    //Form1.cookieContainer.Add(cookieContainer.GetCookies(new UriBuilder(text2).Uri));
                //}
                RequestHellp.CkContainer.Add(GetCookies(hwr, hwrs));
                //Form1.cookieContainer.Add(GetCookies(hwrs.Headers[HttpResponseHeader.SetCookie], hwr.Host.Split(':')[0]));
            }

            return 1;
        }

        private static void fixCookies(HttpWebRequest request, HttpWebResponse response)
        {
            for (int i = 0; i < response.Headers.Count; i++)
            {
                string name = response.Headers.GetKey(i);
                if (name != "Set-Cookie")
                    continue;
                string value = response.Headers.Get(i);
                string cookies = string.Empty;
                foreach (var singleCookie in value.Split(','))
                {
                    Match match = Regex.Match(singleCookie, "(.+?)=(.+?);");
                    if (match.Captures.Count == 0)
                        continue;
                    string host = request.Host.Split(':')[0];
                    string ckname = match.Groups[1].ToString();
                    string ckvalue = match.Groups[2].ToString();
                    for (int j = 0; j < match.Groups.Count; j++)
                    {
                        try
                        {
                            RequestHellp.CkContainer.Add(new Cookie(ckname, ckvalue, "/", host));
                            if (cookies.Contains(ckname))
                            {
                                continue;
                            }
                            cookies += RequestHellp.CkContainer.GetCookieHeader(new UriBuilder(host).Uri) + "|";
                        }
                        catch (Exception)
                        {

                        }
                    }
                }
            }
        }

        private static CookieCollection GetCookies(HttpWebRequest request, HttpWebResponse response)
        {
            CookieCollection cookieCollection = new CookieCollection();
            CookieContainer cc = new CookieContainer();//调试用
            for (int i = 0; i < response.Headers.Count; i++)
            {
                string name = response.Headers.GetKey(i);
                if (name != "Set-Cookie")
                    continue;
                string value = response.Headers.Get(i);
                foreach (var cksplit in value.Split(','))
                {
                    //MatchCollection mc = Regex.Matches(cksplit, "(.+?)=(.+?);", RegexOptions.Compiled);
                    MatchCollection mc = Regex.Matches(cksplit, "(\\S*?)=(.*?)(?:;|$)", RegexOptions.Compiled);

                    string cookies = string.Empty;//调试用

                    foreach (Match item in mc)
                    {
                        if (item.Groups[1].Value.Contains("expires") || item.Groups[1].Value.Contains("path") || item.Groups[1].Value.Contains("samesite"))
                        {
                            continue;
                        }
                        try
                        {
                            string host = request.Host.Split(':')[0];
                            cookieCollection.Add(new Cookie(item.Groups[1].Value, item.Groups[2].Value, "/", host));
                            //调试用
                            cc.Add(new Cookie(item.Groups[1].Value, item.Groups[2].Value, "/", host));
                            cookies += cc.GetCookieHeader(new UriBuilder(host).Uri) + "|";
                            //调试用
                        }
                        catch (Exception)
                        {

                        }
                    }
                }
            }
            return cookieCollection;
        }
        private static CookieCollection GetCookies(string cookietxt, string host)
        {
            CookieCollection cookieCollection = new CookieCollection();
            CookieContainer cc = new CookieContainer();//调试用
            foreach (var cksplit in cookietxt.Split(','))
            {
                //(?![httponly,|httponly])(\S*?)=(.*?)(?:;|$)
                //MatchCollection mc = Regex.Matches(cksplit, "(.+?)=(.+?);", RegexOptions.Compiled);
                MatchCollection mc = Regex.Matches(cksplit, "(\\S*?)=(.*?)(?:;|$)", RegexOptions.Compiled);

                string cookies = string.Empty;//调试用

                foreach (Match item in mc)
                {
                    if (item.Groups[1].Value.Contains("expires") || item.Groups[1].Value.Contains("path") || item.Groups[1].Value.Contains("samesite"))
                    {
                        continue;
                    }
                    try
                    {
                        cookieCollection.Add(new Cookie(item.Groups[1].Value, item.Groups[2].Value, "/", host));
                        //调试用
                        cc.Add(new Cookie(item.Groups[1].Value, item.Groups[2].Value, "/", host));
                        cookies += cc.GetCookieHeader(new UriBuilder(host).Uri) + "|";
                        //调试用
                    }
                    catch (Exception)
                    {

                    }
                }
            }
            return cookieCollection;
        }
    }
}
wpyok168
关注
.NET 6 在 Win7 系统证书链错误导致 HttpWebRequest 内存泄露
dotNET跨平台
05-09 1637
本文记录我将应用迁移到 dotnet 6 之后，在 Win7 系统上，因为使用 HttpWebRequest 访问一个本地服务，此本地服务开启 https 且证书链在此 Win7 系统上错误，导致应用内存泄露问题。本文记录此问题的原因以及调查过程核心原因核心原因是在 CRYPT32.dll 上的 CertGetCertificateChain 方法存在内存泄露，更底层的原...
在C 用HttpWebRequest中发送GET/HTTP/HTTPS请求
ytfghytf的博客
11-06 1996
在C 用HttpWebRequest中发送GET/HTTP/HTTPS请求
httpwebrequest工具类
04-24
httpwebrequest工具类 可以有来抓取网面 代码从网上获取
HttpHelper.cs类
OuErHuiLaiKanKan的博客
10-12 873
/// /// 类说明：HttpHelper类，用来实现Http访问，Post或者Get方式的，直接访问，带Cookie的，带证书的等方式，可以设置代理 /// 重要提示：请不要自行修改本类，如果因为你自己修改后将无法升级到新版本。如果确实有什么问题请到官方网站提建议， /// 我们一定会及时修改 /// 编码日期：2011-09-20 /// 编 码 人：苏飞 /// 联系方式：3619836
一个HttpWebRequest工具类
weixin_30376083的博客
11-23 246
using System; using System.Collections.Generic; using System.IO; using System.Linq; using System.Net; using System.Text; public class HttpRequestHelper { /// <summary> //...
C# 后台使用HttpWebRequest发送POST请求帮助类
热门推荐
lm_home的博客
03-09 1万+
using System; using System.Collections.Generic; using System.IO; using System.Net; using System.Text; namespace Utils { public class RequestHelper { public static string SendHttpReque
记录HttpWebRequest辅助类
weixin_33923148的博客
11-28 103
最近因为工作关系，需要通过HttpWebRequest去请求API，所有就写了个简单的辅助publicsealedclassHttpRequestHelper { private static string USER_AGENT = "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWeb...
火车头7.6版采集https插件：网站报错System.Net.HttpWebRequest问题解决方案
11-17
这个插件可能是对系统默认的HttpWebRequest类进行了优化或者提供了一种绕过某些错误的方法，例如忽视SSL/TLS证书错误，或者改进了与特定服务器的通信协议。"无限制版本https"可能意味着这个插件允许用户不受限制地...
C#基于HttpWebRequest实现模拟登陆
01-08
本篇文章将深入探讨如何使用C#的`HttpWebRequest`类来模拟登录操作。 首先，理解HTTP请求的基本概念至关重要。HTTP（超文本传输协议）是互联网上应用最广泛的一种网络协议，负责客户端（如浏览器）和服务器之间的...
HttpWebRequest采集（二）-- C#解析html
07-28
本篇文章将深入探讨如何使用C#编程语言通过HttpWebRequest类来实现网页HTML的抓取和解析。HttpWebRequest是.NET框架中用于发送HTTP请求的类，它是WebRequest的一个子类，能够帮助开发者构建基于HTTP的应用程序。 ...
HTTP辅助类组件RestSharp.dll文件
03-29
Http辅助类组件RestSharp。使用简单，只用到RestClient和RestRequest两种类型，同时支持上传文件
用C#实现的SOCKS5代理服务器源代码
03-16
作者：Kingthy早上看到breeze写了一篇Socks5代理协议的文章《C# 实现Socket5代理协议通讯 》，并在评论里看到howaaa说“顺便也讲讲用C#实现一个Socks5代理服务器吧，这方面资料很少，相信很有价值”，于是一时兴起，花了一个下午的时间捣鼓出Socks5代理的服务端程序。
HttpWebRequest 网络代理工具类
lygachao的博客
09-12 473
private int _timeOut = 20000;         private int _readWriteTimeOut = 60000;         private bool _ignoreSSLCheck = true;         ///         /// 等待请求开始返回的超时时间         ///         public i
发送HttpWebRequest请求工具类
冻死的企鹅
03-05 318
public static class PSWebUtils { private const string SIMPLECHECK_KEY_SN_PARAM_NAME = "__sk_keysn"; private const string SIMPLECHECK_KEY_ID_PARAM_NAME = "__sk_keyid"; private const string SIMPLECHECK_KEY_SN_PARAM_NAME_PS = "Key.
HttpWebRequest类
D0126_的博客
04-20 812
HttpWebRequest这个类非常强大，强大的地方在于它封装了几乎HTTP请求报文里需要用到的东西，以致于能够能够发送任意的HTTP请求并获得服务器响应(Response)信息。HttpRequest类的对象用于服务器端，获取客户端传来的请求的信息，包括HTTP报文传送过来的所有信息。你需要详细了解下HTTP方面的知识，比如HTTP请求报文之类的。//将上传的东西保存。
HttpRequest帮助类
chuxue1342的专栏
05-12 1108
using System; using System.Collections.Generic; using System.Text; using System.Threading; using System.Net; using System.IO; using System.Web; using System.Drawing; using ICSharpCode.SharpZip
C# HttpClient请求Webapi帮助类
weixin_30687811的博客
02-26 952
引用Newtonsoft.Json // Post请求 public string PostResponse(string url,string postData,out string statusCode) { string result = string.Empty; //设置H...
C# HttpHelper,帮助类,真正的Httprequest请求时无视编码，无视证书，无视Cookie,网页抓取
蒋小龙的IT史
01-14 4196
这个类是专门为HTTP的GET和POST请求写的，解决了编码，证书，自动带Cookie等问题。
HttpWebRequest
最新发布
06-11
HttpWebRequest是.NET Framework中的一个类，用于向Web服务器发送HTTP请求并接收响应。它允许开发人员在.NET应用程序中执行各种HTTP操作，例如GET、POST、PUT、DELETE等。可以使用HttpWebRequest来与Web服务器通信，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值