public bool IsCooldownExpired(ulong serverId, string commandName)
{
CommandInfo cmdInfo = Provider.GetService <CommandService>().FindInfoByName(commandName);
if (cmdInfo == null)
{
return(true);
}
if (!ServerCooldowns.ContainsKey(serverId))
{
return(true);
}
var foundCmd = ServerCooldowns.GetValue(serverId).FirstOrDefault(x => x.Key.Name.ToLower() == cmdInfo.Name.ToLower());
if (foundCmd.Key == null)
{
return(true);
}
if (foundCmd.Equals(default(KeyValuePair <CommandInfo, int>)))
{
return(true);
}
return(IsCooldownExpired(serverId, foundCmd.Key));
}
public void SetValue()
{
var Test = new ConcurrentDictionary<string, int>();
Test.AddOrUpdate("Q", 4, (x, y) => 4);
Test.AddOrUpdate("Z", 2, (x, y) => 4);
Test.AddOrUpdate("C", 3, (x, y) => 4);
Test.AddOrUpdate("A", 1, (x, y) => 4);
Assert.Equal(4, Test.GetValue("Q"));
Test.SetValue("Q", 40);
Assert.Equal(40, Test.GetValue("Q"));
}
public void SetValue()
{
var Test = new ConcurrentDictionary <string, int>();
Test.AddOrUpdate("Q", 4, (x, y) => 4);
Test.AddOrUpdate("Z", 2, (x, y) => 4);
Test.AddOrUpdate("C", 3, (x, y) => 4);
Test.AddOrUpdate("A", 1, (x, y) => 4);
Assert.Equal(4, Test.GetValue("Q"));
Test.SetValue("Q", 40);
Assert.Equal(40, Test.GetValue("Q"));
}
public void GetValue()
{
var Test = new ConcurrentDictionary <string, int>();
Test.AddOrUpdate("Q", 4, (_, __) => 4);
Test.AddOrUpdate("Z", 2, (_, __) => 4);
Test.AddOrUpdate("C", 3, (_, __) => 4);
Test.AddOrUpdate("A", 1, (_, __) => 4);
Assert.Equal(4, Test.GetValue("Q"));
Assert.Equal(0, Test.GetValue("V"));
Assert.Equal(123, Test.GetValue("B", 123));
}
public bool IsAudioStreaming(ulong guildId)
{
if (!IsInVoiceChannel(guildId))
{
return(false);
}
return(ServerVoiceConnections.GetValue(guildId).CancelToken != null);
}
private ICloudBlob GetBlobReference(string blockName)
{
return(blobReferences.GetValue(
blockName,
blobReferencesLock,
() => InitializeBlobReferenceAsync(blockName).GetAwaiter().GetResult()));
}
public static DynamicMethod GetConvertToListMethod <T>()
{
return(_ConvertToListMethodCache.GetValue(typeof(T).TypeHandle, () =>
{
return EmitUtil.CreateTableToListMethod <T>();
}));
}
public static DynamicMethod GetConvertToEntityMethod <T>()
{
return(_ConvertDataRowToEntityMethodCache.GetValue(typeof(T).TypeHandle, () =>
{
return EmitUtil.CreateDataRowToEntityMethod <T>();
}));
}
public static DynamicMethod GetObjectToParamListMethod <TParam>(Type objType) where TParam : DbParameter
{
return(_ObjectToParamListMethodCache.GetValue(objType.TypeHandle, () =>
{
return EmitUtil.CreateObjectToParamListMethod <TParam>(objType);
}));
}
public static List <FieldInfo> GetRpcFieldList(this Type type)
{
return(_FieldListDic.GetValue(type.TypeHandle, () =>
{
List <FieldInfo> _FieldList = new List <FieldInfo>();
for (; type != null; type = type.BaseType)
{
FieldInfo[] fields = type.GetFields(BindingFlags.Public |
BindingFlags.Instance |
BindingFlags.NonPublic |
BindingFlags.GetField |
BindingFlags.DeclaredOnly);
if (fields != null)
{
for (int i = 0; i < fields.Length; i++)
{
if ((fields[i].Attributes & FieldAttributes.NotSerialized) == 0)
{
if (!_FieldList.Contains(fields[i]))
{
_FieldList.Add(fields[i]);
}
}
}
}
}
return _FieldList;
}));
}
private IEnumerable <IServerFilter> GetFilter(MethodInfo methodInfo)
{
return(_FilterDic.GetValue(methodInfo.MethodHandle, () =>
{
return GetFilterList(methodInfo);
}));
}
public async Task SendMessage(string msg)
{
var msgWithAuthor = $"{UserInfoProvider.GetUsername(Context)}: {msg}\n";
var connId = Context.ConnectionId;
var roomId = ConnectionInRoom.GetValue(connId);
await Clients.Group(roomId).SendAsync("sendMessage", msgWithAuthor);
}
private CacheAttribute GetCacheAttribute(IInvocation invocation)
{
return(_CacheAttributeDic.GetValue(invocation.Method.MethodHandle, () =>
{
return invocation.Method.GetMethodAttribute <CacheAttribute>();
}));
}
/// <summary>
/// 获取投影关系
/// </summary>
/// <typeparam name="TSource">源属性</typeparam>
/// <typeparam name="TTarget">目标属性</typeparam>
/// <typeparam name="projectionExpression">转换表达式</typeparam>
/// <returns>投影关系</returns>
public static ProjectionDefinition <TSource, TTarget> ToProjection <TSource, TTarget>(this Expression <Func <TSource, TTarget> > projectionExpression)
{
var targetType = typeof(TTarget);
var sourceType = typeof(TSource);
return(_ProjectionCache.GetValue(targetType.TypeHandle, sourceType.TypeHandle, () =>
{
return Builders <TSource> .Projection.Expression(projectionExpression);
}) as ProjectionDefinition <TSource, TTarget>);
}
public static MQAttribute GetMQAttribute <T>()
{
var typeT = typeof(T);
var typeHandle = typeT.TypeHandle;
return(_mqAttributeCache.GetValue(typeHandle, () =>
{
return typeT.GetAttribute <MQAttribute>();
}));
}
public IEnumerable <object> GetSubscribersFor(string eventName)
{
var subscribers = map.GetValue(eventName, null);
if (subscribers != null)
{
var m = subscribers.Map(x => x.Key);
return(m);
}
return(new List <object>());
}
public static List <PropertyInfo> GetPropertyInfos(object obj)
{
if (obj.IsNull())
{
return(new List <PropertyInfo>());
}
return(_cacheProperties.GetValue(obj.GetType(), () =>
{
return obj.GetType().GetProperties(BindingFlags.GetProperty | BindingFlags.Instance | BindingFlags.Public).ToList();
}));
}
/// <summary>
/// 获取一个锁(需要自己释放)
/// </summary>
/// <param name="key">锁的键</param>
/// <param name="value">当前占用值</param>
/// <param name="span">耗时时间</param>
/// <returns>成功返回true</returns>
public bool LockTake(string key, string value, TimeSpan span)
{
EnsureUtil.NotNullAndNotEmpty(key, "Lockkey");
EnsureUtil.NotNullAndNotEmpty(value, "Lockvalue");
var obj = _LockCache.GetValue(key, () => { return(new object()); });
Monitor.Enter(obj);
_LockUserCache[key] = value;
LogUtil.Debug($"{key}:{value}获取锁成功");
return(true);
}
public static MongoDBAttribute GetMongoDBAttribute <T>()
{
var typeT = typeof(T);
var typeHandle = typeT.TypeHandle;
//return typeT.GetAttribute<MQAttribute>();
return(_cacheAttribute.GetValue(typeHandle, () =>
{
return typeT.GetAttribute <MongoDBAttribute>();
}));
}
/// <summary>
/// 根据类型获取类型的属性信息
/// </summary>
/// <param name="type">类型</param>
/// <returns>类型的属性信息</returns>
public static List <PropertyInfo> GetTypeProperties(Type type)
{
if (type == null)
{
return(new List <PropertyInfo>());
}
var typeHandle = type.TypeHandle;
return(_propertyCache.GetValue(typeHandle, () =>
{
return type.GetProperties(BindingFlags.Instance | BindingFlags.Public).ToList();
}));
}
/// <summary>
/// 获取枚举类型的说明信息
/// </summary>
/// <param name="enumType">枚举类型</param>
/// <returns>枚举类型的说明信息</returns>
public static Dictionary <string, string> GetDesc(Type enumType)
{
if (enumType == null)
{
return(new Dictionary <string, string>());
}
var typeHandle = enumType.TypeHandle;
return(_enumDescCache.GetValue(typeHandle, () =>
{
return GetDescriptions(enumType);
}));
}
/// <summary>
/// 获取一个锁(需要自己释放)
/// </summary>
/// <param name="key">锁的键</param>
/// <param name="value">当前占用值</param>
/// <param name="span">耗时时间</param>
/// <returns>成功返回true</returns>
public bool LockTake(string key, string value, TimeSpan span)
{
EnsureUtil.NotNullAndNotEmpty(key, "Lockkey");
EnsureUtil.NotNullAndNotEmpty(value, "Lockvalue");
var obj = _LockCache.GetValue(key, () => { return(new object()); });
if (Monitor.TryEnter(obj, span))
{
_LockUserCache[key] = value;
return(true);
}
return(false);
}
/// <summary>
/// 判断是否是自增
/// </summary>
/// <param name="type">要判断你的类型</param>
/// <returns>有自增字段返回true</returns>
public static bool IsIdentity(Type type)
{
if (type == null)
{
return(false);
}
var typeHandle = type.TypeHandle;
return(_IdentityCache.GetValue(typeHandle, () =>
{
return PropertyUtil.GetTypeProperties(type).Where(m => m.GetCustomAttribute(typeof(IdentityAttribute), false) != null).Any();
}));
}
/// <summary>
/// 获取类型的DisplayName
/// </summary>
/// <param name="type">要获取的类型</param>
/// <returns>DisplayName</returns>
public static string GetDisplayName(this Type type)
{
if (type == null)
{
return(string.Empty);
}
string displayName = string.Empty;
return(_DisplayNameCache.GetValue(type.TypeHandle, () =>
{
DisplayNameAttribute displayAttribute = type.GetCustomAttribute <DisplayNameAttribute>(false);
return displayAttribute?.DisplayName;
}));
}
/// <summary>
/// 根据类型获取字段属性与数据的访问权
/// </summary>
/// <param name="type">类型</param>
/// <returns>字段属性与数据的访问权</returns>
public static FieldInfo[] GetTypeFields(Type type)
{
if (type == null)
{
return(new FieldInfo[0]);
}
var typeHandle = type.TypeHandle;
return(_TypeFieldCache.GetValue(typeHandle, () =>
{
return type.GetFields(BindingFlags.Public | BindingFlags.Instance);
}));
}
public static SocketRemotingClient GetClient(Type classType)
{
var className = classType.FullName;
//TODO 根据类名字动态获取IP端口信息
var remoteEndPointConfigProvider = DependencyManage.Resolve <IRemoteEndPointConfigProvider>();
var config = remoteEndPointConfigProvider.GetConfig();
var ipEndPoint = config.GetEndPoint(classType.FullName);
var clientPool = ClientPoolList.GetValue(ipEndPoint, () =>
{
return(new ClientPool(config.MaxClientPoolCount, ipEndPoint));
});
return(clientPool.GetCilent());
}
public static bool TryUpdate <TKey, TValue>(this ConcurrentDictionary <TKey, TValue> self, TKey key, TValue value)
{
TValue currentValue = default(TValue);
if (self.ContainsKey(key))
{
currentValue = self.GetValue(key);
return(self.TryUpdate(key, value, currentValue));
}
else
{
return(self.TryAdd(key, value));
}
}
/// <summary>
/// 获取拼接后的方法名字
/// </summary>
/// <param name="methodInfo"></param>
/// <returns></returns>
public static string GetCombineMethodName(this MethodInfo methodInfo)
{
return(_MethodNameDic.GetValue(methodInfo.MethodHandle, () =>
{
StringBuilder methodBuilder = new StringBuilder();
methodBuilder.Append(methodInfo.Name);
var parameterList = methodInfo.GetParameters();
methodBuilder.Append("_").Append(parameterList.Length.ToString()).Append("|");
foreach (var item in parameterList)
{
methodBuilder.Append(item.ParameterType.Name).Append('|');
}
methodBuilder.Remove(methodBuilder.Length - 1, 1);
return methodBuilder.ToString();
}));
}
/// <summary>
/// 创建OperateResult的Emit方法
/// </summary>
/// <param name="operateType">操作结果类型</param>
/// <param name="operateState">操作结果状态</param>
/// <param name="msg">操作结果信息</param>
/// <returns>OperateResult</returns>
public static OperateResult EmitCreate(Type operateType, OperateState operateState, string msg)
{
var returnType = operateType;
if (operateType.BaseType == typeof(Task))
{
returnType = operateType.GenericTypeArguments[0];
}
var method = _CreateOperateResultCache.GetValue(returnType.TypeHandle, () =>
{
return(EmitMethodCreate(returnType));
});
var fuc = (Func <OperateState, string, OperateResult>)method.CreateDelegate(typeof(Func <OperateState, string, OperateResult>));
return(fuc(operateState, msg));
}
public static Type GetType(string typeName)
{
var typeHandle = _RuntimeTypeHandleDic.GetValue(typeName, () =>
{
var assemblies = AppDomain.CurrentDomain.GetAssemblies();
foreach (var assembly in assemblies)
{
var type = assembly.GetType(typeName);
if (type != null)
{
return(type.TypeHandle);
}
}
throw new Exception("not fount typename " + typeName);
});
return(Type.GetTypeFromHandle(typeHandle));
}
/// <summary>
/// Execute Binding Method
/// </summary>
/// <param name="instance">MSMQ 处理器实现</param>
/// <param name="msg">待处理消息</param>
internal void Execute(TMsmqHandlerImpl instance, MsmqMessageJsonObject msg)
{
ThrowHelper.ThrowIfNull(instance, "instance");
ThrowHelper.ThrowIfNull(msg, "msg");
ThrowHelper.ThrowIfNull(msg.HandlerName, "msg.HandlerName");
ThrowHelper.ThrowIfNull(msg.JsonMessage, "msg.JsonMessage");
var handlerMethod = m_MsmqContract_Cache.GetValue(msg.HandlerName);
ThrowHelper.ThrowIfNull(handlerMethod, "handlerMethod");
var msgType = handlerMethod.GetParameters()[0].ParameterType;
var msgObj = JsonHelper.DeserializeObject(msg.JsonMessage, msgType);
ThrowHelper.ThrowIfNull(msgObj, "msgObj");
//handlerMethod.FastInvoke(instance, new object[] { msgObj });
handlerMethod.Invoke(instance, new[] { msgObj });
}
