.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。