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);
}
}
}
}