private static HttpWebRequest CreateRequest(string url, string method)
        {
            int timeout = Convert.ToInt16(ConfigurationManager.AppSettings["timeout"]);
            string userAgent = ConfigurationManager.AppSettings["userAgent"];

            try
            {
                var uri = new Uri(url);
                var request = (HttpWebRequest)WebRequest.Create(uri);
                if (method != "GET")
                {
                    WebRequest.DefaultWebProxy = new WebProxy();
                    request.Timeout = timeout;
                    request.UserAgent = userAgent;
                    var policy = new HttpRequestCachePolicy(HttpRequestCacheLevel.Default);
                    HttpWebRequest.DefaultCachePolicy = policy;
                    var noCachePolicy = new HttpRequestCachePolicy(HttpRequestCacheLevel.NoCacheNoStore);
                    request.CachePolicy = noCachePolicy;
                }
                return request;
            }
            catch (Exception err)
            {
                MessageBox.Show(err.Message);
                return null;
            }
        }

 public void Ctor_ExpectedPropertyValues(
     HttpRequestCachePolicy p, HttpRequestCacheLevel level, TimeSpan maxAge, TimeSpan maxStale, TimeSpan minFresh, DateTime cacheSyncDate)
 {
     Assert.Equal(level, p.Level);
     Assert.Equal(maxAge, p.MaxAge);
     Assert.Equal(maxStale, p.MaxStale);
     Assert.Equal(minFresh, p.MinFresh);
     Assert.Equal(cacheSyncDate, p.CacheSyncDate);
     Assert.StartsWith("Level:", p.ToString());
 }

 private HttpWebRequest CreateWebApiRequest(String relativeUri)
 {
     var request = (HttpWebRequest)WebRequest.Create(new Uri(_uri, relativeUri));
     request.ContentType = SchedulerConstants.RequestJsonContentType;
     request.Headers.Add("Authorization",
                         new Signature(this._subscriptionId, this._secretKey).ToString());
     HttpRequestCachePolicy noCachePolicy = new HttpRequestCachePolicy(HttpRequestCacheLevel.NoCacheNoStore);
     request.CachePolicy = noCachePolicy;
     return request;
 }

 public static void Test_WebRequest_03(string url)
 {
     // create HttpWebRequest or FileWebRequest
     WebRequest req = WebRequest.Create(url);
     HttpRequestCachePolicy cachePolicy = new HttpRequestCachePolicy(HttpRequestCacheLevel.Default);
     req.CachePolicy = cachePolicy;
     // RequestCachePolicy
     _tr.WriteLine("Test_WebRequest_03");
     _tr.WriteLine("  url : \"{0}\"", url);
     _tr.WriteLine("  WebRequest.Create(url) : \"{0}\"", req);
 }

        public string GetResponse(string host, IDictionary<string, object> arguments,
            bool useCookies = false)
        {
            const string contentType = "application/x-www-form-urlencoded";
            const string requestType = "POST";

            Logging.LogLine("POSTing to " + host + " " + arguments.GetHashCode(), "browser serv");

            var isFirst = true;

            if (useCookies)
            {
                if (!arguments.ContainsKey("csrf_token"))
                    arguments["csrf_token"] = GetCsrfToken();
            }

            var totalRequest = new StringBuilder();
            foreach (var arg in arguments.Where(arg => arg.Key != "type"))
            {
                if (!isFirst)
                    totalRequest.Append('&');
                else
                    isFirst = false;

                totalRequest.Append(arg.Key);
                totalRequest.Append('=');
                totalRequest.Append(HttpUtility.UrlEncode((string) arg.Value));
            }

            var toPost = Encoding.ASCII.GetBytes(totalRequest.ToString());

            var cachePolicy = new HttpRequestCachePolicy(HttpRequestCacheLevel.NoCacheNoStore);
            var req = (HttpWebRequest) WebRequest.Create(host);
            req.CachePolicy = cachePolicy;
            req.Method = requestType;
            req.ContentType = contentType;
            req.ContentLength = toPost.Length;
            req.UserAgent = Constants.FriendlyName;

            if (useCookies)
                req.CookieContainer = loginCookies;

            using (var postStream = req.GetRequestStream())
                postStream.Write(toPost, 0, toPost.Length);

            using (var rep = (HttpWebResponse) req.GetResponse())
            using (var answerStream = rep.GetResponseStream())
            {
                if (answerStream == null)
                    return null;
                using (var answerReader = new StreamReader(answerStream))
                    return answerReader.ReadToEnd();
            }
        }

 // retornar la respuesta en JSON.
 private static string GetResponseJSON(string uri)
 {
     HttpRequestCachePolicy policy = new HttpRequestCachePolicy(HttpRequestCacheLevel.Default);
     HttpWebRequest.DefaultCachePolicy = policy;
     WebRequest request = WebRequest.Create(uri);
     HttpRequestCachePolicy noCachePolicy = new HttpRequestCachePolicy(HttpRequestCacheLevel.NoCacheNoStore);
     request.CachePolicy = noCachePolicy;
     WebResponse response = request.GetResponse();
     using (Stream responseStream = response.GetResponseStream())
     {
         StreamReader reader = new StreamReader(responseStream, Encoding.UTF8);
         return reader.ReadToEnd();
     }
 }

        /// <summary>
        /// Gets web response of request specifying accept header header explicitly
        /// </summary>
        /// <param name="request">HttpWebRequest request</param>
        /// <param name="acceptHeaderValue">The specified accept header</param>
        /// <param name="maximumPayloadSize">Maximum size of response in byte to be allowed to receive</param>
        /// <returns>Web response</returns>
        public static Response Get(HttpWebRequest request, string acceptHeaderValue, int maximumPayloadSize)
        {
            if (request == null)
            {
                throw new ArgumentNullException("request");
            }

            if (!string.IsNullOrEmpty(acceptHeaderValue))
            {
                request.Accept = acceptHeaderValue;
            }

            // make sure cache disabled, otherwise intermediate proxy would likely return cached responses
            HttpRequestCachePolicy cachePolicy = new HttpRequestCachePolicy(HttpRequestCacheLevel.NoCacheNoStore);
            request.CachePolicy = cachePolicy;
            return WebHelper.Get(request, maximumPayloadSize);
        }

        public string GetResponse(string host, IEnumerable<KeyValuePair<string, object>> arguments,
            bool useCookies = false)
        {
            const string contentType = "application/x-www-form-urlencoded";
            const string requestType = "POST";

            var isFirst = true;

            var totalRequest = new StringBuilder();
            foreach (var arg in arguments.Where(arg => arg.Key != "type"))
            {
                if (!isFirst)
                    totalRequest.Append('&');
                else
                    isFirst = false;

                totalRequest.Append(arg.Key);
                totalRequest.Append('=');
                totalRequest.Append(HttpUtility.UrlEncode((string) arg.Value));
            }

            var toPost = Encoding.ASCII.GetBytes(totalRequest.ToString());

            var cachePolicy = new HttpRequestCachePolicy(HttpRequestCacheLevel.NoCacheNoStore);
            var req = (HttpWebRequest) WebRequest.Create(host);
            req.CachePolicy = cachePolicy;
            req.Method = requestType;
            req.ContentType = contentType;
            req.ContentLength = toPost.Length;

            if (useCookies)
                req.CookieContainer = loginCookies;

            using (var postStream = req.GetRequestStream())
                postStream.Write(toPost, 0, toPost.Length);

            using (var rep = (HttpWebResponse) req.GetResponse())
            using (var answerStream = rep.GetResponseStream())
            {
                if (answerStream == null)
                    return null;
                using (var answerReader = new StreamReader(answerStream))
                    return answerReader.ReadToEnd(); // read our response
            }
        }

        public void TestCache()
        {
            HttpRequestCachePolicy policy = new HttpRequestCachePolicy(HttpRequestCacheLevel.Revalidate);
              Session.CachePolicy = policy;

              Request req = new Request(Session, new Uri("http://www.dr.dk/drfront/images//2013/05/21/c=0,17,1024,505;w=300;42676.jpg"));

              using (var resp = req.Accept("image/jpeg").Get<byte[]>())
              {
            resp.SaveToFile("c:\\tmp\\scrap.jpg");
            Assert.AreEqual(HttpStatusCode.OK, resp.StatusCode);
              }

              using (var resp = req.Accept("image/jpeg").Get<byte[]>())
              {
            resp.SaveToFile("c:\\tmp\\scrap.jpg");
            Assert.AreEqual(HttpStatusCode.NotModified, resp.StatusCode);
              }
        }

        /// <summary>
        /// 请求并返回
        /// </summary>
        public static string GetRequestModel()
        {
            var url = string.Format("http://192.168.1.180:8002/login.aspx?key={0}", "test");
            HttpWebRequest webRequest = HttpWebRequest.Create(url) as HttpWebRequest;
            webRequest.Method = "GET";
            HttpRequestCachePolicy cPolicy = new HttpRequestCachePolicy(HttpRequestCacheLevel.NoCacheNoStore);
            webRequest.CachePolicy = cPolicy;
            webRequest.Pipelined = false;
            webRequest.KeepAlive = false;
            webRequest.AllowAutoRedirect = true;
            webRequest.UserAgent = "Mozilla/5.0 (Windows NT 6.1; WOW64; rv:13.0) Gecko/20100101 Firefox/13.0.1";
            webRequest.Accept = "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8";
            webRequest.Headers.Add("Accept-Language", "zh-cn,zh;q=0.8,en-us;q=0.5,en;q=0.3");
            webRequest.Headers.Add("Cookie", "JSESSIONID=396C8439833102EFAF868D6297A9D8FD.web25_8081; __utma=142379556.1006189020.1343613376.1343613376.1343651790.2; __utmb=142379556.2.10.1343651790; __utmc=142379556; __utmz=142379556.1343613376.1.1.utmcsr=(direct)|utmccn=(direct)|utmcmd=(none)");
            HttpWebResponse response = webRequest.GetResponse() as HttpWebResponse;

            var strRet = string.Empty;
            try
            {
                System.IO.Stream resStream = response.GetResponseStream();
                Encoding encode = System.Text.Encoding.Default;
                StreamReader readStream = new StreamReader(resStream, encode);
                Char[] read = new Char[256];
                int count = readStream.Read(read, 0, 256);
                while (count > 0)
                {
                    String str = new String(read, 0, count);
                    strRet = strRet + str;
                    count = readStream.Read(read, 0, 256);
                }
                resStream.Close();
            }
            catch (Exception e)
            {
                strRet = "";
            }
            return strRet;
        }

 internal RequestCachingSectionInternal(RequestCachingSection section)
 {
     if (!section.DisableAllCaching)
     {
         this.defaultCachePolicy = new RequestCachePolicy(section.DefaultPolicyLevel);
         this.isPrivateCache = section.IsPrivateCache;
         this.unspecifiedMaximumAge = section.UnspecifiedMaximumAge;
     }
     else
     {
         this.disableAllCaching = true;
     }
     this.httpRequestCacheValidator = new HttpRequestCacheValidator(false, this.UnspecifiedMaximumAge);
     this.ftpRequestCacheValidator = new FtpRequestCacheValidator(false, this.UnspecifiedMaximumAge);
     this.defaultCache = new WinInetCache(this.IsPrivateCache, true, true);
     if (!section.DisableAllCaching)
     {
         HttpCachePolicyElement defaultHttpCachePolicy = section.DefaultHttpCachePolicy;
         if (defaultHttpCachePolicy.WasReadFromConfig)
         {
             if (defaultHttpCachePolicy.PolicyLevel == HttpRequestCacheLevel.Default)
             {
                 HttpCacheAgeControl cacheAgeControl = (defaultHttpCachePolicy.MinimumFresh != TimeSpan.MinValue) ? HttpCacheAgeControl.MaxAgeAndMinFresh : HttpCacheAgeControl.MaxAgeAndMaxStale;
                 this.defaultHttpCachePolicy = new HttpRequestCachePolicy(cacheAgeControl, defaultHttpCachePolicy.MaximumAge, (defaultHttpCachePolicy.MinimumFresh != TimeSpan.MinValue) ? defaultHttpCachePolicy.MinimumFresh : defaultHttpCachePolicy.MaximumStale);
             }
             else
             {
                 this.defaultHttpCachePolicy = new HttpRequestCachePolicy(defaultHttpCachePolicy.PolicyLevel);
             }
         }
         FtpCachePolicyElement defaultFtpCachePolicy = section.DefaultFtpCachePolicy;
         if (defaultFtpCachePolicy.WasReadFromConfig)
         {
             this.defaultFtpCachePolicy = new RequestCachePolicy(defaultFtpCachePolicy.PolicyLevel);
         }
     }
 }

        public WebReqResult GetHTML(string url)
        {
            WebReqResult result = new WebReqResult();

            try
            {
                HttpWebRequest request = (HttpWebRequest)WebRequest.Create(url);
                HttpRequestCachePolicy cachePolicy = new HttpRequestCachePolicy(HttpRequestCacheLevel.NoCacheNoStore);
                WebHeaderCollection requestHeaderCollection = request.Headers;

                requestHeaderCollection.Add("Accept-Language:en-US,en;q=0.5");

                request.Accept = "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8";
                request.AutomaticDecompression = DecompressionMethods.GZip | DecompressionMethods.Deflate;
                request.CachePolicy = cachePolicy;
                request.Proxy = null; // Proxy autodetection slows down requests ( http://stackoverflow.com/a/935728 )
                request.Timeout = 5000;
                request.UserAgent = "Mozilla/5.0 (Windows NT 6.3; WOW64; rv:38.0) Gecko/20100101 Firefox/38.0";

                using (HttpWebResponse response = (HttpWebResponse)request.GetResponse())
                {
                    Stream stream = response.GetResponseStream();
                    StreamReader readStream = new StreamReader(stream);
                    string html = WebUtility.HtmlDecode(readStream.ReadToEnd());
                    result.Success = true;
                    result.HTML = html;
                }
            }
            catch (Exception e)
            {
                result.Success = false;
                result.Error = e.Message;
            }

            return result;
        }

        private static HttpWebRequest CreateRequest(Uri url, string data, string method, string contentType, NameValueCollection headers, int timeout, bool gzip, NetworkCredential credential = null)
        {
            var request = (HttpWebRequest)WebRequest.Create(url);

            request.Method = method.ToUpper();
            request.ContentType = contentType;
            var noCachePolicy = new HttpRequestCachePolicy(HttpRequestCacheLevel.NoCacheNoStore);
            request.CachePolicy = noCachePolicy;
            request.Timeout = timeout;
            request.Credentials = credential;

            if (headers != null)
                request.Headers.Add(headers);

            if (gzip)
                request.Headers.Add(HttpRequestHeader.AcceptEncoding, "gzip, deflate");

            if (data != null)
            {
                var encoding = new UTF8Encoding();
                var byteData = encoding.GetBytes(data);
                request.ContentLength = byteData.Length;

                using (var postStream = request.GetRequestStream())
                {
                    postStream.Write(byteData, 0, byteData.Length);
                }
            }
            else if (request.Method != "GET")
            {
                //Specify a zero content length to prevent 411s
                request.ContentLength = 0;
            }

            return request;
        }

 public void SetCacheControlWithMaxAgeAndMinFresh(TimeSpan maxAge, TimeSpan minFresh)
 {
     _cachePolicy = new HttpRequestCachePolicy(HttpCacheAgeControl.MaxAgeAndMinFresh, maxAge, minFresh);
 }

 public void SetCacheControlWithMaxAgeAndMaxStale(TimeSpan maxAge, TimeSpan maxStale)
 {
     _cachePolicy = new HttpRequestCachePolicy(HttpCacheAgeControl.MaxAgeAndMaxStale, maxAge, maxStale);
 }

 public void SetCacheControlToNoCache()
 {
     _cachePolicy = new HttpRequestCachePolicy(HttpRequestCacheLevel.NoCacheNoStore);
 }

        public void WhenCreatingSessionItCopiesAllSimpleProperties()
        {
            // Arrange
              HttpRequestCachePolicy policy = new HttpRequestCachePolicy(HttpRequestCacheLevel.CacheOrNextCacheOnly);

              IService service = RamoneConfiguration.NewService(BaseUrl);
              service.UserAgent = "Dummy";
              service.DefaultEncoding = Encoding.ASCII;
              service.DefaultRequestMediaType = new MediaType("X/1");
              service.DefaultResponseMediaType = new MediaType("Y/1");
              service.CachePolicy = policy;

              // Act
              ISession session = service.NewSession();

              // Assert
              Assert.AreEqual("Dummy", session.UserAgent);
              Assert.AreEqual(Encoding.ASCII, session.DefaultEncoding);
              Assert.AreEqual(new MediaType("X/1"), session.DefaultRequestMediaType);
              Assert.AreEqual(new MediaType("Y/1"), session.DefaultResponseMediaType);
              Assert.AreEqual(BaseUrl, session.BaseUri);
              Assert.AreEqual(policy, session.CachePolicy);
        }

        private Stream ResponseStreamPOST()
        {
            ServicePointManager.Expect100Continue = false;
            string regionquery = "";

            if (_region.Key != -1)
            {
                regionquery = "lr=" + _region.Key + "&";

            }
            /* Адрес для совершения запроса, полученный при регистрации IP,
            в него уже забит логин и ключ API.*/
            string url = @"http://yandex.ru/search/xml?" + regionquery + "user=" + _APICredentials.User + "&key=" + _APICredentials.Key;

            //if (_region.Key != -1)
            //{
            //    long swift = 11000000; //Смещение для регионов

            //    long swiftedregion = swift +  _region.Key;

            //    regionquery = " cat:" + swiftedregion.ToString();

            //}
            // Текст запроса в формате XML
            string command =
                @"<?xml version=""1.0"" encoding=""UTF-8""?>
             <request>
               <query>"
             + _query.ToString() +
               @"</query>
               <page>"
             + _page.ToString() +
               @"</page>
              <maxpassages>2</maxpassages>
              <groupings>
            <groupby attr=""d"" mode=""deep"" groups-on-page = ""50"" docs-in-group=""1"" curcateg=""-1""/>
              </groupings>
                      </request>";

            byte[] bytes = Encoding.UTF8.GetBytes(command);
            // Объект, с помощью которого будем отсылать запрос и получать ответ.
            HttpRequestCachePolicy policy = new HttpRequestCachePolicy(HttpRequestCacheLevel.NoCacheNoStore);
            HttpWebRequest.DefaultCachePolicy = policy;
            HttpWebRequest request = (HttpWebRequest)WebRequest.Create(url);

            request.Method = "POST";
            request.ContentLength = bytes.Length;
            request.ContentType = "text/xml";
            // Пишем наш XML-запрос в поток
            using (Stream requestStream = request.GetRequestStream())
            {
                requestStream.Write(bytes, 0, bytes.Length);
            }

            // Получаем ответ
            HttpWebResponse response = (HttpWebResponse)request.GetResponse();
            Stream responsestream = response.GetResponseStream();
            return responsestream;
        }

        public String monitisHttpGet(String url_and_parameter)
        {
            WebRequest request;
            request = WebRequest.Create(url_and_parameter);
            HttpRequestCachePolicy noCachePolicy = new HttpRequestCachePolicy(HttpRequestCacheLevel.NoCacheNoStore);
            request.CachePolicy = noCachePolicy;
 
            Stream objStream;
            objStream = request.GetResponse().GetResponseStream();

            StreamReader objReader = new StreamReader(objStream);
            String response = objReader.ReadToEnd();

            objStream.Close();
            objReader.Close();

            return response;
        }

        public string GetPageHTML(string pageUrl, int timeoutSeconds)
        {
            System.Net.WebResponse response = null;

            try
            {
                // Setup our Web request
                System.Net.WebRequest request = System.Net.WebRequest.Create(pageUrl);
                HttpRequestCachePolicy noCachePolicy = new HttpRequestCachePolicy(HttpRequestCacheLevel.NoCacheNoStore);
                request.CachePolicy = noCachePolicy;
                try
                {
                    request.Proxy.Credentials = System.Net.CredentialCache.DefaultNetworkCredentials;
                }
                catch (Exception proxyE)
                {
                    PumpString("Error setting proxy server: " + proxyE.Message, false, false, new Version(), false, "");
                }

                request.Timeout = timeoutSeconds * 1000;

                // Retrieve data from request
                response = request.GetResponse();

                System.IO.Stream streamReceive = response.GetResponseStream();
                System.Text.Encoding encoding = System.Text.Encoding.GetEncoding("utf-8");
                System.IO.StreamReader streamRead = new System.IO.StreamReader(streamReceive, encoding);

                // return the retrieved HTML
                return streamRead.ReadToEnd();
            }
            catch (Exception ex)
            {
                // Error occured grabbing data, return empty string.
                PumpString("An error occurred while retrieving the HTML content. " + ex.Message, false, false, new Version(), false, "");
                return "";
            }
            finally
            {
                // Check if exists, then close the response.
                if (response != null)
                {
                    response.Close();
                }
            }
        }