private HttpWebRequest PrepareWebRequest(ClientExecutionContext context)
        {
            NameValueCollection addHeaders = null;

            HttpWebRequest client = PrepareWebRequest(context, addHeaders);

            using (var requestStream = client.GetRequestStream())
            {
                Stopwatch serializationWatch = new Stopwatch();
                try
                {
                    serializationWatch.Start();
                    context.CallFormat.StreamSerializer(context.Request, requestStream);
                }
                catch (WebException ex)
                {
                    var webEx = ExceptionFactory.CreateWebException(ex);
                    throw webEx;
                }
                catch (Exception)
                {
                    throw;
                }
                finally
                {
                    serializationWatch.Stop();
                    context.Metrics.SerializationTime = serializationWatch.ElapsedMilliseconds;
                }
            }

            context.Metrics.RequestSize = client.ContentLength;
            return(client);
        }
        private TResponse HandleResponse <TResponse>(ClientExecutionContext context, WebResponse webResponse)
        {
            if (DeserializeResponseUseMemoryStream)
            {
                return(HandleResponseUseMemoryStream <TResponse>(context, webResponse));
            }

            ApplyWebResponseFilters(webResponse);

            TResponse response;

            using (var responseStream = webResponse.GetResponseStream())
            {
                Stopwatch deserializationWatch = new Stopwatch();
                try
                {
                    deserializationWatch.Start();
                    response         = (TResponse)context.CallFormat.StreamDeserializer(typeof(TResponse), responseStream);
                    context.Response = response;
                }
                catch (WebException ex)
                {
                    var webEx = ExceptionFactory.CreateWebException(ex);
                    throw webEx;
                }
                catch (Exception)
                {
                    throw;
                }
                finally
                {
                    deserializationWatch.Stop();
                    context.Metrics.DeserializationTime = deserializationWatch.ElapsedMilliseconds;
                }
            }

            if (!HandleServiceErrorManually)
            {
                CheckResponseFailure(response as IHasResponseStatus);
            }

            return(response);
        }
        private TResponse HandleResponseUseMemoryStream <TResponse>(ClientExecutionContext context, WebResponse webResponse)
        {
            ApplyWebResponseFilters(webResponse);

            TResponse response;

            using (MemoryStream ms = new MemoryStream())
            {
                string responseTypeName = typeof(TResponse).FullName;
                using (var responseStream = webResponse.GetResponseStream())
                {
                    var readStreamTransaction = new CatTransaction("SOA2Client.deserialization.readStream", responseTypeName);
                    try
                    {
                        readStreamTransaction.Start();
                        responseStream.CopyTo(ms);
                        ms.Flush();
                        ms.Seek(0, SeekOrigin.Begin);
                        readStreamTransaction.MarkSuccess();
                    }
                    catch (Exception ex)
                    {
                        readStreamTransaction.MarkFailure(ex);
                        throw;
                    }
                    finally
                    {
                        readStreamTransaction.End();
                    }
                }

                var       deserializeTransaction = new CatTransaction(CatSerializationTypes.ClientDeserializationCall, responseTypeName);
                Stopwatch deserializationWatch   = new Stopwatch();
                try
                {
                    deserializationWatch.Start();
                    deserializeTransaction.Start();
                    response = (TResponse)context.CallFormat.StreamDeserializer(typeof(TResponse), ms);
                    deserializeTransaction.MarkSuccess();
                    context.Response = response;
                }
                catch (WebException ex)
                {
                    var webEx = ExceptionFactory.CreateWebException(ex);
                    deserializeTransaction.MarkFailure(webEx);
                    throw webEx;
                }
                catch (Exception ex)
                {
                    deserializeTransaction.MarkFailure(ex);
                    throw;
                }
                finally
                {
                    deserializeTransaction.End();
                    deserializationWatch.Stop();
                    context.Metrics.DeserializationTime = deserializationWatch.ElapsedMilliseconds;
                }
            }

            if (!HandleServiceErrorManually)
            {
                CheckResponseFailure(response as IHasResponseStatus);
            }

            return(response);
        }
        protected internal WebException HandleWebException(ClientExecutionContext context, WebException webEx)
        {
            using (webEx.Response)
            {
                HttpWebResponse errorResponse = webEx.Response as HttpWebResponse;
                if (errorResponse == null)
                {
                    if (webEx is WebExceptionBase)
                    {
                        return(webEx);
                    }
                    return(ExceptionFactory.CreateWebException(webEx));
                }

                if (webEx.Status == WebExceptionStatus.ProtocolError)
                {
                    string title = string.IsNullOrWhiteSpace(errorResponse.StatusDescription) ? webEx.Message : errorResponse.StatusDescription;

                    WebProtocolException serviceEx = null;
                    if (webEx is WebProtocolException)
                    {
                        serviceEx = (WebProtocolException)webEx;
                    }
                    else
                    {
                        serviceEx = (WebProtocolException)ExceptionFactory.CreateWebException(webEx, title);
                    }

                    try
                    {
                        using (Stream stream = errorResponse.GetResponseStream())
                        {
                            if (errorResponse.ContentType.MatchesContentType(context.ContentType))
                            {
                                var bytes = stream.ReadFully();
                                using (var memoryStream = new MemoryStream(bytes))
                                {
                                    serviceEx.ResponseBody   = bytes.FromUtf8Bytes();
                                    serviceEx.ResponseObject = (GenericErrorResponseType)context.CallFormat.StreamDeserializer(typeof(GenericErrorResponseType), memoryStream);
                                }
                            }
                            else
                            {
                                serviceEx.ResponseBody = stream.ToUtf8String();
                            }
                        }
                    }
                    catch (Exception innerEx)
                    {
                        // Oh, well, we tried
                        return(new WebProtocolException(title, innerEx)
                        {
                            StatusCode = (int)errorResponse.StatusCode,
                            StatusDescription = errorResponse.StatusDescription,
                            ResponseBody = serviceEx.ResponseBody
                        });
                    }

                    //Escape deserialize exception handling and throw here
                    return(serviceEx);
                }

                return(webEx);
            }
        }