【C#】缓存数据

namespace WpfCopy.Controls
{
    public class CacheFileEventArgs : EventArgs
    {
        public bool IsFaulted { get; private set; }
        public CacheFileModel CacheFile { get; private set; }


        public CacheFileEventArgs(CacheFileModel cacheFile)
        {
            CacheFile = cacheFile;
            IsFaulted = false;
        }

        public CacheFileEventArgs()
        {
            IsFaulted = true;
        }

    }


    public class CacheFileModel
    {
        public string RemoteFile { get; set; }
        public string LocalFile { get; set; }

        public DateTime CreateTime { get; set; }
        public DateTime LastUseTime { get; set; }
    }

    class FileCacheMgr
    {
        private const string CacheDir = "CacheFile";

        private const string CacheDataFile = "file.cache";

        /// <summary>
        /// 缓存数据文件的读写锁
        /// </summary>
        readonly object _cacheDataFileLock = new object();

        /// <summary>
        /// 管理缓存数据的锁
        /// </summary>
        readonly object _cacheLock = new object();

        /// <summary>
        /// 缓存数据任务的锁
        /// </summary>
        readonly object _cacheTaskLock = new object();

        /// <summary>
        /// 缓存数据字典
        /// </summary>
        Dictionary<string, CacheFileModel> _cacheDict = new Dictionary<string, CacheFileModel>();

        /// <summary>
        /// 下载任务字典
        /// </summary>
        readonly Dictionary<string, WeakDelegateCollection<CacheFileEventArgs>> _cacheTaskDict = new Dictionary<string, WeakDelegateCollection<CacheFileEventArgs>>();

        private static readonly FileCacheMgr instance = new FileCacheMgr();
        public static FileCacheMgr Instance { get { return instance; } }

        public FileCacheMgr()
        {

        }

        /// <summary>
        /// 读取缓存
        /// </summary>
        void LoadCacheData()
        {
            lock (_cacheDataFileLock)
            {
                if (!File.Exists(CacheDataFile) && Directory.Exists(CacheDir))
                    Directory.Delete(CacheDir, true);
                var xs = new XmlSerializer(typeof(List<CacheFileModel>));
                using (Stream stream = new FileStream(CacheDataFile, FileMode.Open, FileAccess.Read))
                {
                    var list = xs.Deserialize(stream) as List<CacheFileModel> ?? new List<CacheFileModel>();

                    _cacheDict = list.ToDictionary(m => m.RemoteFile);
                }
            }
        }
        /// <summary>
        /// 保存缓存
        /// </summary>
        void SaveCacheData()
        {
            lock (_cacheDataFileLock)
            {
                try
                {
                    var xs = new XmlSerializer(typeof(List<CacheFileModel>));
                    using (Stream stream = new FileStream(CacheDataFile, FileMode.Create, FileAccess.Write))
                    {
                        xs.Serialize(stream, _cacheDict.Values.ToList<CacheFileModel>());
                    }
                }
                catch (Exception)
                {
                    File.Delete(CacheDataFile);
                }
            }
        }
        /// <summary>
        /// 清除过期缓存
        /// </summary>
        public void ClearExpireCache()
        {
            try
            {
                List<string> clearList = new List<string>();

                foreach (var item in _cacheDict)
                {
                    if (DateTime.Now - item.Value.LastUseTime > TimeSpan.FromDays(7))
                        clearList.Add(item.Key);
                }

                foreach (var item in clearList)
                {
                    File.Delete(_cacheDict[item].LocalFile);
                    _cacheDict.Remove(item);
                }

                SaveCacheData();
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
        /// <summary>
        /// 添加缓存数据
        /// </summary>
        /// <param name="model"></param>
        public void AddCacheData(CacheFileModel model)
        {
            if (model == null)
                throw new ArgumentException("model");

            lock (_cacheLock)
            {
                if (_cacheDict.ContainsKey(model.RemoteFile) == false)
                {
                    _cacheDict.Add(model.RemoteFile, model);
                    SaveCacheData();
                }
            }
        }
        /// <summary>
        /// 删除缓存文件--
        /// </summary>
        /// <param name="model"></param>
        public void RemoveCacheData(CacheFileModel model)
        {
            if (model == null)
                throw new ArgumentException("model");

            if (File.Exists(model.LocalFile))
                File.Delete(model.LocalFile);

            if (_cacheDict.ContainsKey(model.RemoteFile))
            {
                _cacheDict.Remove(model.RemoteFile);
                SaveCacheData();
            }
        }

        /// <summary>
        /// 获取缓存数据，如果不存在，则创建下载任务
        /// </summary>
        /// <param name="remoteFile"></param>
        /// <param name="callback"></param>
        /// <param name="getFtpFunc"></param>
        void GetCacheFile(string remoteFile, EventHandler<CacheFileEventArgs> callback, Func<MyFtp> getFtpFunc)
        {

            if (_cacheDict.ContainsKey(remoteFile))
            {
                CacheFileModel cache = _cacheDict[remoteFile];
                if (File.Exists(cache.LocalFile))
                {
                    cache.LastUseTime = DateTime.Now;
                    SaveCacheData();

                    if (callback != null)
                    {
                        callback(this, new CacheFileEventArgs(cache));
                    }
                    return;
                }
                else
                {
                    _cacheDict.Remove(remoteFile);
                }
            }

            CreateDownLoadTask(remoteFile, getFtpFunc(), callback);
        }

        void CreateDownLoadTask(string remoteFile, MyFtp myFtp, EventHandler<CacheFileEventArgs> callBack)
        {
            lock (_cacheTaskLock)
            {
                bool exist = _cacheTaskDict.ContainsKey(remoteFile);
                AddCallBackToDictNoLock(remoteFile, callBack);
                if (exist == false)
                {
                    Task.Factory.StartNew(() =>
                    {
                        DownloadFileWork(remoteFile, myFtp, callBack);
                    }, TaskCreationOptions.PreferFairness);
                }
            }
        }

        void DownloadFileWork(string remoteFile, MyFtp myFtp, EventHandler<CacheFileEventArgs> callback)
        {
            string localFile = Path.Combine(CacheDir, Guid.NewGuid().ToString() + Path.GetExtension(remoteFile));

            string path = Path.GetDirectoryName(localFile);

            if (Directory.Exists(path) == false)
            {
                Directory.CreateDirectory(path);
            }
            var eventArgs = new CacheFileEventArgs();
            try
            {
                bool dlRet = myFtp.DownLoad(remoteFile, localFile);
                if (dlRet && File.Exists(localFile))
                {
                    var cacheModel = new CacheFileModel()
                    {
                        RemoteFile = remoteFile,
                        LocalFile = localFile
                    };
                    eventArgs = new CacheFileEventArgs(cacheModel);
                    AddCacheData(cacheModel);
                }
            }
            finally
            {
                try
                {
                    InvokeCallBack(remoteFile, eventArgs);
                }
                finally
                {
                    RemoveCallBack(remoteFile);
                }
            }
        }

        void AddCallBackToDictNoLock(string remoteFile, EventHandler<CacheFileEventArgs> callback)
        {
            if (_cacheTaskDict.ContainsKey(remoteFile) == false)
                _cacheTaskDict.Add(remoteFile, new WeakDelegateCollection<CacheFileEventArgs>());

            var weakEvent = _cacheTaskDict[remoteFile];
            weakEvent.WeakEvent += callback;
        }

        void RemoveCallBack(string remoteFile)
        {
            lock (_cacheTaskLock)
            {
                if (_cacheTaskDict.ContainsKey(remoteFile))
                    _cacheTaskDict.Remove(remoteFile);
            }
        }

        void InvokeCallBack(string remoteFile, CacheFileEventArgs args)
        {
            lock (_cacheTaskLock)
            {
                if (_cacheTaskDict.ContainsKey(remoteFile) == false)
                {
                    return;
                }

                _cacheTaskDict[remoteFile].Invoke(this, args);
            }
        }

    }
}