/// <summary>
        /// Process the web response and output corresponding objects. 
        /// </summary>
        /// <param name="response"></param>
        internal override void ProcessResponse(WebResponse response)
        {
            if (null == response) { throw new ArgumentNullException("response"); }

            // check for Server Core, throws exception if -UseBasicParsing is not used
            if (ShouldWriteToPipeline && (!UseBasicParsing))
            {
                VerifyInternetExplorerAvailable(true);
            }

            Stream responseStream = StreamHelper.GetResponseStream(response);
            if (ShouldWriteToPipeline)
            {
                // creating a MemoryStream wrapper to response stream here to support IsStopping.
                responseStream = new WebResponseContentMemoryStream(responseStream, StreamHelper.ChunkSize, this);
                WebResponseObject ro = WebResponseObjectFactory.GetResponseObject(response, responseStream, this.Context, UseBasicParsing);
                WriteObject(ro);

                // use the rawcontent stream from WebResponseObject for further 
                // processing of the stream. This is need because WebResponse's
                // stream can be used only once.
                responseStream = ro.RawContentStream;
                responseStream.Seek(0, SeekOrigin.Begin);
            }

            if (ShouldSaveToOutFile)
            {
                StreamHelper.SaveStreamToFile(responseStream, QualifiedOutFile, this);
            }
        }

        /// <summary>
        /// 
        /// </summary>
        /// <exception cref="System.ArgumentNullException">if response is null.</exception>
        /// <param name="response"></param>
        public WebResult(WebResponse response)
        {
            if (response == null) throw new ArgumentNullException(nameof(response));

            this.Type = WebResultType.Succeed;
            this.Response = response;
        }

        public void ProcessReponse(List<SearchResultItem> list, WebResponse resp)
        {
            var response = new StreamReader(resp.GetResponseStream()).ReadToEnd();

            var info = JsonConvert.DeserializeObject<BergGetStockResponse>(response, new JsonSerializerSettings()
            {
                Culture = CultureInfo.GetCultureInfo("ru-RU")
            });

            if (info != null && info.Resources.Length > 0)
            {
                foreach (var resource in info.Resources.Where(r => r.Offers != null))
                {
                    foreach (var offer in resource.Offers)
                    {
                        list.Add(new SearchResultItem()
                        {
                            Article = resource.Article,
                            Name = resource.Name,
                            Vendor = PartVendor.BERG,
                            VendorPrice = offer.Price,
                            Quantity = offer.Quantity,
                            VendorId = resource.Id,
                            Brand = resource.Brand.Name,
                            Warehouse = offer.Warehouse.Name,
                            DeliveryPeriod = offer.AveragePeriod,
                            WarehouseId = offer.Warehouse.Id.ToString()
                        });
                    }

                }
            }
        }

 public ExtendedHttpWebResponse(Uri responseUri, WebResponse response, Stream responseStream, CacheInfo cacheInfo)
 {
     this.responseUri = responseUri;
     this.response = response;
     this.responseStream = responseStream;
     this.cacheInfo = cacheInfo;
 }

        public override PageContent GetContent(WebResponse p_Response)
        {
            // Navigate to the requested page using the WebDriver. PhantomJS will navigate to the page
            // just like a normal browser and the resulting html will be set in the PageSource property.
            m_WebDriver.Navigate().GoToUrl(p_Response.ResponseUri);

            // Let the JavaScript execute for a while if needed, for instance if the pages are doing async calls.
            //Thread.Sleep(1000);

            // Try to retrieve the charset and encoding from the response or body.
            string pageBody = m_WebDriver.PageSource;
            string charset = GetCharsetFromHeaders(p_Response);
            if (charset == null) {
                charset = GetCharsetFromBody(pageBody);
            }

            Encoding encoding = GetEncoding(charset);

            PageContent pageContent = new PageContent {
                    Encoding = encoding,
                    Charset = charset,
                    Text = pageBody,
                    Bytes = encoding.GetBytes(pageBody)
                };

            return pageContent;
        }

 public static dynamic FromResponse(WebResponse response)
 {
     using (var stream = response.GetResponseStream())
     {
         return FromStream(stream);
     }
 }

        /// <summary>
        /// 从Response获取错误信息
        /// </summary>
        /// <param name="response"></param>
        /// <returns></returns>
        public static WfServiceInvokeException FromWebResponse(WebResponse response)
        {
            StringBuilder strB = new StringBuilder();

            string content = string.Empty;

            using (Stream stream = response.GetResponseStream())
            {
                StreamReader streamReader = new StreamReader(stream, Encoding.UTF8);
                content = streamReader.ReadToEnd();
            }

            if (response is HttpWebResponse)
            {
                HttpWebResponse hwr = (HttpWebResponse)response;

                strB.AppendFormat("Status Code: {0}, Description: {1}\n", hwr.StatusCode, hwr.StatusDescription);
            }

            strB.AppendLine(content);

            WfServiceInvokeException result = new WfServiceInvokeException(strB.ToString());

            if (response is HttpWebResponse)
            {
                HttpWebResponse hwr = (HttpWebResponse)response;

                result.StatusCode = hwr.StatusCode;
                result.StatusDescription = hwr.StatusDescription;
            }

            return result;
        }

        public ICommandResponse ParseResponse(WebResponse response)
        {
            var request = _computeRequestService.GenerateRequest(null, _apiKey);
            _authenticator.AuthenticateRequest(WebRequest.Create(""), _base64Secret);//((RestClient)_client).BuildUri((RestRequest)request), _base64Secret);

            return _client.Execute<MachineResponse>((RestRequest)request).Data;
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="WebResponseDetails"/> class.
        /// </summary>
        /// <param name="webResponse">The web response.</param>
        public WebResponseDetails(WebResponse webResponse)
        {
            if (webResponse == null)
            {
                throw new ArgumentNullException("webResponse", "Server response could not be null");
            }

            //
            // Copy headers
            this.Headers = new Dictionary<string,string>();
            if ((webResponse.Headers != null) && (webResponse.Headers.Count > 0))
            {
                foreach (string key in webResponse.Headers.AllKeys)
                    this.Headers.Add(key, webResponse.Headers[key]);
            }

            //
            // Copy body (raw)
            try
            {
                StreamReader reader = new StreamReader(webResponse.GetResponseStream(), System.Text.Encoding.Default);
                this.Body = reader.ReadToEnd();
            }
            catch (ArgumentNullException exp_null)
            {
                //
                // No response stream ?
                System.Diagnostics.Trace.WriteLine("WebResponse does not have any response stream");
                this.Body = string.Empty;
            }
        }

 internal SharpBoxException(SharpBoxErrorCodes errorCode, Exception innerException, WebRequest request, WebResponse response)
     : base(GetErrorMessage(errorCode), innerException)
 {
     ErrorCode = errorCode;
     PostedRequet = request;
     DisposedReceivedResponse = response;
 }

	public WebException(String msg, Exception inner, 
		WebExceptionStatus status, WebResponse response) 
		: base(msg, inner) 
			{
				myresponse = response;
				mystatus = status;
			}

 private string ReadAll(WebResponse webResponse)
 {
     using (var reader = new StreamReader(webResponse.GetResponseStream()))
     {
         return reader.ReadToEnd();
     }
 }

        private void SetResponse(WebResponse response, Stream contentStream)
        {
            if (null == response) { throw new ArgumentNullException("response"); }

            BaseResponse = response;

            MemoryStream ms = contentStream as MemoryStream;
            if (null != ms)
            {
                _rawContentStream = ms;
            }
            else
            {
                Stream st = contentStream;
                if (contentStream == null)
                {
                    st = StreamHelper.GetResponseStream(response);
                }

                long contentLength = response.ContentLength;
                if (0 >= contentLength)
                {
                    contentLength = StreamHelper.DefaultReadBuffer;
                }
                int initialCapacity = (int)Math.Min(contentLength, StreamHelper.DefaultReadBuffer);
                _rawContentStream = new WebResponseContentMemoryStream(st, initialCapacity, null);
            }
            // set the position of the content stream to the beginning
            _rawContentStream.Position = 0;
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="AirbrakeResponse"/> class.
        /// </summary>
        /// <param name="response">The response.</param>
        /// <param name="content">The content.</param>
        public AirbrakeResponse(WebResponse response, string content)
        {
            this.log = LogManager.GetLogger(GetType());
            this.content = content;
            this.errors = new AirbrakeResponseError[0];

            if (response != null)
            {
                // TryGet is needed because the default behavior of WebResponse is to throw NotImplementedException
                // when a method isn't overridden by a deriving class, instead of declaring the method as abstract.
                this.contentLength = response.TryGet(x => x.ContentLength);
                this.contentType = response.TryGet(x => x.ContentType);
                this.headers = response.TryGet(x => x.Headers);
                this.isFromCache = response.TryGet(x => x.IsFromCache);
                this.isMutuallyAuthenticated = response.TryGet(x => x.IsMutuallyAuthenticated);
                this.responseUri = response.TryGet(x => x.ResponseUri);
            }

            try
            {
                Deserialize(content);
            }
            catch (Exception exception)
            {
                this.log.Fatal(f => f(
                    "An error occurred while deserializing the following content:\n{0}", content),
                               exception);
            }
        }

        public static bool SaveBinaryFile(WebResponse response, string FileName)
        {
            bool Value = true;
            byte[] buffer = new byte[1024];

            try
            {
                if (File.Exists(FileName))
                    File.Delete(FileName);
                Stream outStream = File.Create(FileName);
                Stream inStream = response.GetResponseStream();

                int l;
                do
                {
                    l = inStream.Read(buffer, 0, buffer.Length);
                    if (l > 0)
                        outStream.Write(buffer, 0, l);
                }
                while (l > 0);

                outStream.Close();
                inStream.Close();
            }
            catch
            {
                Value = false;
            }
            return Value;
        }

 public ICommandResponse ParseResponse(WebResponse response)
 {
     return new SetObjectACLResponse
     {
         Policy = response.Headers["x-emc-policy"]
     };
 }

        /// <summary>Print the error message as it came from the server.</summary>
        private void PrintErrorResponse(WebResponse response)
        {
            if (response == null)
            {
                return;
            }

            Stream responseStream = response.GetResponseStream();
            try
            {
                Stream errorStream = Console.OpenStandardError();
                try
                {
                    Copy(responseStream, errorStream);
                }
                finally
                {
                    errorStream.Close();
                }
            }
            finally
            {
                responseStream.Close();
            }
        }

 /// <summary>
 /// 
 /// </summary>
 /// <param name="response"></param>
 /// <returns></returns>
 private static Encoding getEncoding(WebResponse response)
 {
     try
     {
         String contentType = response.ContentType;
         if (contentType == null)
         {
             return _encoding;
         }
         String[] strArray = contentType.ToLower(CultureInfo.InvariantCulture).Split(new char[] { ';', '=', ' ' });
         Boolean isFind = false;
         foreach (String item in strArray)
         {
             if (item == "charset")
             {
                 isFind = true;
             }
             else if (isFind)
             {
                 return Encoding.GetEncoding(item);
             }
         }
     }
     catch (Exception exception)
     {
         if (((exception is ThreadAbortException) || (exception is StackOverflowException)) || (exception is OutOfMemoryException))
         {
             throw;
         }
     }
     return _encoding;
 }

        private static string ExtractJsonResponse(WebResponse response)
        {
            GetRateLimits(response);

            var responseStream = response.GetResponseStream();
            if (responseStream == null)
            {
                throw new StackExchangeException("Response stream is empty, unable to continue");
            }

            string json;
            using (var outStream = new MemoryStream())
            {
                using (var zipStream = new GZipStream(responseStream, CompressionMode.Decompress))
                {
                    zipStream.CopyTo(outStream);
                    outStream.Seek(0, SeekOrigin.Begin);
                    using (var reader = new StreamReader(outStream, Encoding.UTF8))
                    {
                        json = reader.ReadToEnd();
                    }
                }
            }

            return json;
        }

		private Action<HttpWebRequest> HandleUnauthorizedResponse(RavenConnectionStringOptions options, WebResponse webResponse)
		{
			if (options.ApiKey == null)
				return null;

			var oauthSource = webResponse.Headers["OAuth-Source"];

			var useBasicAuthenticator =
				string.IsNullOrEmpty(oauthSource) == false &&
				oauthSource.EndsWith("/OAuth/API-Key", StringComparison.CurrentCultureIgnoreCase) == false;

			if (string.IsNullOrEmpty(oauthSource))
				oauthSource = options.Url + "/OAuth/API-Key";

			var authenticator = authenticators.GetOrAdd(
				GetCacheKey(options),
				_ =>
				{
					if (useBasicAuthenticator)
					{
						return new BasicAuthenticator(enableBasicAuthenticationOverUnsecuredHttp: false);
					}

					return new SecuredAuthenticator();
				});

			return authenticator.DoOAuthRequest(oauthSource, options.ApiKey);
		}