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

備注

像微軟的異常處理框架都是一個非常好的東西。

合理的利用和使用異常會讓程序的結構更加簡潔，這些概念只有真正使用了才能深刻的明白。