/// <summary> /// Fires an instrumentation event. /// </summary> /// <param name="name">The name of the exception policy.</param> /// <param name="e">The caught exception.</param> protected override void PublishFailureEvent(string name, Exception e) { string message = CreateProviderNotFoundExceptionMessage(currentException, name); ExceptionHandlingConfigFailureEvent.Fire(message); ExceptionUtility.LogHandlingException(name, e, null, currentException); }
/// <summary> /// <para>Publish an instrumentation event that indicates there was an error while attempting to create a provider.</para> /// </summary> /// <param name="configurationName"><para>The name of the configuration object.</para></param> /// <param name="e"><para>The <see cref="Exception"/> to publish.</para></param> protected override void PublishFailureEvent(string configurationName, Exception e) { Exception wrappedException = new ExceptionHandlingException(SR.UnableToLoadExceptionHandlers(configurationName, this.policyName), e); ExceptionUtility.LogHandlingException(this.policyName, wrappedException, null, e); throw new ExceptionHandlingException(SR.UnableToLoadExceptionHandlers(configurationName, this.policyName)); }
private Exception ExecuteHandlerChain(Exception ex, Guid handlingInstanceID) { string lastHandlerName = String.Empty; Exception originalException = ex; try { IExceptionHandler[] handlers = this.factory.CreateExceptionHandlers(policyName, typeDataName); for (int i = 0; i < handlers.Length; i++) { lastHandlerName = handlers[i].GetType().Name; ex = handlers[i].HandleException(ex, policyName, handlingInstanceID); } } catch (Exception handlingException) { ExceptionUtility.LogHandlingException( policyName, new ExceptionHandlingException(SR.UnableToHandleException(lastHandlerName), handlingException), ex, originalException ); throw new ExceptionHandlingException(SR.UnableToHandleException(lastHandlerName)); } return(ex); }
private Type GetExceptionType(ExceptionTypeData typeData, string policyName) { try { return(Type.GetType(typeData.TypeName, true)); } catch (TypeLoadException e) { ExceptionUtility.LogHandlingException(policyName, null, null, e); ExceptionNotHandledEvent.Fire(); throw new ExceptionHandlingException(SR.ExceptionUnknownExceptionTypeInConfiguration(typeData.TypeName), e); } }
/// <devdoc> /// Rethrows the given exception. Placed in a seperate method for /// easier viewing in the stack trace. /// </devdoc> private void IntentionalRethrow(Exception chainException, Exception originalException) { if (chainException != null) { ExceptionHandledEvent.Fire(); throw chainException; } else { Exception wrappedException = new ExceptionHandlingException(SR.ExceptionNullException); ExceptionUtility.LogHandlingException(policyName, wrappedException, chainException, originalException); throw wrappedException; } }
private static ExceptionPolicy GetExceptionPolicy(Exception exception, string policyName, ConfigurationContext configurationContext) { try { ExceptionPolicyFactory factory = new ExceptionPolicyFactory(configurationContext); return(factory.CreateExceptionPolicy(policyName, exception)); } catch (ConfigurationException ex) { ExceptionUtility.LogHandlingException(policyName, ex, null, exception); ExceptionNotHandledEvent.Fire(); throw new ExceptionHandlingException(ex.Message, ex); } catch (InvalidOperationException ex) { ExceptionUtility.LogHandlingException(policyName, ex, null, exception); ExceptionNotHandledEvent.Fire(); throw new ExceptionHandlingException(ex.Message, ex); } }