.NET：如何应对边界异常？

背景

为什么语言引入了异常

一直没有思考过这个问题，但是异常确实让我的编程生活更快乐，今天早上似乎找到了这个问题的答案：exception之于call stack就像break和continue之于while或for、就像return之于method，总结为一句话：异常只是一种返回机制。

为什么异常让程序更简洁

代码里只有正常的处理逻辑。

        /// <summary>
        /// 创建。
        /// </summary>
        public ActionResult Create(TAggregateRoot item)
        {
            this.CurrentCommandService.Execute(new TCreateCommand
            {
                Aggregate = item
            });

            return this.NewtonsoftJson(new
            {
                success = true,
                items = this.GetById(item.Id)
            });
        }

        /// <summary>
        /// 修改。
        /// </summary>
        public ActionResult Update(TAggregateRoot item)
        {
            this.CurrentCommandService.Execute(new TUpdateCommand
            {
                Aggregate = item
            });

            return this.NewtonsoftJson(new
            {
                success = true,
                items = this.GetById(item.Id)
            });
        }

我的程序代码基本上也是CQRS的，凡是以写为目的的，都是用void进行声明。

异常的处理

异常有五种处理思路，如下图所示：

关于这五种处理思路的概要介绍可以参考这篇文章：http://www.cnblogs.com/happyframework/archive/2013/04/09/3010082.html。

今天的主要目的是介绍“边界异常处理”。

边界异常处理

当异常到达边界，毫无疑问我们必须进行处理。总体来说，到达边界的异常分为两大类：我们有意抛出的异常和未处理异常，针对这两种异常我们需要不同的处理思路，如：

1. 有意抛出的异常：不希望写入日志，希望显示到UI。
2. 未处理的异常：希望写入日志，不希望直接显示到UI，希望定制这种异常的显示信息。

一个简单的边界异常处理框架

结构

下图的友好异常就是我们有意抛出的异常或我们能意识到的异常。

几个核心类型

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

namespace Happy.Web.Mvc.ExceptionHanding
{
    /// <summary>
    /// 异常信息提供者接口，如果你希望为异常返回更多的信息，可以实现该接口。
    /// </summary>
    public interface IExceptionInformationProvider
    {
        /// <summary>
        /// 创建信息。
        /// </summary>
        object CreateInformation(Exception exception);
    }
}

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

            this.LogException(exception);

            filterContext.Result = ExceptionInformationProviderRegistry.CreateErrorResult(exception);

            filterContext.ExceptionHandled = true;
        }

        private void LogException(Exception exception)
        {
            if (FriendlyExceptionRegistry.Contains(exception.GetType()))
            {
                return;
            }

            LogManager.GetCurrentClassLogger().Error(exception);
        }
    }
}

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

using Happy.ExtensionMethod;
using Happy.DesignByContract;
using Happy.Web.Mvc.Newtonsoft;

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

        static ExceptionInformationProviderRegistry()
        {
            Register<OptimisticConcurrencyException>(new Internal.OptimisticConcurrencyExceptionInformationProvider());
        }

        /// <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;
        }

        internal static ActionResult CreateErrorResult(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;
                }
            }

            return new NewtonsoftJsonResult
            {
                Data = information
            };
        }

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

为乐观并发异常自定义返回消息

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

using Happy.Web.Mvc.Newtonsoft;

namespace Happy.Web.Mvc.ExceptionHanding.Internal
{
    internal sealed class OptimisticConcurrencyExceptionInformationProvider : ExceptionInformationProvider<OptimisticConcurrencyException>
    {
        protected override object CreateResult(OptimisticConcurrencyException exception)
        {
            return new
            {
                message = Messages.Error_OptimisticConcurrencyExceptionMessage
            };
        }
    }
}

备注

像微软的异常处理框架都是一个非常好的东西。

合理的利用和使用异常会让程序的结构更加简洁，这些概念只有真正使用了才能深刻的明白。