因为项目中遇到了审核分配的需求，而且可以预见的是后面这种类似的分配需求还会出现，所以就有了这样一个小类库的产生
首先先说明下需求原因：现在有审核人员，有待审核的订单，因为审核人员的奖金跟审核过的订单金额同比挂钩（即审的订单总额越多，奖金越高，也可能跟绩效挂钩），造成审核人员只抢大单，小单子长时间无人审，对外影响恶劣，为了解决这个问题，以及为后续的类似问题提供一个通用的解决方案，故而设计了这么一个小类库
首先对应各部分存在三个接口：
1、待分配的用户集合，该接口定义了用户相关的各种行为，用户是否能进行分配取决于用户是否登入
/// <summary>
/// 自动分配用户
/// </summary>
public interface IAllotUsers<T>
{
/// <summary>
/// 登入
/// </summary>
/// <param name="user"></param>
/// <returns></returns>
bool LoginIn(T user);
/// <summary>
/// 登出
/// </summary>
/// <param name="user"></param>
/// <returns></returns>
bool LoginOut(T user);
/// <summary>
/// 验证是否已登入
/// </summary>
/// <param name="user"></param>
/// <returns></returns>
bool IsLogin(T user);
/// <summary>
/// 获取所有已登入用户
/// </summary>
/// <returns></returns>
IEnumerable<T> GetAllLoginUsers();
} /// <summary>
/// 自动分配项
/// </summary>
public interface IAllotItems<T>
{
/// <summary>
/// 添加可分配项
/// </summary>
/// <param name="item">可分配项</param>
/// <param name="fun">添加规则（影响Get方法的顺序），如果传入null，则默认为第一分配队列，如果超出允许的队列范围，则修正为最后一个队列</param>
void Add(T item, Func<int> fun);
/// <summary>
/// 获取可分配项
/// </summary>
/// <param name="fun">分配规则</param>
/// <param name="item">分配到的分配项</param>
/// <returns>是否分配成功</returns>
bool Get(Func<T, bool> fun, ref T item);
/// <summary>
/// 取消获取
/// </summary>
/// <param name="item"></param>
/// <returns></returns>
bool GetBack(T item);
/// <summary>
/// 设定指定分配项已经处于分配状态
/// </summary>
/// <param name="item"></param>
void Set(T item);
/// <summary>
/// 移除可分配项
/// </summary>
/// <param name="item">可分配项</param>
/// <returns>返回移除是否成功</returns>
bool Remove(T item);
/// <summary>
/// 获取所有可分配项
/// </summary>
/// <returns></returns>
IEnumerable<T> GetAllAllotItems();
} /// <summary>
/// 自动分配
/// </summary>
public interface IAutoAllot<Tu, Ti> : IAllotUsers<Tu>, IAllotItems<Ti>
{
/// <summary>
/// 是否已经存在分配记录
/// </summary>
/// <param name="user"></param>
/// <returns></returns>
bool IsAllot(Tu user);
/// <summary>
/// 获取可分配项，如存在分配记录，则直接返回记录对应的分配项目
/// </summary>
/// <typeparam name="T1">待分配者类型</typeparam>
/// <param name="user">待分配者</param>
/// <param name="fun">分配规则</param>
/// <param name="item">分配到的分配项</param>
/// <returns>是否分配成功</returns>
bool GetAllotItem(Tu user, Func<Ti, bool> fun, ref Ti item);
/// <summary>
/// 撤销分配
/// </summary>
/// <param name="user"></param>
/// <returns></returns>
bool GetBackAllotItem(Tu user);
/// <summary>
/// 分配结束，移除分配关系以及可分配项
/// </summary>
/// <param name="user"></param>
/// <returns></returns>
bool Finished(Tu user);
}然后针对接口定义，实现了相应的默认的分配类
1、GeneralAllotUsers，该类库内部包含一个HashSet作为集合载体，保证每个用户在分配队列中的唯一性
/// <summary>
/// 通用分配用户
/// </summary>
/// <typeparam name="T"></typeparam>
public class GeneralAllotUsers<T> : IAllotUsers<T>
{
private HashSet<T> _users = new HashSet<T>();
#region IAllotUsers<T> 成员
public bool LoginIn(T user)
{
bool ret = true;
if (!this._users.Contains(user))
{
ret = this._users.Add(user);
}
return ret;
}
public bool LoginOut(T user)
{
bool ret = true;
if (this._users.Contains(user))
{
ret = this._users.Remove(user);
}
return ret;
}
public bool IsLogin(T user)
{
return this._users.Contains(user);
}
public IEnumerable<T> GetAllLoginUsers()
{
return this._users.ToArray();
}
#endregion
}2、GeneralAllotItems，该类库内部包含一个Dictionary来作为待分配项的载体，Key对应待分配项，Value对应该分配项是否已经被分配（分配项不允许被重复分配），然后通过List<List<T>>来作为分配顺序的一个载体，另外通过一个private的object对象来保证该类在多线程时的分配唯一性
/// <summary>
/// 通用分配项
/// </summary>
/// <typeparam name="T"></typeparam>
public class GeneralAllotItems<T> : IAllotItems<T>
{
private Dictionary<T, bool> _dic = new Dictionary<T, bool>();
private List<List<T>> _list = new List<List<T>>();
private object _obj = new object();
public GeneralAllotItems()
: this(1)
{
}
/// <summary>
/// 分配初始化
/// </summary>
/// <param name="levels">存在多少个分配队列</param>
public GeneralAllotItems(int levels)
{
if (levels <= 0)
{
throw new ArgumentException();
}
for (int i = 0; i < levels; i++)
{
this._list.Add(new List<T>());
}
}
#region IAllotItems<T> 成员
public void Add(T item, Func<int> fun)
{
if (!this._dic.ContainsKey(item))
{
int lv = 0;
if (fun != null)
{
lv = fun();
}
//修正lv的值范围
if (lv < 0)
{
lv = 0;
}
else if (lv >= this._list.Count)
{
lv = this._list.Count - 1;
}
this._list[lv].Add(item);
this._dic.Add(item, false);
}
}
public bool Get(Func<T, bool> fun, ref T item)
{
foreach (var l in this._list)
{
foreach (T k in l)
{
if (!this._dic[k])//如果该分配项尚未分配过
{
lock (this._obj)
{
if (!this._dic[k])
{
if (fun == null || fun(k))//不存在分配规则或者符合分配规则
{
item = k;
this._dic[k] = true;
return true;
}
}
}
}
}
}
return false;
}
public bool GetBack(T item)
{
bool ret = false;
if (this._dic.ContainsKey(item))
{
ret = true;
this._dic[item] = false;
}
return ret;
}
public void Set(T item)
{
if (this._dic.ContainsKey(item))
{
this._dic[item] = true;
}
}
public bool Remove(T item)
{
for (int i = 0; i < this._list.Count; i++)
{
if (this._list[i].Contains(item))
{
this._list[i].Remove(item);
break;
}
}
return this._dic.Remove(item);
}
public IEnumerable<T> GetAllAllotItems()
{
return (from l in this._list
let p = l
from t in p
select t).ToArray();
}
#endregion
} /// <summary>
/// 自动分配通用类
/// </summary>
/// <typeparam name="Tu"></typeparam>
/// <typeparam name="Ti"></typeparam>
public class GeneralAutoAllot<Tu, Ti> : IAutoAllot<Tu, Ti>
{
private IAllotItems<Ti> _items;
private IAllotUsers<Tu> _users;
private Dictionary<Tu, Ti> _dic;
public GeneralAutoAllot()
: this(null)
{
}
public GeneralAutoAllot(Dictionary<Tu, Ti> dic)
: this(dic, null, null)
{
}
public GeneralAutoAllot(Dictionary<Tu, Ti> dic, IAllotUsers<Tu> users, IAllotItems<Ti> items)
{
this._dic = dic;
if (this._dic == null)
{
this._dic = new Dictionary<Tu, Ti>();
}
this._users = users;
if (this._users == null)
{
this._users = new GeneralAllotUsers<Tu>();
}
this._items = items;
if (this._items == null)
{
this._items = new GeneralAllotItems<Ti>();
}
}
#region IAutoAllot<Tu,Ti> 成员
public bool IsAllot(Tu user)
{
return this._dic.ContainsKey(user);
}
/// <summary>
/// FIFO,先入先出
/// </summary>
/// <param name="user"></param>
/// <param name="fun"></param>
/// <param name="item"></param>
/// <returns></returns>
public bool GetAllotItem(Tu user, Func<Ti, bool> fun, ref Ti item)
{
bool ret = false;
if (this._dic.ContainsKey(user))
{//已经有分配记录，则直接获取分配记录中对应的分配项
ret = true;
item = this._dic[user];
}
else
{
//是否已经登入
if (this._users.IsLogin(user))
{
//从items中获取可分配项
ret = this._items.Get(fun, ref item);
if (ret)
{//成功分配后记录分配关系
this._dic.Add(user, item);
}
}
}
return ret;
}
public bool GetBackAllotItem(Tu user)
{
bool ret = false;
if (this._dic.ContainsKey(user))
{
ret = this._items.GetBack(this._dic[user]);
this._dic.Remove(user);
}
return ret;
}
public bool Finished(Tu user)
{
bool ret = false;
if (this._dic.ContainsKey(user))
{
ret = this._items.Remove(this._dic[user]);
this._dic.Remove(user);
}
return ret;
}
public IEnumerable<Tu> GetAllLoginUsers()
{
return this._users.GetAllLoginUsers();
}
#endregion
#region IAllotUsers<Tu> 成员
public bool LoginIn(Tu user)
{
return _users.LoginIn(user);
}
public bool LoginOut(Tu user)
{
return _users.LoginOut(user);
}
public bool IsLogin(Tu user)
{
return _users.IsLogin(user);
}
#endregion
#region IAllotItems<Ti> 成员
public void Add(Ti item, Func<int> fun)
{
_items.Add(item, fun);
}
public bool Get(Func<Ti, bool> fun, ref Ti item)
{
return _items.Get(fun, ref item);
}
public bool GetBack(Ti item)
{
return _items.GetBack(item);
}
public void Set(Ti item)
{
_items.Set(item);
}
public bool Remove(Ti item)
{
return _items.Remove(item);
}
public IEnumerable<Ti> GetAllAllotItems()
{
return this._items.GetAllAllotItems();
}
#endregion
} public class AutoAllotProxy
{
/// <summary>
/// 自动分配类
/// </summary>
private static IAutoAllot<string, int> AutoAllot;
static AutoAllotProxy()
{
InitData(null);
}
/// <summary>
/// 政策待分配数据初始化
/// </summary>
private static void InitData(IEnumerable<string> loginUsers)
{
//数据恢复
List<KeyValuePair<int, string>> list;//list=XXXXXX此部分读取数据库
//从读取出来的数据中恢复分配关系
Dictionary<string, int> tmpDic = new Dictionary<string, int>();
HashSet<int> alloting = new HashSet<int>();//正在审核
List<int> allot = new List<int>();//待审核政策，需要按时间排序
if (list != null && list.Count > 0)
{
//为了防止出现单个用户存在多个正在审核记录，采用foreach遍历
foreach (var k in list)
{
if (!string.IsNullOrEmpty(k.Value))
{
//如果单个用户有多条审核记录，则只接受第一条审核关系，其余审核关系被排除
if (!tmpDic.ContainsKey(k.Value))
{
tmpDic.Add(k.Value, k.Key);
alloting.Add(k.Key);
allot.Add(k.Key);
}
}
else
{
allot.Add(k.Key);
}
}
}
//恢复用户和政策的分配关系
AutoAllot = new GeneralAutoAllot<string, int>(tmpDic);
foreach (var k in allot)
{//恢复政策列表
AutoAllot.Add(k, null);
}
foreach (var k in alloting)
{//恢复政策分配状态
AutoAllot.Set(k);
}
var users = loginUsers;
if (users == null || !users.Any())
{
users = tmpDic.Keys;
}
foreach (var k in users)
{//恢复用户登入状态
AutoAllot.LoginIn(k);
}
}
/// <summary>
/// 用户登入
/// </summary>
/// <param name="userName"></param>
public void LoginIn(string userName)
{
if (!string.IsNullOrEmpty(userName))
{
AutoAllot.LoginIn(userName);
}
}
/// <summary>
/// 用户退出
/// </summary>
/// <param name="userName"></param>
/// <returns>0：失败，1：成功，2：退出但存在分配记录</returns>
public int LoginOut(string userName)
{
int ret = 0;
if (!string.IsNullOrEmpty(userName))
{
ret = AutoAllot.LoginOut(userName) ? 1 : 0;
if (ret == 1 && AutoAllot.IsAllot(userName))
{
ret = 2;
}
}
return ret;
}
/// <summary>
/// 用户是否已经登入
/// </summary>
/// <param name="userName"></param>
/// <returns></returns>
public bool IsLogin(string userName)
{
if (!string.IsNullOrEmpty(userName))
{
return AutoAllot.IsLogin(userName);
}
return true;
}
/// <summary>
/// 添加待审核项
/// </summary>
/// <param name="pid"></param>
public void Add(int pid)
{
if (pid > 0)
{
AutoAllot.Add(pid, null);//因为分配顺序没有特殊要求，只是简单的先入先出，所以直接传入null
}
}
/// <summary>
/// 获取分配的待审核项，该方法只负责分配，将分配关系持久化到数据库的事情由外部来实现
/// </summary>
/// <param name="userName"></param>
/// <returns></returns>
public int Get(string userName)
{
int pid = 0;
if (!string.IsNullOrEmpty(userName))
{
AutoAllot.GetAllotItem(userName,
null,
ref pid);
}
return pid;
}
/// <summary>
/// 政策审核结束
/// </summary>
/// <param name="userName"></param>
/// <returns></returns>
public bool Finished(string userName)
{
if (!string.IsNullOrEmpty(userName))
{
return AutoAllot.Finished(userName);
}
return false;
}
/// <summary>
/// 获取当前内存中存在的分配项
/// </summary>
/// <returns></returns>
public int[] GetAllAllotPolicies()
{
return AutoAllot.GetAllAllotItems().ToArray();
}
/// <summary>
/// 获取所有登入的用户
/// </summary>
/// <returns></returns>
public string[] GetAllLoginUsers()
{
return AutoAllot.GetAllLoginUsers().ToArray();
}
/// <summary>
/// 分配重新开启
/// </summary>
public void ResetAllot()
{
InitData(AutoAllot.GetAllLoginUsers());//将当前已登录的用户传入进行重新初始化分配关系
}
}
760
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
