/// <summary> /// Formats and handles an exception. /// </summary> /// <param name="ex">The <see cref="ApplicationModelException"/> to handle.</param> /// <param name="isExtended">TRUE if the message should be in extended format, FALSE otherwise.</param> /// <returns>A string message that can be send to client applications.</returns> public static string FormatServiceException(ApplicationModelException ex, bool isExtended) { if (isExtended) { return(string.Format(ExceptionHandler.EXCEPTION_FORMAT_EXTENDED, ex.GetType().Name.Humanize(), Enum.Format(typeof(ExceptionNumber), ex.Number, "x"), ex.Number, ex.ID, ex.Message)); } else { return(string.Format(ExceptionHandler.EXCEPTION_FORMAT, ex.GetType().Name.Humanize(), Enum.Format(typeof(ExceptionNumber), ex.Number, "x"), ex.ID)); } }
/// <summary> /// Handles an exception and wraps it into an <see cref="ApplicationModelException"/> of type T as needed. /// </summary> /// <typeparam name="T">The type of <see cref="ApplicationModelException"/> to wrap the original exception into.</typeparam> /// <param name="number">The excpttion number.</param> /// <param name="ex">The exception.</param> /// <param name="policyName">The name of the exception policy to apply.</param> /// <returns>An <see cref="ApplicationModelException"/> of type T.</returns> public static T HandleException <T>(long number, Exception ex, string policyName) where T : ApplicationModelException { ex.CatchNullArgument("ex"); policyName.CatchNullOrEmptyArgument("policyName"); bool shouldWrap = false; T outerException = default(T); // First handle the execption by // - logging it to the exception log // - if ex is of type ExceptionWrapper also set the IsUnhandled flag to FALSE // - if ex is NOT of type ExceptionWrapper then just log the exception if (ex is ApplicationModelException) { ApplicationModelException wrapperException = (ApplicationModelException)ex; if (wrapperException.IsUnhandled) { // Write to exception log Logger.Write(ex, policyName, TraceLevel.Error); // Ok ... this is handled wrapperException.IsUnhandled = false; } shouldWrap = typeof(T) != wrapperException.GetType(); if (!shouldWrap) { outerException = (T)wrapperException; } } else { // Write to exception log Logger.Write(ex, policyName, TraceLevel.Error); // Only wrap if we have a different type of exception shouldWrap = typeof(T) != typeof(Exception); } if (shouldWrap) { // Create an instance of the requested ExceptionWrapper subtype outerException = (T)Activator.CreateInstance(typeof(T), new object[] { number, ex.Message, ex }); // If it is a ExceptionWrapper type also set the IsUnhandled flag to FALSE if (outerException is ApplicationModelException) { (outerException as ApplicationModelException).IsUnhandled = false; } } return(outerException); }