C# Exception.FindInnerException方法代码示例

        protected override bool CheckIsTransient(Exception ex)
        {
            bool returnValue = false;

            try
            {
                var dataServiceException = ex.FindInnerException<DataServiceRequestException>();

                if ((dataServiceException != null) && (dataServiceException.Response != null))
                {
                    if (dataServiceException.Response.IsBatchResponse)
                    {
                        returnValue = CommonRetryableWebExceptions.Any(s => (int)s == dataServiceException.Response.BatchStatusCode);
                    }
                    else
                    {
                        // If this isn't a batch response we have to check the StatusCode on the Response object itself
                        var responses = dataServiceException.Response.ToList();

                        if (responses.Count == 1)
                        {
                            returnValue = CommonRetryableWebExceptions.Any(s => (int)s == responses[0].StatusCode);
                        }
                    }
                }
            }
            catch (Exception)
            {
                // we don't want to hide the original exception with any errors we might generate here
                // so just swallow the exception and don't retry
                returnValue = false;
            }

            return returnValue;
        }

        protected override bool CheckIsTransient(Exception ex)
        {
            var webException = ex.FindInnerException<WebException>();

            if (webException != null &&
                CommonRetryableWebExceptions.Contains(webException.Status))
            {
                return true;
            }

            if (ex.FindInnerException<TimeoutException>() != null)
            {
                return true;
            }

            return false;
        }

        protected override bool CheckIsTransient(Exception ex)
        {
            var dataServiceException = ex.FindInnerException<DataServiceQueryException>();

            if (dataServiceException == null)
            {
                return false;
            }

            return CommonRetryableWebExceptions.Any(s => dataServiceException.Response != null && (int)s == dataServiceException.Response.StatusCode);
        }

        protected override bool CheckIsTransient(Exception ex)
        {
            var dataServiceException = ex.FindInnerException<DataServiceRequestException>();

            if (dataServiceException == null)
            {
                return false;
            }

            if (dataServiceException.Response.IsBatchResponse &&
                CommonRetryableWebExceptions.Any(s => (int)s == dataServiceException.Response.BatchStatusCode))
            {
                return true;
            }
            var responses = dataServiceException.Response.ToList();

            //If we have responses with retryable status codes we should retry
            return responses.Any(r => CommonRetryableWebExceptions.Any(s => (int)s == r.StatusCode));
        }

        protected override bool CheckIsTransient(Exception ex)
        {
            if (IsRetriableWebException(ex, operationIdempotentOnRetry: true, retryOnUnauthorizedErrors: true))
            {
                return true;
            }

            DataServiceRequestException dataServiceException = ex as DataServiceRequestException;

            if (dataServiceException != null)
            {
                if (IsErrorStringMatch(GetErrorCode(dataServiceException), StorageErrorCodeStrings.InternalError, StorageErrorCodeStrings.ServerBusy, StorageErrorCodeStrings.OperationTimedOut, TableErrorCodeStrings.TableServerOutOfMemory))
                {
                    return true;
                }
            }

            DataServiceQueryException dataServiceQueryException = ex as DataServiceQueryException;

            if (dataServiceQueryException != null)
            {
                if (IsErrorStringMatch(GetErrorCode(dataServiceQueryException), StorageErrorCodeStrings.InternalError, StorageErrorCodeStrings.ServerBusy, StorageErrorCodeStrings.OperationTimedOut, TableErrorCodeStrings.TableServerOutOfMemory))
                {
                    return true;
                }
            }

            DataServiceClientException dataServiceClientException = ex.FindInnerException<DataServiceClientException>();

            if (dataServiceClientException != null)
            {
                if (IsRetriableHttpStatusCode(dataServiceClientException.StatusCode, operationIdempotentOnRetry:true, retryOnUnauthorizedErrors:true))
                {
                    return true;
                }

                if (IsErrorStringMatch(dataServiceClientException.Message, StorageErrorCodeStrings.InternalError, StorageErrorCodeStrings.ServerBusy, StorageErrorCodeStrings.OperationTimedOut, TableErrorCodeStrings.TableServerOutOfMemory))
                {
                    return true;
                }
            }

            var serverException = ex as StorageException;

            if (serverException != null)
            {
                if (IsErrorStringMatch(serverException, StorageErrorCodeStrings.InternalError, StorageErrorCodeStrings.ServerBusy, StorageErrorCodeStrings.OperationTimedOut, TableErrorCodeStrings.TableServerOutOfMemory))
                {
                    return true;
                }
            }

            if (IsTimeoutException(ex))
            {
                return true;
            }

            if (IsSocketException(ex))
            {
                return true;
            }

            if ((ex.FindInnerException<IOException>() != null) && !(ex is FileLoadException))
            {
                return true;
            }

            return false;
        }

        protected bool IsRetriableDataServiceException(Exception ex, bool operationIdempotentOnRetry, bool retryOnUnauthorizedErrors)
        {
            try
            {
                var transportException = ex.FindInnerException<DataServiceTransportException>();

                if (transportException != null)
                {
                    if (transportException.Response == null)
                    {
                        // If we don't have a response object to look at then we don't really know what happened on the server.
                        // Thus if the operation is Idempotent, we will go ahead and retry because even if the first operation
                        // succeeded on the server redoing the operation won't change the final result.  If the operation is
                        // not idempotent, we won't retry since we don't have any details on the error.
                        return operationIdempotentOnRetry;
                    }
                    else if (IsRetriableHttpStatusCode(transportException.Response.StatusCode, operationIdempotentOnRetry, retryOnUnauthorizedErrors))
                    {
                        return true;
                    }
                }

                var requestException = ex.FindInnerException<DataServiceRequestException>();

                if (requestException != null)
                {
                    if (requestException.Response == null)
                    {
                        // If we don't have a response object to look at then we don't really know what happened on the server.
                        // Thus if the operation is Idempotent, we will go ahead and retry because even if the first operation
                        // succeeded on the server redoing the operation won't change the final result.  If the operation is
                        // not idempotent, we won't retry since we don't have any details on the error.
                        return operationIdempotentOnRetry;
                    }
                    else if (requestException.Response.IsBatchResponse)
                    {
                        if (IsRetriableHttpStatusCode(requestException.Response.BatchStatusCode, operationIdempotentOnRetry, retryOnUnauthorizedErrors))
                        {
                            return true;
                        }
                    }
                    else
                    {
                        // If this isn't a batch response we have to check the StatusCode on the Response object itself
                        var responses = requestException.Response.ToList();

                        if ((responses.Count == 1) && IsRetriableHttpStatusCode(responses[0].StatusCode, operationIdempotentOnRetry, retryOnUnauthorizedErrors))
                        {
                            return true;
                        }
                    }
                }

                var queryException = ex.FindInnerException<DataServiceQueryException>();

                if (queryException != null)
                {
                    if (queryException.Response == null)
                    {
                        // If we don't have a response object to look at then we don't really know what happened on the server.
                        // Thus if the operation is Idempotent, we will go ahead and retry because even if the first operation
                        // succeeded on the server redoing the operation won't change the final result.  If the operation is
                        // not idempotent, we won't retry since we don't have any details on the error.
                        return operationIdempotentOnRetry;
                    }
                    else if (IsRetriableHttpStatusCode(queryException.Response.StatusCode, operationIdempotentOnRetry, retryOnUnauthorizedErrors))
                    {
                        return true;
                    }
                }

                var clientException = ex.FindInnerException<DataServiceClientException>();

                if (clientException != null)
                {
                    if (IsRetriableHttpStatusCode(clientException.StatusCode, operationIdempotentOnRetry, retryOnUnauthorizedErrors))
                    {
                        return true;
                    }
                }
            }
            catch (Exception)
            {
                // do nothing, just return false below
            }

            return false;
        }

 protected bool IsTimeoutException(Exception ex)
 {
     return (ex is TimeoutException || (ex.FindInnerException<TimeoutException>() != null));
 }

 protected bool IsSocketException(Exception ex)
 {
     return (ex is SocketException || (ex.FindInnerException<SocketException>() != null));
 }

        protected bool IsRetriableWebException(Exception ex, bool operationIdempotentOnRetry, bool retryOnUnauthorizedErrors)
        {
            try
            {
                var webException = ex.FindInnerException<WebException>();

                if (webException != null)
                {
                    if (CommonRetryableWebExceptions.Contains(webException.Status))
                    {
                        return true;
                    }
                    else if (webException.Status == WebExceptionStatus.ProtocolError)
                    {
                        // The response received from the server was complete but indicated a protocol-level error.
                        // Decide if the HTTP protocol error is retriable or not.
                        var response = webException.Response as HttpWebResponse;

                        if (response == null || IsRetriableHttpStatusCode(response.StatusCode, operationIdempotentOnRetry, retryOnUnauthorizedErrors))
                        {
                            return true;
                        }
                    }
                    else if (operationIdempotentOnRetry)
                    {
                        if (RetryableWebExceptionsForIdempotentOperations.Contains(webException.Status))
                        {
                            return true;
                        }
                    }
                }
            }
            catch(Exception)
            {
                // do nothing, just return false below
            }

            return false;
        }

 protected bool IsIOException(Exception ex)
 {
     return (ex is IOException || (ex.FindInnerException<IOException>() != null));
 }