.NET：可擴展的單據編號生成器 之 基於緩沖區的順序號

背景

我在上篇文章“.NET：可擴展的單據編號生成器 之 順序號（防止重復）”中介紹了如何使用“種子表”和“悲觀鎖”解決順序號的問題。昨天找朋友討論，說這種速度不夠高，今天就稍微改進一下，引入一個內存緩沖區，提高生成的速度。

思路

引入內存緩沖區后，順序號的生產流程變為：在內存中維護一個順序號區間，在這個區間內，就直接查內存，否則更新種子表並重新更新內存區間。還是直接看代碼吧。

實現

代碼下載：http://yunpan.cn/Q5jj5yedRAtk5。

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 static readonly int _OnceBufferSize = 10000;
        private static readonly Dictionary<string, BufferSeed> _Buffer = new Dictionary<string, BufferSeed>();

        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)
        {
            var key = this.GetKey(entity);

            lock (_Buffer)
            {
                if (!_Buffer.ContainsKey(key))
                {
                    this.SetBufferSeed(entity, key);
                }
            }

            lock (_Buffer[key])
            {
                if (_Buffer[key].IsOverflow())
                {
                    this.SetBufferSeed(entity, key);
                }

                _Buffer[key].CurrentValue++;

                return _Buffer[key].CurrentValue;
            }
        }

        private void SetBufferSeed(object entity, string key)
        {
            var value = this.GetOrSetSeedValueFormDatabase(entity);

            _Buffer[key] = new BufferSeed
            {
                CurrentValue = value - _OnceBufferSize,
                MaxValue = value
            };
        }

        private int GetOrSetSeedValueFormDatabase(object entity)
        {
            var key = this.GetKey(entity);

            try
            {
                using (var ts = new TransactionScope(TransactionScopeOption.RequiresNew,
                    new TransactionOptions { IsolationLevel = IsolationLevel.RepeatableRead }))
                {
                    var value = 0;

                    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 += _OnceBufferSize;
                        context.SaveChanges();

                        value = seed.Value;
                    }

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

        private class BufferSeed
        {
            public int CurrentValue { get; set; }

            public int MaxValue { get; set; }

            public bool IsOverflow()
            {
                return this.CurrentValue >= this.MaxValue;
            }
        }
    }
}

Program.cs

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

using System.Diagnostics;
using System.Text.RegularExpressions;

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

            var generator = CodeRuleInterpreter
                .Interpret("前綴_<日期:yyyy_MM_dd>_<屬性:NamePinYin>_<種子:6>");

            var watch = Stopwatch.StartNew();

            for (var i = 0; i < 10000; i++)
            {
                generator.Generate(new Employee { NamePinYin = "DUANGW" });
            }

            watch.Stop();

            Console.WriteLine("1萬條編號用時：" + watch.Elapsed);
        }
    }
}

執行結果

備注

 優化前后，速度相差幾百倍。