#灵感/代码缓存

## SessionCache

``` cs
using System;
using System.Collections.Generic;
using HTFramework.Utility;
using Newtonsoft.Json;
using UnityEngine;

namespace DefaultNamespace
{
    
    [Serializable]
    public class SessionEventData
    {
        public string uuid;
        public string event_name;
        public long event_timestamp;
        public string public_properties;
        public Dictionary<string, object> event_properties;
    }
    
    [Serializable]
    public class EventData
    {
        public string uuid;
        public string event_name;
        public long event_timestamp;
        public string public_properties;
        public Dictionary<string, object> event_properties;
    }

    public enum Session_Name
    {
        start_end_session, //开始/结束会话
        default_session //普通会话
    }
    

    /// <summary>
    /// 消息事件 缓存器
    /// </summary>
    public class SessionCache : Singleton<SessionCache>
    {


        private Dictionary<string, Dictionary<string,object>> SessionDic;
        private string sessionCacheKey = "sessionCacheKey";
        private string _publicString = String.Empty;
        private int _deleteDay; //延迟几天删除

        public void OnInit(string publicString,int day)
        {
            // if (PlayerPrefs.HasKey(sessionCacheKey))
            // {
            //     PlayerPrefs.DeleteKey(sessionCacheKey);
            //     PlayerPrefs.Save();
            // }
            // return;

            _publicString = publicString;
            _deleteDay = day;

            InitData();

        }

        private void InitData()
        {

            if (PlayerPrefs.HasKey(sessionCacheKey))
            {
                SessionDic = JsonConvert.DeserializeObject<Dictionary<string,Dictionary<string,object>>>(PlayerPrefs.GetString(sessionCacheKey, ""));
            }
            else
            {
                SessionDic = new Dictionary<string, Dictionary<string,object>>();
            }
        }

        public void AddEvetData(Session_Name event_Name,object eventData)
        {
            switch (event_Name)
            {
                case Session_Name.start_end_session:
                    SessionEventData start_end_session  = eventData as SessionEventData;
                    start_end_session.public_properties = String.Empty;
                    if (!SessionDic.ContainsKey("start_end_session"))
                    {
                        Dictionary<string,object> start_sessionDic = new Dictionary<string, object>();
                        SessionDic.Add("start_end_session", start_sessionDic);
                    }
                    SessionDic["start_end_session"].Add(start_end_session.uuid,JsonConvert.SerializeObject(start_end_session));
                    break;
                case Session_Name.default_session:
                    EventData default_session = eventData as EventData;
                    default_session.public_properties = String.Empty;
                    if (!SessionDic.ContainsKey("default_session"))
                    {
                        Dictionary<string,object> default_sessionDic = new Dictionary<string, object>();
                        SessionDic.Add("default_session", default_sessionDic);
                    }
                    break;
            }
            PlayerPrefs.SetString(sessionCacheKey,JsonConvert.SerializeObject(SessionDic));
            PlayerPrefs.Save();
        }

        
        /// <summary>
        /// 移除特定缓存数据
        /// </summary>
        /// <param name="event_Name">对应缓存eventName名称</param>
        /// <param name="uuid"></param>
        public void RemoveEventData(string event_Name, string uuid)
        {
            if (SessionDic.ContainsKey(event_Name) && SessionDic[event_Name].ContainsKey(uuid))
            {
                SessionDic[event_Name].Remove(uuid);
            }
        }

        
        /// <summary>
        /// 清空缓存数据
        /// </summary>
        public void ClearEventData()
        {
            foreach (KeyValuePair<string,Dictionary<string,object>> keyValuePair in SessionDic)
            {
                keyValuePair.Value.Clear();
            }
            SessionDic.Clear();
            PlayerPrefs.DeleteKey(sessionCacheKey);
            PlayerPrefs.Save();
        }

        /// <summary>
        /// 发送缓存数据
        /// </summary>
        /// <returns></returns>
        public string CacheEvent()
        {
            List<object> SessionList = new List<object>();
            Dictionary<string, List<string>> _deleteDic = new Dictionary<string, List<string>>(); //过期需要清理的缓存数据
            
            foreach (KeyValuePair<string,Dictionary<string,object>> keyValuePair in SessionDic)
            {
                switch (keyValuePair.Key)
                {
                    case "start_end_session":
                        foreach (KeyValuePair<string,object> valuePair in keyValuePair.Value)
                        {
                            SessionEventData start_end_session_SessionEventData = JsonConvert.DeserializeObject<SessionEventData>(valuePair.Value.ToString());
                            start_end_session_SessionEventData.public_properties = _publicString;
                            if (GetDeleyTime(start_end_session_SessionEventData.event_timestamp))
                            {
                                if (!_deleteDic.ContainsKey(start_end_session_SessionEventData.event_name))
                                {
                                    List<string> uuidList = new List<string>();
                                    _deleteDic.Add(start_end_session_SessionEventData.event_name,uuidList);
                                }
            
                                _deleteDic[start_end_session_SessionEventData.event_name].Add(start_end_session_SessionEventData.uuid);
                            }
                            SessionList.Add(start_end_session_SessionEventData);
                        }
                        break;
                    case "default_session":
                        foreach (KeyValuePair<string,object> valuePair in keyValuePair.Value)
                        {
                            EventData default_session_SessionEventData = JsonConvert.DeserializeObject<EventData>(valuePair.Value.ToString());
                            default_session_SessionEventData.public_properties = _publicString;
                            if (GetDeleyTime(default_session_SessionEventData.event_timestamp))
                            {
                                if (!_deleteDic.ContainsKey(default_session_SessionEventData.event_name))
                                {
                                    List<string> uuidList = new List<string>();
                                    _deleteDic.Add(default_session_SessionEventData.event_name,uuidList);
                                }
            
                                _deleteDic[default_session_SessionEventData.event_name].Add(default_session_SessionEventData.uuid);
                            }
                            SessionList.Add(default_session_SessionEventData);
                        }
                        break;
                }
            }
            
            foreach (KeyValuePair<string,List<string>> keyValuePair in _deleteDic)
            {
                for (int i = 0; i < keyValuePair.Value.Count; i++)
                {
                    SessionDic[keyValuePair.Key].Remove(keyValuePair.Value[i]);
                }
            }
            
            
            if (SessionList.Count <= 0)
            {
                return  String.Empty;
            }
            return JsonConvert.SerializeObject(SessionList);
        }
        

        private bool GetDeleyTime(long t)
        {
            double time = (DateTime.Now.ToUniversalTime().Ticks - 621355968000000000) / 10000000 - t;
            if (Math.Floor(time / 86400) > _deleteDay)
            {
                return true;
            }

            return false;
        }

    }
}
```

## SessionMgr

``` cs
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using DefaultNamespace;
using HTFramework.Utility;
using UnityEngine;
using Newtonsoft.Json;
using UnityEngine.Networking;

namespace CGBU_SDK
{

    /// <summary>
    /// 会话时间管理类
    /// </summary>
    public class SessionMgr : MonoSingleton<SessionMgr>
    {
        // private const string appId = "3f99e16c541a";
        // private const string reportUrl = "https://global-receiver-ias.icongamesg.com/report/?appid=" + appId;
        
        private const string StartSession = "start_session";
        private const string EndSession = "end_session";
        // private const string sessionCachePrefsKey = "sessionCachePrefsKey";

        private const string ReSendUrl = "&batch=1";
        
        private string _sessionId;
        private string _publicString;
        private long  _startEventTimestamp;
        private long _endEventTimestamp;
        private Dictionary<string, object> _eventDic;
        private Dictionary<string, object> _userDataDic;

        private string _uid = String.Empty;
        private string _uuid = String.Empty;


        #region 生命周期
        
        private void Awake()
        {
            _uid = SystemInfo.deviceUniqueIdentifier;
        }
        

        private void OnDestroy()
        {
            StopNetworkRequest();
        }

        /// <summary>
        /// 切后台 暂停游戏
        /// </summary>
        /// <param name="pauseStatus"></param>
        private void OnApplicationPause(bool pauseStatus)
        {
            if (pauseStatus)
            {
                SendEndSessionEvent();
            }
            else
            {
                CacheEvent(0);
            }
        }
        

        /// <summary>
        /// 退出游戏
        /// </summary>
        private void OnApplicationQuit()
        {
            AddToList(CreateEndEvent());
        }

        private SessionEventData CreateEndEvent()
        {
            _endEventTimestamp = (DateTime.Now.ToUniversalTime().Ticks - 621355968000000000) / 10000000;
            SessionEventData _sessionEndEventData = new SessionEventData
            {
                uuid =  _uuid,
                event_name = EndSession,
                event_timestamp = _endEventTimestamp,
                public_properties = _publicString,
                event_properties = _eventDic
            };

            _sessionEndEventData.event_name = EndSession;
            _sessionEndEventData.event_timestamp = _endEventTimestamp;
            
            _sessionEndEventData.event_properties["session_dur"] = _endEventTimestamp - _startEventTimestamp;
            _sessionEndEventData.event_properties["user_properties"] = _userDataDic;
            return _sessionEndEventData;
        }
        

        #endregion

        #region 会话收发&业务逻辑

        /// <summary>
        /// 发送结束会话事件
        /// </summary>
        private void SendEndSessionEvent()
        {
            SessionEventData endData = CreateEndEvent();
            ReportEvent(JsonConvert.SerializeObject(endData),false,0,endData);
        }


        /// <summary>
        /// 初始化 发送开始会话事件
        /// </summary>
        /// <param name="wake"></param>
        /// <param name="publicString"></param>
        /// <param name="uid"></param>
        /// <param name="eventDataDic"></param>
        /// <param name="userDataDic"></param>
        public void OnInit(bool wake,string publicString,string uid = null,Dictionary<string,object> eventDataDic = null,Dictionary<string,object> userDataDic = null)
        {

            // if (PlayerPrefs.HasKey(sessionCachePrefsKey))
            // {
            //     PlayerPrefs.DeleteKey(sessionCachePrefsKey);
            //     PlayerPrefs.Save();
            // }
            // return;
            
            if (!wake)
            {
                Destroy(gameObject);
                return;
            }
            
            SessionCache.Instance.OnInit("",7);
            
            _uid = uid != null ? uid : _uid;
            _publicString = publicString;
            _startEventTimestamp = (DateTime.Now.ToUniversalTime().Ticks - 621355968000000000) / 10000000;
            // _sessionId = _uid + _startEventTimestamp + GenerateRandomString(10);
            _sessionId = DateTime.Now.ToUniversalTime().Ticks.ToString();

            _uuid = Guid.NewGuid() + "-" + DateTime.Now.ToUniversalTime().Ticks;

            _userDataDic = new Dictionary<string, object>();
            _eventDic = new Dictionary<string, object>
            {
                ["session_id"] = _sessionId,
                ["session_dur"] = 0,
                ["user_properties"] = _userDataDic
                
            };
            
            SessionEventData _sessionStartEventData = new SessionEventData
            {
                uuid =  _uuid,
                event_name = StartSession,
                event_timestamp = _startEventTimestamp,
                public_properties = _publicString,
                event_properties = _eventDic
            };
            
            ChangeEventDataDic(eventDataDic);
            ChangeUserDataDic(userDataDic);
            ReportEvent(JsonConvert.SerializeObject(_sessionStartEventData), false, 0, _sessionStartEventData);
        }

        
        /// <summary>
        /// 修改事件数据
        /// </summary>
        /// <param name="eventDataDic"></param>
        public void ChangeEventDataDic(Dictionary<string, object> eventDataDic)
        {
            if (eventDataDic != null)
            {
                Dictionary<string, object> mergedDict = _eventDic.Union(eventDataDic.Where(kvp => !_eventDic.ContainsKey(kvp.Key)))
                    .ToDictionary(pair => pair.Key, pair => pair.Value);
                _eventDic = mergedDict;
            }
        }

        /// <summary>
        /// 修改用户数据
        /// </summary>
        /// <param name="userDataDic"></param>
        public void ChangeUserDataDic(Dictionary<string,object> userDataDic)
        {
            _userDataDic = userDataDic == null ? _userDataDic : userDataDic;
        }
        
        private void ReportEvent(string eventDataStr,bool isReSend = false,int reSendCount = 0,SessionEventData eventData = null)
        {
            if (eventData != null)
            {
                AddToList(eventData);
            }
            StartNetworkRequest(Instance.SendSessionEvent(eventDataStr,isReSend,reSendCount,eventData));
        }
        
        private IEnumerator SendSessionEvent(string eventDataStr,bool isReSend = false,int reSendCount = 0,SessionEventData eventData = null)
        {
            string AnalyseAppId = isReSend == false ? "8d482dec8f6d" : "8d482dec8f6d" + ReSendUrl;
            // 发送POST请求
            using (UnityWebRequest www = new UnityWebRequest("https://7b6zvje56lpbtmjuzwulj36qoi0hikbc.lambda-url.us-east-1.on.aws?appid=" + AnalyseAppId, "POST"))
            {
                byte[] bodyRaw = System.Text.Encoding.UTF8.GetBytes(eventDataStr);
                www.uploadHandler = new UploadHandlerRaw(bodyRaw);
                www.downloadHandler = new DownloadHandlerBuffer();
                www.SetRequestHeader("Content-Type", "application/json");
                yield return www.SendWebRequest();


                // 检查是否有错误发生
                if (www.result != UnityWebRequest.Result.Success)
                {
                    // Debug.Log("Error: " + www.error);
                }
                else
                {
                    // 获取服务器响应的文本内容
                    // string responseText = www.downloadHandler.text;
                
                    // 输出服务器响应内容
                    // Debug.Log("Server Response: " + responseText);
                    

                    if (isReSend) //如果是批量重发，就清空缓存器
                    {
                        SessionCache.Instance.ClearEventData();
                    }
                    else //如果不是重发，说明第一次就发送成功了,检测是否在缓存中，如果存在于缓存中，删除即可
                    {
                        if (eventData != null)
                        {
                            SessionCache.Instance.RemoveEventData(eventData.event_name,eventData.uuid);
                        }
                    }
                }

                if (www.isNetworkError || www.isHttpError)
                {
                    // Debug.LogError("Error: " + www.error);
                }
                CacheEvent(reSendCount);
            }
        }
        
        private void CacheEvent(int reSendCount = 0)
        {
            if (reSendCount >= 1) //只重发一次
            {
                return;
            }

            string ListStr = SessionCache.Instance.CacheEvent();
            
            if (ListStr != String.Empty)
            {
                reSendCount += 1;
                ReportEvent(ListStr,true,reSendCount);
            }
        }

        private void AddToList(SessionEventData sessionEventData)
        {
            SessionCache.Instance.AddEvetData(Session_Name.start_end_session,sessionEventData);
        }
        

        #endregion
        

        #region 协程处理

        private Coroutine networkCoroutine;

        private void StartNetworkRequest(IEnumerator coroutine)
        {
            if (networkCoroutine == null) //检查是否已有协程在运行
            {
                networkCoroutine = StartCoroutine(coroutine);
            }
            else
            {
                StopCoroutine(networkCoroutine);
                networkCoroutine = StartCoroutine(coroutine);
            }
        }
        
        private void StopNetworkRequest()
        {
            if (networkCoroutine != null)
            {
                StopCoroutine(networkCoroutine);
                networkCoroutine = null;
            }
        }

        #endregion

    }
}
```