Beispiel #1
0
        /// <summary>
        /// Performs the HTTP request.
        /// </summary>
        /// <returns>The server response string(UTF8 decoded).</returns>
        public virtual string Request()
        {
            HttpWebRequest req = HttpWebRequest.Create(ConstructUri()) as HttpWebRequest;

            AppendHeaders(req.Headers);

            if (!string.IsNullOrEmpty(Method))
            {
                req.Method = Method;
            }

            if (!string.IsNullOrEmpty(ContentType))
            {
                req.ContentType = ContentType;
            }

            PrepareRequest(req);

            // Calls GetRequestStream with a "GET" method, an exception is thrown "Cannot send a content-body with this verb-type."
            if (req.Method == HttpMethod.Post)
            {
                using (var reqStream = req.GetRequestStream())
                {
                    WriteBody(reqStream);
                }

                // ContentLength is automatically calculated.
            }

            WebResponse resp = null;
            try
            {
                resp = req.GetResponse();
            }
            catch (WebException wex)
            {
                ErrorResponse errorResp;
                var webResp = wex.Response as HttpWebResponse;
                if (null == webResp)
                    throw new AMicroblogException(LocalErrorCode.NetworkUnavailable);

                try
                {
                    var responseContent = RetrieveResponse(webResp);

                    if (!string.IsNullOrEmpty(responseContent) && responseContent.StartsWith(Constants.XmlHeader, StringComparison.InvariantCultureIgnoreCase))
                    {
                        errorResp = XmlSerializationHelper.XmlToObject<ErrorResponse>(responseContent);
                        // Retrieves the error code and wraps the exception.
                        var errorCode = AMicroblogException.RetrieveErrorCode(errorResp.ErrorMessage);
                        if (!string.IsNullOrEmpty(errorCode))
                            errorResp.ErrorCode = int.Parse(errorCode);
                    }
                    else
                    {
                        // Handle other cases
                        errorResp = new ErrorResponse() { ErrorCode = (int)webResp.StatusCode, ErrorMessage = webResp.StatusDescription };
                    }
                }
                catch (Exception exx)
                {
                    throw new AMicroblogException(LocalErrorCode.ProcessResponseErrorHandlingFailed, exx);
                }

                var aex = new AMicroblogException(errorResp.ErrorMessage, wex) { IsRemoteError = true, ErrorCode = errorResp.ErrorCode };

                var e = new ResponseErrorEventArgs(req.RequestUri.AbsoluteUri, aex, req.Method, req.ContentType);
                Environment.NotifyResponseError(e);

                aex.IsHandled = e.IsHandled;

                throw aex;
            }

            return RetrieveResponse(resp);
        }
Beispiel #2
0
 /// <summary>
 /// Handles the response error event.
 /// </summary>
 private static void HandleResponseError(object sender, ResponseErrorEventArgs e)
 {
     foreach (var handler in ResponseErrorHandlers)
     {
         try
         {
             var errorCode = e.ErrorData.ErrorCode.ToString();
             if (handler.ErrorCode == "*" || errorCode == handler.ErrorCode || Regex.IsMatch(errorCode, handler.ErrorCode, RegexOptions.IgnoreCase))
             {
                 var realHandler = Activator.CreateInstance(handler.Type) as IResponseErrorHandler;
                 realHandler.Handle(e.ErrorData);
                 e.IsHandled = true;
             }
         }
         catch
         {
             // Nothing to do.
         }
     }
 }
        /*
        // Sample code of calling a AMicroblog API
        public void Post(string status)
        {
        try
        {
        var updStatusInfo = new UpdateStatusInfo();
        updStatusInfo.Status = status;

        var statusInfo = AMicroblog.PostStatus(updStatusInfo);

        // Further post-process against statusInfo...
        }
        catch (AMicroblogException aex)
        {
        // Handles the exception only if the exception is not handled by Unified Response Error Handling mechanism.
        if (!aex.IsHandled)
        {
            if (aex.IsRemoteError)
            {
                ShowErrorMessage("Server returned an error: {0}", aex.Message);

                // You can customize the error message based on aex.RemoteErrorCode.
            }
            else
                ShowErrorMessage("Unexpected error occured: {0}", aex.Message);
        }
        }
        catch (Exception ex)
        {
        ShowErrorMessage("Unexpected error occured: {0}", ex.Message);
        }
        }
        */
        private void Environment_ResponseError(object sender, ResponseErrorEventArgs e)
        {
            Console.WriteLine("An error response for {0}: {1}", e.ErrorData.RequestUri, e.ErrorData.Exception.Message);
        }
Beispiel #4
0
 /// <summary>
 /// Triggers the <see cref="ResponseError"/>.
 /// </summary>
 /// <remarks>To insure that each event handler has a chance to process the event, any exception is suspended.</remarks>
 internal static void NotifyResponseError(ResponseErrorEventArgs e)
 {
     if (null != ResponseError)
     {
         var invocationList = ResponseError.GetInvocationList();
         foreach (var invocation in invocationList)
         {
             try
             {
                 var inv = invocation as EventHandler<ResponseErrorEventArgs>;
                 inv(null, e);
             }
             catch { }
         }
     }
 }