幸福框架：在應用層實現觸發器

背景

企業應用開發過程中經常面對一些非功能型需求，如：自動收集和設置審計信息、索引和關系約束，有些非功能需求當然可以用數據庫自帶的功能，如索引約束，但是應用層視乎也有必要重復一次，因為當違背這種約束的時候我們希望提示給用戶友好的信息，如：‘xxx已經存在，xxx必須唯一’，這篇文章我就介紹一個簡單的方案應對這種需求。

思路

我覺得數據庫的觸發器是個好東西，應用層完全可以借用一下，我還認為如果我在應用層實現了觸發器，像一些前置條件和后置條件驗證也可以用觸發器實現（這塊我不是很清楚設計的是否合理，還是要引入另外一個繼承體系）。

實現

核心類

核心代碼

DefaultTriggerService.cs

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

using Microsoft.Practices.ServiceLocation;

using Happy.Domain;

namespace Happy.Application.Trigger.Internal
{
    internal sealed class DefaultTriggerService : ITriggerService
    {
        public void ExecuteBeforeInsert<TAggregateRoot>(TAggregateRoot aggregate)
            where TAggregateRoot : AggregateRoot
        {
            var triggers = ServiceLocator
                .Current
                .GetAllInstances<ICreateTrigger<TAggregateRoot>>();

            foreach (var trigger in triggers)
            {
                trigger.BeforeInsert(aggregate);
            }
        }

        public void ExecuteAfterInsert<TAggregateRoot>(TAggregateRoot aggregate)
            where TAggregateRoot : AggregateRoot
        {
            var triggers = ServiceLocator
                .Current
                .GetAllInstances<ICreateTrigger<TAggregateRoot>>();

            foreach (var trigger in triggers)
            {
                trigger.AfterInsert(aggregate);
            }
        }

        public void ExecuteBeforeUpdate<TAggregateRoot>(TAggregateRoot aggregate)
            where TAggregateRoot : AggregateRoot
        {
            var triggers = ServiceLocator
                .Current
                .GetAllInstances<IUpdateTrigger<TAggregateRoot>>();

            foreach (var trigger in triggers)
            {
                trigger.BeforeUpdate(aggregate);
            }
        }

        public void ExecuteAfterUpdate<TAggregateRoot>(TAggregateRoot aggregate)
            where TAggregateRoot : AggregateRoot
        {
            var triggers = ServiceLocator
                .Current
                .GetAllInstances<IUpdateTrigger<TAggregateRoot>>();

            foreach (var trigger in triggers)
            {
                trigger.AfterUpdate(aggregate);
            }
        }

        public void ExecuteBeforeDelete<TAggregateRoot>(TAggregateRoot aggregate)
            where TAggregateRoot : AggregateRoot
        {
            var triggers = ServiceLocator
                .Current
                .GetAllInstances<IDeleteTrigger<TAggregateRoot>>();

            foreach (var trigger in triggers)
            {
                trigger.BeforeDelete(aggregate);
            }
        }

        public void ExecuteAfterDelete<TAggregateRoot>(TAggregateRoot aggregate)
            where TAggregateRoot : AggregateRoot
        {
            var triggers = ServiceLocator
                .Current
                .GetAllInstances<IDeleteTrigger<TAggregateRoot>>();

            foreach (var trigger in triggers)
            {
                trigger.AfterDelete(aggregate);
            }
        }
    }
}

自動管理樹形節點的路徑信息

代碼

ITreeNode.cs

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

namespace Happy.Domain.Feature
{
    /// <summary>
    /// 樹的節點。
    /// </summary>
    public interface ITreeNode
    {
        /// <summary>
        /// 節點ID。
        /// </summary>
        Guid Id { get; set; }

        /// <summary>
        /// 父節點ID。
        /// </summary>
        Guid ParentId { get; set; }

        /// <summary>
        /// 節點在樹中的路徑，如：/A/B/C/D，包含自己。
        /// </summary>
        string NodePath { get; set; }
    }
}

TreeNodeTrigger.cs

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

using Happy.ExtensionMethod;
using Happy.Domain;
using Happy.Domain.Feature;
using Happy.Application.Trigger;

namespace Happy.EntityFramework.Trigger
{
    public class TreeNodeTrigger<TUnitOfWork, TAgggregateRoot> : TriggerBase<TUnitOfWork, TAgggregateRoot>
        where TUnitOfWork : UnitOfWork
        where TAgggregateRoot : AggregateRoot, ITreeNode
    {
        public override void BeforeInsert(TAgggregateRoot aggregate)
        {
            var parentNodePath = this.GetParentNodePath(aggregate);

            aggregate.NodePath = parentNodePath + "/" + aggregate.Id;
        }

        public override void BeforeUpdate(TAgggregateRoot aggregate)
        {
            var newParentNodePath = this.GetParentNodePath(aggregate);
            var newNodePath = newParentNodePath + "/" + aggregate.Id;
            var oldNodePath = aggregate.NodePath;

            if (oldNodePath == newNodePath)
            {
                return;
            }

            aggregate.NodePath = newNodePath;

            var table = typeof(TAgggregateRoot).Name.ToPluralize();
            var sql = string.Format("UPDATE {0} SET NodePath = REPLACE(NodePath, {{0}}, {{1}}) WHERE NodePath LIKE {{2}}", table);
            this.UnitOfWork.Database.ExecuteSqlCommand(sql, oldNodePath, newNodePath, oldNodePath + "/%");
        }

        public override void BeforeDelete(TAgggregateRoot aggregate)
        {
            var table = typeof(TAgggregateRoot).Name.ToPluralize();
            var sql = string.Format("DELETE FROM {0} WHERE NodePath LIKE {{0}}", table);
            this.UnitOfWork.Database.ExecuteSqlCommand(sql, aggregate.NodePath + "/%");
        }

        private string GetParentNodePath(TAgggregateRoot aggregate)
        {
            var table = typeof(TAgggregateRoot).Name.ToPluralize();
            var sql = string.Format("SELECT NodePath FROM {0} WHERE Id = {{0}}", table);
            return this.UnitOfWork.Database.SqlQuery<string>(sql, aggregate.ParentId).FirstOrDefault();
        }
    }
}

運行效果

備注

這種觸發器我在項目中有用過，雖然有所不足，如批量操作性能不高，但是在很多場景下，也減少了不少的重復代碼。