C⻠中はHttpWebRequestでGET/HTTP/HTTPS要求を送信します。

using System;
using System.Collections.Generic;
using System.IO;
using System.IO.Compression;
using System.Net;
using System.Net.Security;
using System.Security.Cryptography.X509Certificates;
using System.Text;

namespace Common
{
    public class HttpResponse
    {
        #region Static Field

        private static readonly string DefaultUserAgent = "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.2; SV1; .NET CLR 1.1.4322; .NET CLR 2.0.50727)";

        #endregion Static Field

        #region public Method

        /// 

        /// Get    Json  
        /// 
        /// 
        /// 
        public static string GetHttpResponseJson(string url, IWebProxy webProxy)
        {
            string json = string.Empty;
            Encoding encoding = Encoding.UTF8;
            HttpWebResponse Response = CreateGetHttpResponse(new HttpGetParametersModel()
            {
                Url = url,
                WebProxy = webProxy
            });
            json = GetStream(Response, encoding);
            return json;
        }

        /// 

        /// Post Url  Json  
        /// 
        /// 
        /// 
        public static string PostHttpResponseJson(string url, IWebProxy webProxy)
        {
            string json = string.Empty;
            Encoding encoding = Encoding.UTF8;
            HttpWebResponse Response = CreatePostHttpResponse(new HttpPostParametersModel()
            {
                Url = url,
                RequestEncoding = encoding,
                WebProxy = webProxy
            });
            json = GetStream(Response, encoding);
            return json;
        }

        /// 

        ///  Post     Url  Json  
        /// 
        /// 
        /// 
        /// 
        public static string PostHttpResponseJson(string url, IWebProxy webProxy, IDictionary<string, string> postDict)
        {
            string json = string.Empty;
            Encoding encoding = Encoding.UTF8;
            HttpWebResponse Response = CreatePostHttpResponse(new HttpPostParametersModel()
            {
                Url = url,
                DictParameters = postDict,
                WebProxy = webProxy,
                RequestEncoding = encoding
            });
            json = GetStream(Response, encoding);
            return json;
        }

        /// 

        ///   GET   HTTP  
        /// 
        ///    URL
        ///        
        ///            ，    
        ///   HTTP     Cookie  ，             
        /// 
        public static HttpWebResponse CreateGetHttpResponse(HttpGetParametersModel getParametersModel)
        {
            if (string.IsNullOrEmpty(getParametersModel.Url))
            {
                throw new ArgumentNullException("getParametersModel.Url");
            }
            HttpWebRequest request = WebRequest.Create(getParametersModel.Url) as HttpWebRequest;
            if (getParametersModel.WebProxy != null)
            {
                request.Proxy = getParametersModel.WebProxy;
            }
            request.Method = "GET";
            request.UserAgent = DefaultUserAgent;
            if (!string.IsNullOrEmpty(getParametersModel.UserAgent))
            {
                request.UserAgent = getParametersModel.UserAgent;
            }
            if (getParametersModel.Timeout.HasValue)
            {
                request.Timeout = getParametersModel.Timeout.Value;
            }
            if (getParametersModel.Cookies != null)
            {
                request.CookieContainer = new CookieContainer();
                request.CookieContainer.Add(getParametersModel.Cookies);
            }
            return request.GetResponse() as HttpWebResponse;
        }

        /// 

        ///   POST   HTTP  
        /// 
        ///    URL
        ///     POST           
        ///        
        ///            ，    
        ///   HTTP        
        ///   HTTP     Cookie  ，             
        /// 
        public static HttpWebResponse CreatePostHttpResponse(HttpPostParametersModel postParametersModel)
        {
            if (string.IsNullOrEmpty(postParametersModel.Url))
            {
                throw new ArgumentNullException("postParametersModel.Url");
            }
            if (postParametersModel.RequestEncoding == null)
            {
                throw new ArgumentNullException("postParametersModel.RequestEncoding");
            }
            HttpWebRequest request = null;
            //     HTTPS  
            if (postParametersModel.Url.StartsWith("https", StringComparison.OrdinalIgnoreCase))
            {
                ServicePointManager.ServerCertificateValidationCallback = new RemoteCertificateValidationCallback(CheckValidationResult);
                request = WebRequest.Create(postParametersModel.Url) as HttpWebRequest;
                request.ProtocolVersion = HttpVersion.Version10;
            }
            else
            {
                request = WebRequest.Create(postParametersModel.Url) as HttpWebRequest;
            }
            if (postParametersModel.WebProxy != null)
            {
                request.Proxy = postParametersModel.WebProxy;
            }
            request.Method = "POST";
            request.ContentType = "application/x-www-form-urlencoded";

            if (!string.IsNullOrEmpty(postParametersModel.UserAgent))
            {
                request.UserAgent = postParametersModel.UserAgent;
            }
            else
            {
                request.UserAgent = DefaultUserAgent;
            }

            if (postParametersModel.Timeout.HasValue)
            {
                request.Timeout = postParametersModel.Timeout.Value;
            }
            if (postParametersModel.Cookies != null)
            {
                request.CookieContainer = new CookieContainer();
                request.CookieContainer.Add(postParametersModel.Cookies);
            }
            //    POST  
            if (!(postParametersModel.DictParameters == null || postParametersModel.DictParameters.Count == 0))
            {
                StringBuilder buffer = new StringBuilder();
                int i = 0;
                foreach (string key in postParametersModel.DictParameters.Keys)
                {
                    if (i > 0)
                    {
                        buffer.AppendFormat("&{0}={1}", key, postParametersModel.DictParameters[key]);
                    }
                    else
                    {
                        buffer.AppendFormat("{0}={1}", key, postParametersModel.DictParameters[key]);
                    }
                    i++;
                }
                byte[] data = postParametersModel.RequestEncoding.GetBytes(buffer.ToString());
                using (Stream stream = request.GetRequestStream())
                {
                    stream.Write(data, 0, data.Length);
                }
            }
            return request.GetResponse() as HttpWebResponse;
        }

        #endregion public Method

        #region Private Method

        /// 

        ///   https      ,    True,    
        /// 
        /// 
        /// 
        /// 
        /// 
        /// 
        private static bool CheckValidationResult(object sender, X509Certificate certificate, X509Chain chain, SslPolicyErrors errors)
        {
            return true; //    
        }

        /// 

        ///  response     
        /// 
        /// 
        /// 
        /// 
        private static string GetStream(HttpWebResponse response, Encoding encoding)
        {
            try
            {
                if (response.StatusCode == HttpStatusCode.OK)
                {
                    switch (response.ContentEncoding.ToLower())
                    {
                        case "gzip":
                            {
                                string result = Decompress(response.GetResponseStream(), encoding);
                                response.Close();
                                return result;
                            }
                        default:
                            {
                                using (StreamReader sr = new StreamReader(response.GetResponseStream(), encoding))
                                {
                                    string result = sr.ReadToEnd();
                                    sr.Close();
                                    sr.Dispose();
                                    response.Close();
                                    return result;
                                }
                            }
                    }
                }
                else
                {
                    response.Close();
                }
            }
            catch (Exception e)
            {
                throw e;
            }
            return "";
        }

        private static string Decompress(Stream stream, Encoding encoding)
        {
            byte[] buffer = new byte[100];
            //int length = 0;

            using (GZipStream gz = new GZipStream(stream, CompressionMode.Decompress))
            {
                //GZipStream gzip = new GZipStream(res.GetResponseStream(), CompressionMode.Decompress);
                using (StreamReader reader = new StreamReader(gz, encoding))
                {
                    return reader.ReadToEnd();
                }
                /*
                using (MemoryStream msTemp = new MemoryStream())
                {
                    //       Read      ，    GZipStream   Length   ，     ：System.NotSupportedException:       ；
                    while ((length = gz.Read(buffer, 0, buffer.Length)) != 0)
                    {
                        msTemp.Write(buffer, 0, length);
                    }

                    return encoding.GetString(msTemp.ToArray());
                }
                 * */
            }
        }

        #endregion Private Method

        #region     

        /// 

        ///   POST  Json   HTTP  （   https    ）
        /// 
        ///    URL
        ///     POST           
        ///        
        ///            ，    
        ///   HTTP        
        ///   HTTP     Cookie  ，             
        /// 
        [Obsolete("       ")]
        private HttpWebResponse CreatePostHttpResponseJson(string url, string postJson, string parameters, int? timeout, string userAgent, Encoding requestEncoding, string referer)
        {
            if (string.IsNullOrEmpty(url))
            {
                throw new ArgumentNullException("url");
            }
            if (requestEncoding == null)
            {
                throw new ArgumentNullException("requestEncoding");
            }

            HttpWebRequest request = null;
            //     HTTPS  
            if (url.StartsWith("https", StringComparison.OrdinalIgnoreCase))
            {
                ServicePointManager.ServerCertificateValidationCallback = new RemoteCertificateValidationCallback(CheckValidationResult);
                request = WebRequest.Create(url) as HttpWebRequest;
                request.ProtocolVersion = HttpVersion.Version10;
            }
            else
            {
                request = WebRequest.Create(url) as HttpWebRequest;
            }

            request.Method = "POST";
            //                  JSON    
            request.ContentType = "application/json;charset=UTF-8";
            request.KeepAlive = true;

            if (!string.IsNullOrEmpty(userAgent))
            {
                request.UserAgent = userAgent;
            }
            else
            {
                request.UserAgent = DefaultUserAgent;
            }

            if (timeout.HasValue)
            {
                request.Timeout = timeout.Value;
            }

            //    POST  

            #region post parameter    querystring  

            if (parameters != null)
            {
                byte[] data = requestEncoding.GetBytes(parameters);
                using (Stream stream = request.GetRequestStream())
                {
                    stream.Write(data, 0, data.Length);
                    stream.Close();
                }
            }

            #endregion post parameter    querystring  

            #region post json

            if (!string.IsNullOrEmpty(postJson))
            {
                using (var streamWriter = new StreamWriter(request.GetRequestStream()))
                {
                    //string json = "{\"user\":\"test\"," +
                    //              "\"password\":\"bla\"}";

                    streamWriter.Write(postJson);
                    streamWriter.Flush();
                    streamWriter.Close();
                }
            }

            #endregion post json

            if (!string.IsNullOrEmpty(referer))
            {
                request.Referer = referer;
            }

            HttpWebResponse response = request.GetResponse() as HttpWebResponse;

            if (request.CookieContainer != null)
            {
                response.Cookies = request.CookieContainer.GetCookies(request.RequestUri);
            }

            return response;
        }

        #endregion     
    }

    #region GET/POST      

    /// 

    /// GET      
    /// 
    public class HttpGetParametersModel
    {
        /// 

        ///    URL(GET       )
        /// 
        public string Url { get; set; }

        /// 

        ///     
        /// 
        public int? Timeout { get; set; }

        /// 

        ///       
        /// 
        public string UserAgent { get; set; }

        /// 

        /// Web    
        /// 
        public IWebProxy WebProxy { get; set; }

        /// 

        /// Cookies  
        /// 
        public CookieCollection Cookies { get; set; }
    }

    /// 

    /// POST      
    /// 
    public class HttpPostParametersModel : HttpGetParametersModel
    {
        /// 

        /// POST    
        /// 
        public IDictionary<string, string> DictParameters { get; set; }

        /// 

        ///   HTTP        
        /// 
        public Encoding RequestEncoding { get; set; }
    }

    #endregion GET/POST      
}

<system.net>
    
    
    <defaultProxy>
      <proxy
        usesystemdefault="True"
        proxyaddress="http://172.27.1.252:80"
        bypassonlocal="True" />
    defaultProxy>
    system.net>