//-------------------------------------------------------------------------------------------------------------------------- //供外部通过QueueAction调用的方法,实际执行线程是DataCacheThread。 //-------------------------------------------------------------------------------------------------------------------------- internal void LoadAccount(string accountId) { Msg_LD_Load msg = new Msg_LD_Load(); msg.MsgId = (int)DataEnum.TableAccount; msg.PrimaryKeys.Add(accountId); Msg_LD_SingleLoadRequest reqAccount = new Msg_LD_SingleLoadRequest(); reqAccount.MsgId = (int)DataEnum.TableAccount; reqAccount.LoadType = Msg_LD_SingleLoadRequest.LoadTypeEnum.LoadSingle; reqAccount.Keys.Add(accountId); msg.LoadRequests.Add(reqAccount); RequestLoad(msg, (ret) => { KeyString primaryKey = KeyString.Wrap(ret.PrimaryKeys); if (Msg_DL_LoadResult.ErrorNoEnum.Success == ret.ErrorNo) { LogSys.Log(LOG_TYPE.INFO, ConsoleColor.Green, "DataCache Load Success: Msg:{0}, Key:{1}", "Account", primaryKey); } else if (Msg_DL_LoadResult.ErrorNoEnum.NotFound == ret.ErrorNo) { LogSys.Log(LOG_TYPE.INFO, ConsoleColor.Yellow, "DataCache Load NotFound: Msg:{0}, Key:{1}", "Account", primaryKey); } else { LogSys.Log(LOG_TYPE.ERROR, ConsoleColor.Red, "DataCache Load Failed: Msg:{0}, Key:{1}, ERROR:{2}", "Account", primaryKey, ret.ErrorInfo); } UserProcessScheduler dataProcessScheduler = UserServer.Instance.UserProcessScheduler; dataProcessScheduler.DefaultUserThread.QueueAction(dataProcessScheduler.LoadAccountCallback, accountId, ret); }); }
private void OnSaveReply(Msg_DL_SaveResult msg, PBChannel channel, int src, uint session) { KeyString key = KeyString.Wrap(msg.PrimaryKeys); ConcurrentDictionary <KeyString, ConcurrentQueue <SaveRequestInfo> > dict; if (m_SaveRequestQueues.TryGetValue(msg.MsgId, out dict)) { ConcurrentQueue <SaveRequestInfo> reqQueue; if (dict.TryGetValue(key, out reqQueue)) { SaveRequestInfo info; if (reqQueue.TryPeek(out info)) { if (info.m_Request.SerialNo == msg.SerialNo) { if (null != info.m_Callback) { info.m_Callback(msg); } SaveRequestInfo delInfo; if (reqQueue.TryDequeue(out delInfo)) { m_SaveRequestPool.Recycle(delInfo); } //发送队列中的下一个消息 if (reqQueue.TryPeek(out info)) { info.m_LastSendTime = TimeUtility.GetLocalMilliseconds(); m_DataStoreChannel.Send(info.m_Request); } } } } } }
internal void RequestSave(Msg_LD_Save msg, MyAction <Msg_DL_SaveResult> callback = null) { lock (m_SaveRequestQueuesLock) { msg.SerialNo = GenNextSerialNo(); KeyString key = KeyString.Wrap(msg.PrimaryKeys); ConcurrentDictionary <KeyString, ConcurrentQueue <SaveRequestInfo> > dict; if (!m_SaveRequestQueues.TryGetValue(msg.MsgId, out dict)) { dict = m_SaveRequestQueues.AddOrUpdate(msg.MsgId, new ConcurrentDictionary <KeyString, ConcurrentQueue <SaveRequestInfo> >(), (k, v) => v); } ConcurrentQueue <SaveRequestInfo> queue; if (!dict.TryGetValue(key, out queue)) { queue = dict.AddOrUpdate(key, new ConcurrentQueue <SaveRequestInfo>(), (k, v) => v); } SaveRequestInfo info = m_SaveRequestPool.Alloc(); info.m_Request = msg; info.m_Callback = callback; if (queue.Count == 0) { //当前队列为空时直接发送消息 info.m_LastSendTime = TimeUtility.GetLocalMilliseconds(); m_DataStoreChannel.Send(msg); } queue.Enqueue(info); } }
private void OnLoadReply(Msg_DL_LoadResult msg, PBChannel channel, int src, uint session) { KeyString key = KeyString.Wrap(msg.PrimaryKeys); ConcurrentDictionary <KeyString, LoadRequestInfo> dict; if (m_LoadRequests.TryGetValue(msg.MsgId, out dict)) { LoadRequestInfo info; if (dict.TryGetValue(key, out info)) { if (info.m_Request.SerialNo == msg.SerialNo) { if (null != info.m_Callback) { info.m_Callback(msg); } LoadRequestInfo delInfo; if (dict.TryRemove(key, out delInfo)) { m_LoadRequestPool.Recycle(delInfo); } } } } }
private static bool Equals(KeyString a, KeyString b) { bool ret = false; if (object.ReferenceEquals(a, b)) { ret = true; } else if (object.ReferenceEquals(a, null)) { ret = false; } else if (object.ReferenceEquals(b, null)) { ret = false; } else { int ct = a.m_Keys.Count; if (ct == b.m_Keys.Count) { ret = true; for (int ix = 0; ix < ct; ++ix) { if (a.m_Keys[ix] != b.m_Keys[ix]) { ret = false; break; } } } } return(ret); }
public static KeyString Wrap(List <string> strs) { KeyString obj = new KeyString(); obj.m_Keys = strs; return(obj); }
public static KeyString Wrap(params string[] strs) { KeyString obj = new KeyString(); for (int i = 0; i < strs.Length; ++i) { obj.m_Keys.Add(strs[i]); } return obj; }
/// <summary> /// 主键查找 /// </summary> /// <param name="msgId">数据类型ID</param> /// <param name="key">主键</param> /// <returns>查找成功返回对应数据对象,不存在返回null</returns> internal InnerCacheItem Find(int msgId, KeyString key) { InnerCacheTable cacheTable = null; m_CacheTableDict.TryGetValue(msgId, out cacheTable); if (cacheTable != null) { return cacheTable.Find(key); } return null; }
/// <summary> /// 外键查找 /// </summary> /// <param name="msgId">数据类型ID</param> /// <param name="key">外键</param> /// <returns></returns> internal List<InnerCacheItem> FindByForeignKey(int msgId, KeyString foreignKey) { InnerCacheTable cacheTable = null; m_CacheTableDict.TryGetValue(msgId, out cacheTable); if (cacheTable != null) { return cacheTable.FindByForeignKey(foreignKey); } return new List<InnerCacheItem>(); }
internal void GMLoadUser(string gmAccount, ulong userGuid, LobbyGmMessageDefine jsonMsgId, int nodeHandle) { string key = userGuid.ToString(); Msg_LD_Load msg = new Msg_LD_Load(); msg.MsgId = (int)DataEnum.TableUserInfo; msg.PrimaryKeys.Add(key); Msg_LD_SingleLoadRequest reqUser = new Msg_LD_SingleLoadRequest(); reqUser.MsgId = (int)DataEnum.TableUserInfo; reqUser.LoadType = Msg_LD_SingleLoadRequest.LoadTypeEnum.LoadSingle; reqUser.Keys.Add(key); msg.LoadRequests.Add(reqUser); RequestLoad(msg, (ret) => { JsonMessage resultMsg = new JsonMessage(jsonMsgId, gmAccount); GameFrameworkMessage.Msg_LC_GmQueryUser protoData = new GameFrameworkMessage.Msg_LC_GmQueryUser(); protoData.m_Result = GameFrameworkMessage.GmResultEnum.Failed; protoData.m_Info = null; KeyString primaryKey = KeyString.Wrap(ret.PrimaryKeys); if (Msg_DL_LoadResult.ErrorNoEnum.Success == ret.ErrorNo) { LogSys.Log(LOG_TYPE.INFO, "DataCache Load Success: Msg:{0}, Key:{1}", "GmUser", primaryKey); TableUserInfo dataUser = null; foreach (var result in ret.Results) { object _msg; if (DbDataSerializer.Decode(result.Data, DataEnum2Type.Query(result.MsgId), out _msg)) { DataEnum msgEnum = (DataEnum)result.MsgId; switch (msgEnum) { case DataEnum.TableUserInfo: dataUser = _msg as TableUserInfo; break; default: LogSys.Log(LOG_TYPE.ERROR, ConsoleColor.Red, "Decode user data ERROR. Wrong message id. UserGuid:{0}, WrongId:{1}", userGuid, msgEnum); break; } } } protoData.m_Result = GameFrameworkMessage.GmResultEnum.Success; protoData.m_Info = CreateGmUserInfo(dataUser); } else if (Msg_DL_LoadResult.ErrorNoEnum.NotFound == ret.ErrorNo) { LogSys.Log(LOG_TYPE.INFO, ConsoleColor.Yellow, "DataCache Load NotFound: Msg:{0}, Key:{1}", "GmUser", primaryKey); } else { LogSys.Log(LOG_TYPE.ERROR, "DataCache Load Failed: Msg:{0}, Key:{1}, ERROR:{2}", "GmUser", primaryKey, ret.ErrorInfo); } resultMsg.m_ProtoData = protoData; JsonGmMessageDispatcher.SendNodeMessage(nodeHandle, resultMsg); }); }
public static KeyString Wrap(params string[] strs) { KeyString obj = new KeyString(); for (int i = 0; i < strs.Length; ++i) { obj.m_Keys.Add(strs[i]); } return(obj); }
private Dictionary<KeyString, KeyString> m_PrimaryForeignDict = new Dictionary<KeyString, KeyString>(); //primaryKey-foreignKey #endregion Fields #region Methods /// <summary> /// 添加或更新 /// </summary> /// <param name="key">主键,不能为空</param> /// <param name="foreignKey">外键,可以为空</param> /// <param name="dataMessage">数据值</param> /// <param name="dataVersion">数据版本</param> internal void AddOrUpdate(KeyString key, KeyString foreignKey, byte[] dataMessage, long cacheVersion) { InnerCacheItem cacheItem = null; m_PrimaryDict.TryGetValue(key, out cacheItem); if (cacheItem == null) { //数据不在缓存中 if (dataMessage == null) { //被删除的数据 return; } cacheItem = new InnerCacheItem(dataMessage); m_PrimaryDict.Add(key, cacheItem); if (!KeyString.IsNullOrEmpty(foreignKey)) { m_PrimaryForeignDict[foreignKey] = key; HashSet<KeyString> associateKeys = null; m_ForeignPrimaryDict.TryGetValue(foreignKey, out associateKeys); if (associateKeys != null) { associateKeys.Add(key); } else { associateKeys = new HashSet<KeyString>(); associateKeys.Add(key); m_ForeignPrimaryDict.Add(foreignKey, associateKeys); } } } else { //数据已在缓存中 if (CompareDataVersion(cacheVersion, cacheItem.CacheVersion)) { //更新缓存 cacheItem.DirtyState = DirtyState.Unsaved; cacheItem.Valid = true; cacheItem.CacheVersion = cacheVersion; if (dataMessage == null) { cacheItem.Valid = false; } else { cacheItem.DataMessage = dataMessage; } //更新外键关系 if (!KeyString.IsNullOrEmpty(foreignKey)) { m_PrimaryForeignDict[foreignKey] = key; HashSet<KeyString> associateKeys = null; m_ForeignPrimaryDict.TryGetValue(foreignKey, out associateKeys); if (associateKeys != null) { associateKeys.Add(key); } else { associateKeys = new HashSet<KeyString>(); associateKeys.Add(key); m_ForeignPrimaryDict.Add(foreignKey, associateKeys); } } } else { //新数据的dataVersion低,不更新缓存,输出警告日志 LogSys.Log(LOG_TYPE.WARN, "Update cache version WARN. Key:{0}, NewCacheVersion:{1}, OldCacheVersion:{2}", key, cacheVersion, cacheItem.CacheVersion); } } }
static public int get_Keys(IntPtr l) { try { GameFramework.KeyString self = (GameFramework.KeyString)checkSelf(l); pushValue(l, true); pushValue(l, self.Keys); return(2); } catch (Exception e) { return(error(l, e)); } }
/// <summary> /// 添加或更新 /// </summary> /// <param name="msgId">数据类型ID</param> /// <param name="key">Key</param> /// <param name="dataMessage">待添加的数据对象</param> internal void AddOrUpdate(int msgId, KeyString key, KeyString foreignKey, byte[] dataMessage, long cacheVersion = InnerCacheSystem.InitialCacheVersion) { InnerCacheTable tableCache = null; m_CacheTableDict.TryGetValue(msgId, out tableCache); if (tableCache != null) { tableCache.AddOrUpdate(key, foreignKey, dataMessage, cacheVersion); } else { InnerCacheTable newTableCache = new InnerCacheTable(); newTableCache.AddOrUpdate(key, foreignKey, dataMessage, cacheVersion); m_CacheTableDict.Add(msgId, newTableCache); } }
static public int constructor(IntPtr l) { try { GameFramework.KeyString o; o = new GameFramework.KeyString(); pushValue(l, true); pushValue(l, o); return(2); } catch (Exception e) { return(error(l, e)); } }
static public int set_Keys(IntPtr l) { try { GameFramework.KeyString self = (GameFramework.KeyString)checkSelf(l); List <System.String> v; checkType(l, 2, out v); self.Keys = v; pushValue(l, true); return(1); } catch (Exception e) { return(error(l, e)); } }
internal void LoadUser(ulong userGuid, string accountId, string nickname) { string key = userGuid.ToString(); Msg_LD_Load msg = new Msg_LD_Load(); msg.MsgId = (int)DataEnum.TableUserInfo; msg.PrimaryKeys.Add(key); Msg_LD_SingleLoadRequest reqUser = new Msg_LD_SingleLoadRequest(); reqUser.MsgId = (int)DataEnum.TableUserInfo; reqUser.LoadType = Msg_LD_SingleLoadRequest.LoadTypeEnum.LoadSingle; reqUser.Keys.Add(key); msg.LoadRequests.Add(reqUser); Msg_LD_SingleLoadRequest reqMember = new Msg_LD_SingleLoadRequest(); reqMember.MsgId = (int)DataEnum.TableMemberInfo; reqMember.LoadType = Msg_LD_SingleLoadRequest.LoadTypeEnum.LoadMulti; reqMember.Keys.Add(key); msg.LoadRequests.Add(reqMember); Msg_LD_SingleLoadRequest reqItem = new Msg_LD_SingleLoadRequest(); reqItem.MsgId = (int)DataEnum.TableItemInfo; reqItem.LoadType = Msg_LD_SingleLoadRequest.LoadTypeEnum.LoadMulti; reqItem.Keys.Add(key); msg.LoadRequests.Add(reqItem); Msg_LD_SingleLoadRequest reqFriend = new Msg_LD_SingleLoadRequest(); reqFriend.MsgId = (int)DataEnum.TableFriendInfo; reqFriend.LoadType = Msg_LD_SingleLoadRequest.LoadTypeEnum.LoadMulti; reqFriend.Keys.Add(key); msg.LoadRequests.Add(reqFriend); RequestLoad(msg, (ret) => { KeyString primaryKey = KeyString.Wrap(ret.PrimaryKeys); if (Msg_DL_LoadResult.ErrorNoEnum.Success == ret.ErrorNo) { LogSys.Log(LOG_TYPE.INFO, "DataCache Load Success: Msg:{0}, Key:{1}", "UserInfo", primaryKey); } else if (Msg_DL_LoadResult.ErrorNoEnum.NotFound == ret.ErrorNo) { LogSys.Log(LOG_TYPE.INFO, ConsoleColor.Yellow, "DataCache Load NotFound: Msg:{0}, Key:{1}", "UserInfo", primaryKey); } else { LogSys.Log(LOG_TYPE.ERROR, "DataCache Load Failed: Msg:{0}, Key:{1}, ERROR:{2}", "UserInfo", primaryKey, ret.ErrorInfo); } UserProcessScheduler dataProcessScheduler = UserServer.Instance.UserProcessScheduler; dataProcessScheduler.DefaultUserThread.QueueAction(dataProcessScheduler.LoadUserCallback, ret, accountId, nickname); }); }
//-------------------------------------------------------------------------------------------------------------------------- //供内部通过DispatchAction(调用的方法,实际执行线程是DataCacheThread。 //-------------------------------------------------------------------------------------------------------------------------- private void DSSaveInternal(Msg_LD_Save msg) { try { RequestSave(msg, (ret) => { KeyString primaryKey = KeyString.Wrap(msg.PrimaryKeys); if (ret.ErrorNo == Msg_DL_SaveResult.ErrorNoEnum.Success) { LogSys.Log(LOG_TYPE.INFO, "Save data success. MsgId:{0}, SerialNo:{1}, Key:{2}", msg.MsgId, msg.SerialNo, primaryKey); } else { LogSys.Log(LOG_TYPE.ERROR, "Save data failed. MsgId:{0}, SerialNo:{1}, Key:{2}, Error:{3}, ErrorInfo:{4}", msg.MsgId, msg.SerialNo, primaryKey, ret.ErrorNo, ret.ErrorInfo); } }); } catch (Exception e) { LogSys.Log(LOG_TYPE.ERROR, "DataCache Save ERROR:{0}, Stacktrace:{1}", e.Message, e.StackTrace); } }
internal void RequestLoad(Msg_LD_Load msg, MyAction <Msg_DL_LoadResult> callback) { msg.SerialNo = GenNextSerialNo(); KeyString key = KeyString.Wrap(msg.PrimaryKeys); ConcurrentDictionary <KeyString, LoadRequestInfo> dict = null; if (!m_LoadRequests.TryGetValue(msg.MsgId, out dict)) { dict = m_LoadRequests.AddOrUpdate(msg.MsgId, new ConcurrentDictionary <KeyString, LoadRequestInfo>(), (k, v) => v); } LoadRequestInfo info; if (!dict.TryGetValue(key, out info)) { info = dict.AddOrUpdate(key, m_LoadRequestPool.Alloc(), (k, v) => v); } info.m_LastSendTime = TimeUtility.GetLocalMilliseconds(); info.m_Request = msg; info.m_Callback = callback; m_DataStoreChannel.Send(msg); }
private static bool Equals(KeyString a, KeyString b) { bool ret = false; if (object.ReferenceEquals(a, b)) { ret = true; } else if (object.ReferenceEquals(a, null)) { ret = false; } else if (object.ReferenceEquals(b, null)) { ret = false; } else { int ct = a.m_Keys.Count; if (ct == b.m_Keys.Count) { ret = true; for (int ix = 0; ix < ct; ++ix) { if (a.m_Keys[ix] != b.m_Keys[ix]) { ret = false; break; } } } } return ret; }
public static bool IsNullOrEmpty(KeyString str) { return(str == null || str.m_Keys.Count == 0); }
/// <summary> /// 删除 /// </summary> /// <param name="key">主键</param> /// <returns>删除成功返回true,失败为false</returns> internal bool Remove(KeyString key) { KeyString foreignKey = null; m_PrimaryForeignDict.TryGetValue(key, out foreignKey); if (!KeyString.IsNullOrEmpty(foreignKey)) { HashSet<KeyString> priKeys = null; m_ForeignPrimaryDict.TryGetValue(foreignKey, out priKeys); if (priKeys != null) { priKeys.Remove(key); } m_ForeignPrimaryDict.Remove(foreignKey); } m_PrimaryForeignDict.Remove(key); return m_PrimaryDict.Remove(key); }
/// <summary> /// 外键查询 /// </summary> /// <param name="foreignKey">外键</param> /// <returns>外键所对应的数据值列表</returns> internal List<InnerCacheItem> FindByForeignKey(KeyString foreignKey) { List<InnerCacheItem> cacheItemList = new List<InnerCacheItem>(); HashSet<KeyString> associateKeys = null; m_ForeignPrimaryDict.TryGetValue(foreignKey, out associateKeys); if (associateKeys != null) { foreach (var key in associateKeys) { InnerCacheItem cacheItem = this.Find(key); if (cacheItem != null && cacheItem.Valid) { cacheItemList.Add(cacheItem); } } } return cacheItemList; }
/// <summary> /// 主键查询 /// </summary> /// <param name="key">主键</param> /// <returns>若查找到返回唯一对应数据值,否则返回null</returns> internal InnerCacheItem Find(KeyString key) { InnerCacheItem cacheItem = null; m_PrimaryDict.TryGetValue(key, out cacheItem); if (cacheItem != null && cacheItem.Valid) { return cacheItem; } else { return null; } }
private void OnTick() { long curTime = TimeUtility.GetLocalMilliseconds(); if (m_LastTickTime != 0) { long elapsedTickTime = curTime - m_LastTickTime; if (elapsedTickTime > c_WarningTickTime) { LogSys.Log(LOG_TYPE.MONITOR, "DataCacheThread Tick:{0}", elapsedTickTime); } } m_LastTickTime = curTime; if (m_LastLogTime + 60000 < curTime) { m_LastLogTime = curTime; DebugPoolCount((string msg) => { LogSys.Log(LOG_TYPE.INFO, "DataCacheThread.DispatchActionQueue {0}", msg); }); DebugActionCount((string msg) => { LogSys.Log(LOG_TYPE.MONITOR, "DataCacheThread.DispatchActionQueue {0}", msg); }); LogSys.Log(LOG_TYPE.MONITOR, "DataCacheThread.ThreadActionQueue Current Action {0}", m_Thread.CurActionNum); LogSys.Log(LOG_TYPE.MONITOR, "DataCacheThread Load Request Count {0} Save Request Count {1}", CalcLoadRequestCount(), CalcSaveRequestCount()); } if (UserServerConfig.DataStoreAvailable == true) { if (m_LastOperateTickTime + c_OperateTickInterval < curTime) { m_LastOperateTickTime = curTime; //Load操作 foreach (var pair in m_LoadRequests) { int msgId = pair.Key; ConcurrentDictionary <KeyString, LoadRequestInfo> dict = pair.Value; foreach (var reqPair in dict) { KeyString primaryKey = reqPair.Key; LoadRequestInfo req = reqPair.Value; if (req.m_LastSendTime + UserServerConfig.DSRequestTimeout < curTime) { m_WaitDeletedLoadRequests.Add(primaryKey, req.m_Request.SerialNo); Msg_DL_LoadResult result = new Msg_DL_LoadResult(); result.MsgId = msgId; result.PrimaryKeys.AddRange(primaryKey.Keys); result.SerialNo = req.m_Request.SerialNo; result.ErrorNo = Msg_DL_LoadResult.ErrorNoEnum.TimeoutError; result.ErrorInfo = "Timeout Error"; if (null != req.m_Callback) { DispatchAction(req.m_Callback, result); } } } foreach (var delPair in m_WaitDeletedLoadRequests) { LoadRequestInfo info; if (dict.TryRemove(delPair.Key, out info)) { if (info.m_Request.SerialNo == delPair.Value) { m_LoadRequestPool.Recycle(info); } else { dict.TryAdd(delPair.Key, info); } } } m_WaitDeletedLoadRequests.Clear(); } //Save操作 foreach (var pair in m_SaveRequestQueues) { int msgId = pair.Key; ConcurrentDictionary <KeyString, ConcurrentQueue <SaveRequestInfo> > dict = pair.Value; foreach (var reqPair in dict) { KeyString primaryKey = reqPair.Key; ConcurrentQueue <SaveRequestInfo> saveReqQueue = reqPair.Value; SaveRequestInfo req; if (saveReqQueue.TryPeek(out req)) { if (req.m_LastSendTime + UserServerConfig.DSRequestTimeout < curTime) { //超时,重新发送 LogSys.Log(LOG_TYPE.ERROR, "DataCacheThread. SaveRequest timeout. MsgId:{0}, PrimaryKey:{1}, SerialNo:{2}", msgId, KeyString.Wrap(req.m_Request.PrimaryKeys), req.m_Request.SerialNo); m_DataStoreChannel.Send(req.m_Request); req.m_LastSendTime = curTime; } } if (dict.Count > c_MaxRecordPerMessage && saveReqQueue.Count == 0) { m_WaitDeleteSaveRequests.Add(primaryKey); } } foreach (KeyString key in m_WaitDeleteSaveRequests) { lock (m_SaveRequestQueuesLock) { ConcurrentQueue <SaveRequestInfo> queue; if (dict.TryGetValue(key, out queue)) { if (queue.Count == 0) { ConcurrentQueue <SaveRequestInfo> dummy; dict.TryRemove(key, out dummy); } } } } m_WaitDeleteSaveRequests.Clear(); } } if (m_LastDSConnectTime + c_DSConnectInterval < curTime) { m_LastDSConnectTime = curTime; if (m_CurrentStatus != ConnectStatus.Connected) { ConnectDataStore(); } } } }
public static bool IsNullOrEmpty(KeyString str) { return str == null || str.m_Keys.Count == 0; }
// internal void GMLoadAccount(string gmAccount, string accountId, int nodeHandle) { Msg_LD_Load msg = new Msg_LD_Load(); msg.MsgId = (int)DataEnum.TableAccount; msg.PrimaryKeys.Add(accountId); Msg_LD_SingleLoadRequest reqAccount = new Msg_LD_SingleLoadRequest(); reqAccount.MsgId = (int)DataEnum.TableAccount; reqAccount.LoadType = Msg_LD_SingleLoadRequest.LoadTypeEnum.LoadSingle; reqAccount.Keys.Add(accountId); msg.LoadRequests.Add(reqAccount); RequestLoad(msg, (ret) => { JsonMessage resultMsg = new JsonMessage(LobbyGmMessageDefine.Msg_CL_GmQueryAccount, gmAccount); GameFrameworkMessage.Msg_LC_GmQueryAccount protoData = new GameFrameworkMessage.Msg_LC_GmQueryAccount(); protoData.m_Result = GameFrameworkMessage.GmResultEnum.Failed; protoData.m_QueryAccount = accountId; protoData.m_AccountState = GameFrameworkMessage.GmStateEnum.Offline; resultMsg.m_ProtoData = protoData; KeyString primaryKey = KeyString.Wrap(ret.PrimaryKeys); if (Msg_DL_LoadResult.ErrorNoEnum.Success == ret.ErrorNo) { LogSys.Log(LOG_TYPE.INFO, ConsoleColor.Green, "DataCache Load Success: Msg:{0}, Key:{1}", "GmAccount", primaryKey); TableAccount dataAccount = null; foreach (var result in ret.Results) { object _msg; if (DbDataSerializer.Decode(result.Data, DataEnum2Type.Query(result.MsgId), out _msg)) { DataEnum msgEnum = (DataEnum)result.MsgId; switch (msgEnum) { case DataEnum.TableAccount: dataAccount = _msg as TableAccount; break; default: LogSys.Log(LOG_TYPE.ERROR, ConsoleColor.Red, "Decode account data ERROR. Wrong message id. Account:{0}, WrongId:{1}", result.PrimaryKeys[0], msgEnum); break; } } } protoData.m_Result = GameFrameworkMessage.GmResultEnum.Success; protoData.m_QueryAccount = dataAccount.AccountId; protoData.m_AccountState = GameFrameworkMessage.GmStateEnum.Online; if (dataAccount.IsBanned) { protoData.m_AccountState = GameFrameworkMessage.GmStateEnum.Banned; } } else if (Msg_DL_LoadResult.ErrorNoEnum.NotFound == ret.ErrorNo) { LogSys.Log(LOG_TYPE.INFO, ConsoleColor.Yellow, "DataCache Load NotFound: Msg:{0}, Key:{1}", "GmAccount", primaryKey); } else { LogSys.Log(LOG_TYPE.ERROR, ConsoleColor.Red, "DataCache Load Failed: Msg:{0}, Key:{1}, ERROR:{2}", "GmAccount", primaryKey, ret.ErrorInfo); } resultMsg.m_ProtoData = protoData; JsonGmMessageDispatcher.SendNodeMessage(nodeHandle, resultMsg); }); }
/// <summary> /// 删除 /// </summary> /// <param name="msgId">数据类型ID</param> /// <param name="key">Key</param> /// <returns>删除成功返回true,失败返回false</returns> internal bool Remove(int msgId, KeyString key) { InnerCacheTable cacheTable = null; m_CacheTableDict.TryGetValue(msgId, out cacheTable); if (cacheTable != null) { return cacheTable.Remove(key); } return false; }
public static KeyString Wrap(List<string> strs) { KeyString obj = new KeyString(); obj.m_Keys = strs; return obj; }