幸福框架：在应用层实现触发器

背景

企业应用开发过程中经常面对一些非功能型需求，如：自动收集和设置审计信息、索引和关系约束，有些非功能需求当然可以用数据库自带的功能，如索引约束，但是应用层视乎也有必要重复一次，因为当违背这种约束的时候我们希望提示给用户友好的信息，如：‘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();
        }
    }
}

运行效果

备注

这种触发器我在项目中有用过，虽然有所不足，如批量操作性能不高，但是在很多场景下，也减少了不少的重复代码。