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

执行结果

备注

优化前后，速度相差几百倍。