.NET：异常处理的两条“黄金定律”，求批！

背景

架构之处必须考虑：如何处理异常？如何定义自己的异常体系？本文为了强化这个概念而写。

异常处理的两条“黄金定律”

自己抄袭的两条规律：

1. 异常不能穿过“边界类”。
2. 异常不能在没有恢复的情况下“吞掉”。

我们会将异常分为两类：“需要恢复”和“不需要恢复”，“需要恢复”的异常如果到达了边界类，就说明系统有BUG了，这类异常需要记录到日志。“不需要恢复”的异常需要进一步分为：“我们不能恢复”和“我们不期望恢复”，如果这类异常到达边界类，“我们不能恢复“的异常同样需要记录到日志，“我们不期望恢复”的异常则直接将异常信息显示给界面。一般采用AOP处理边界异常。

示例

AOP

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Web.Mvc;

using Common.Logging;
using Happy.ExceptionHanding;
using Happy.Web.Mvc.Newtonsoft;

namespace Happy.Web.Mvc.ExceptionHanding
{
    /// <summary>
    /// 处理应用程序未捕获的异常。
    /// </summary>
    [AttributeUsage(AttributeTargets.Class, AllowMultiple = false, Inherited = true)]
    public class WriteExceptionResultAttribute : FilterAttribute, IExceptionFilter
    {
        /// <inheritdoc />
        public void OnException(ExceptionContext filterContext)
        {
            var exception = filterContext.Exception;
            if (!FriendlyExceptionRegistry.IsFriendly(exception.GetType()))
            {
                LogManager.GetCurrentClassLogger().Error(exception);
            }
            filterContext.Result = CreateErrorResult(exception);
            filterContext.ExceptionHandled = true;
        }

        private static ActionResult CreateErrorResult(Exception exception)
        {
            var information = ExceptionInformationProviderRegistry.CreateInformation(exception);

            return new NewtonsoftJsonResult
            {
                Data = information
            };
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

using Happy.ExtentionMethods;

namespace Happy.ExceptionHanding
{
    /// <summary>
    /// 异常信息提供者注册处。
    /// </summary>
    public static class ExceptionInformationProviderRegistry
    {
        private static readonly Dictionary<Type, IExceptionInformationProvider> _providers
            = new Dictionary<Type, IExceptionInformationProvider>();

        /// <summary>
        /// 注册提供者。
        /// </summary>
        public static void Register<TException>(IExceptionInformationProvider provider)
            where TException : Exception
        {
            Register(typeof(TException), provider);
        }

        /// <summary>
        /// 注册提供者。
        /// </summary>
        public static void Register(Type exceptionType, IExceptionInformationProvider provider)
        {
            exceptionType.MustNotNull("exceptionType");
            provider.MustNotNull("provider");

            _providers[exceptionType] = provider;
        }

        public static Dictionary<string, object> CreateInformation(Exception exception)
        {
            exception.MustNotNull("exception");

            var exceptionType = exception.GetType();

            var information = CreateDefaultInformation(exception);

            if (_providers.ContainsKey(exceptionType))
            {
                var extInformation = _providers[exceptionType].CreateInformation(exception);

                foreach (var item in extInformation.ToDictionary())
                {
                    information[item.Key] = item.Value;
                }
            }
            else
            {
                if (FriendlyExceptionRegistry.IsFriendly(exception.GetType()))
                {
                    information["exception"] = Resource.Messages.Msg_DefaultExceptionMessage;
                }
            }

            return information;
        }

        private static Dictionary<string, object> CreateDefaultInformation(Exception exception)
        {
            return new Dictionary<string, object> 
            { 
                { "success", false },
                { "exception", exception.GetType().Name },
                { "message",exception.Message }
            };
        }
    }
}

备注

放弃继续玩 GO 的一个原因就是：GO 的异常处理太不爽了，或者是我自己的原因，不够 OPEN。