.NET：可扩展的单据编号生成器 之 顺序号（防止重复）

背景

我在上篇文章“.NET：可扩展的单据编号生成器 + 简单的解释器”中介绍了一个简单的单据编号框架。有朋友留言问如何实现“顺序号，且不能重复”，本篇文章就针对这个问题用上篇介绍的框架进行实现。

思路

顺序号 = 上次顺序号 + 步长

根据上面的公式，问题可以化解为：如何获取上次顺序号？获取上次顺序号有两种方式：

1. 1. 扫描单据表，找出最新的一条记录。
   2. 引入种子表，种子表记录了最新的顺序号。

因为生成的顺序号不能重复，这里就有了并发的要求，为了最大限度的提高并发性，我选择2（引入种子表）。

并发处理可以选择：悲观锁或乐观锁，这里为了简单，我选择悲观锁。

实现

代码下载：http://yunpan.cn/Q5KMUTA3qGPct。

种子表设计

CREATE TABLE [dbo].[CodeSeeds] (
    [Id]    UNIQUEIDENTIFIER NOT NULL,
    [Key]   NVARCHAR (500)   NOT NULL,
    [Value] INT              NOT NULL,
    PRIMARY KEY CLUSTERED ([Id] ASC)
);

SeedCodeRuleProvider.cs

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

using System.Transactions;
using System.Text.RegularExpressions;
using System.Data.Entity.Infrastructure;

namespace EntityCodeRuleDemo
{
    public class SeedCodeRuleProvider : ICodeRuleProvider
    {
        private readonly int _width;

        public SeedCodeRuleProvider(int width)
        {
            _width = width;
        }

        public string Generate(object entity)
        {
            return GetSeedValue(entity).ToString().PadLeft(_width, '0');
        }

        protected virtual string GetKey(object entity)
        {
            return entity.GetType().FullName;
        }

        private int GetSeedValue(object entity)
        {
            try
            {
                var value = 0;
                var key = this.GetKey(entity);

                using (var ts = new TransactionScope(TransactionScopeOption.RequiresNew,
                    new TransactionOptions { IsolationLevel = IsolationLevel.RepeatableRead }))
                {
                    using (var context = new TestContext())
                    {
                        var seed = context.CodeSeeds.Where(x => x.Key == key).FirstOrDefault();
                        if (seed == null)
                        {
                            seed = new CodeSeed { Id = Guid.NewGuid(), Key = key, Value = -1 };
                            context.CodeSeeds.Add(seed);
                        }

                        seed.Value++;
                        value = seed.Value;
                        context.SaveChanges();
                    }

                    ts.Complete();
                }

                return value;
            }
            catch (DbUpdateException)
            {
                return this.GetSeedValue(entity);
            }
        }

        public static SeedCodeRuleProvider SeedCodeRuleProviderFactory(string literal)
        {
            var match = new Regex("^<种子(:(?<宽度>.*?))?>$").Match(literal);

            var width = match.Groups["宽度"].Value;

            return new SeedCodeRuleProvider(string.IsNullOrEmpty(width) ? 5 : int.Parse(width));
        }
    }
}

Program.cs

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

using System.Text.RegularExpressions;

namespace EntityCodeRuleDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            CodeRuleInterpreter.RegistProviderFactory(new Regex("^<种子(:(?<宽度>.*?))?>$"), SeedCodeRuleProvider.SeedCodeRuleProviderFactory);

            var employeeCode = CodeRuleInterpreter
                .Interpret("前缀_<日期:yyyy_MM_dd>_<属性:NamePinYin>_<种子:6>")
                .Generate(new Employee { NamePinYin = "DUANGW" });

            Console.WriteLine(employeeCode);
        }
    }
}

运行结果

备注

有写业务要求会强制编号的连续性或编号的随机性，对于这两种需求，还需要单独开发Provider，有机会再写文章介绍了。