filecacheprovider.cs

HeyCacher 高性能缓存方案(带源码) 1. 文件的所有权益归上传用户所有 2. 未经权益所有人同意不得将文件中的内容挪作商业或盈利用途 3. CSDN下载频道仅提供交流平台

            //整理本地过期策略
            List<ICacheItemExpiration> LocalExpirationsList = new List<ICacheItemExpiration>();
            foreach (ICacheItemExpiration tmpExpiration in ci.Expirations)
            {
                if (tmpExpiration is INetCacheItemExpiration)
                {
                    bool IsLocal = false;
                    foreach (string DependencyMark in ((INetCacheItemExpiration)tmpExpiration).AvailableIn())
                    {
                        if (DependencyMark == AppSetting.Mark)
                        {
                            IsLocal = true;
                            break;
                        }
                    }
                    if (IsLocal)
                    {
                        LocalExpirationsList.Add(tmpExpiration);
                    }
                }
                else if (tmpExpiration != null)
                {
                    LocalExpirationsList.Add(tmpExpiration);
                }
            }
            if (LocalExpirationsList.Count > 0)
            {
                LocalExpirations = new ICacheItemExpiration[LocalExpirationsList.Count];
                LocalExpirationsList.CopyTo(LocalExpirations);
            }

            //建立本地过期依赖项
            ExpirationItem expirationItem = null;
            lock (ExpirationItemTable.SyncRoot)
            {
                if (!ExpirationItemTable.Contains(ci.Key))
                {
                    expirationItem = new ExpirationItem(ci.Key, ci.Priority, ci.RefreshAction, LocalExpirations);
                    ExpirationItemTable[ci.Key] = expirationItem;
                }
                else
                {
                    expirationItem = (ExpirationItem)ExpirationItemTable[ci.Key];
                }
            }
        }
        #endregion

        #region Remove
        public override bool Remove(string Key, CacheTack cacheTack, CacheItemRemovedReason removalReason)
        {
            //声名
            CacheItem ResultCacheItem = null;
            ExpirationItem expirationItemBeforeLock = null;  //依赖项

            //检查是否有此缓存项
            if (Contains(Key, cacheTack))
            {
                ResultCacheItem = GetCacheItem(Key, cacheTack);
            }

            //独占锁
            bool LockFlag;
            do
            {
                lock (ExpirationItemTable.SyncRoot)
                {
                    if (!ExpirationItemTable.ContainsKey(Key))
                    {
                        break;
                    }
                    expirationItemBeforeLock = (ExpirationItem)ExpirationItemTable[Key];
                    LockFlag = Monitor.TryEnter(expirationItemBeforeLock);
                }
                if (!LockFlag)
                {
                    Thread.Sleep(0);
                }
            } while (!LockFlag);

            //操作
            if (expirationItemBeforeLock != null)
            {
                expirationItemBeforeLock.TouchedByUserAction(true);
                ExpirationItemTable.Remove(Key);
            }

            //释放锁
            if (expirationItemBeforeLock != null)
            {
                Monitor.Exit(expirationItemBeforeLock);
            }

            //缺少事件通知expirationItemBeforeLock，removalReason

            //实际删除
            if (ResultCacheItem != null)
            {
                if (realRemove(Key, cacheTack))
                {
                    return true;
                }
                else
                {
                    return false;
                }
            }
            else
            {
                return false;
            }
        }
        private bool realRemove(string Key, CacheTack cacheTack)
        {
            string filename = null;

            //取得缓存文件的存储路径
            if (cacheTack == null || String.IsNullOrEmpty(cacheTack.SavePath))
            {
                filename = BuildFileFullPath(GetMd5Key(Key));
            }
            else
            {
                filename = GetFullPath(cacheTack.SavePath);
            }

            //
            return DeleteFile(filename);
        }
        #endregion

        #region Flush
        public override void Flush()
        {
            ExpirationItemTable = Hashtable.Synchronized(new Hashtable());
            DeleteDirectory(m_RootPath);
        }
        #endregion

        internal override System.Collections.IDictionaryEnumerator CreateEnumerator()
        {
            throw new Exception("The method or operation is not implemented.");
        }

        #region helper
        /// <summary>
        /// 取md5后的key
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        private string GetMd5Key(string key)
        {
            string k = m_FileNameMark + key;
            MD5 md5 = MD5CryptoServiceProvider.Create();
            byte[] buf = md5.ComputeHash(System.Text.Encoding.UTF8.GetBytes(k));
            return BitConverter.ToString(buf).Replace("-", string.Empty);
        }

        /// <summary>
        /// 通过一个md5值生成一个完整的缓存文件保存路径
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        private string BuildFileFullPath(string md5Key)
        {
            StringBuilder fn = new StringBuilder(m_RootPath);
            if (m_RootPath[m_RootPath.Length - 1] != '\\') fn.Append("\\");
            for (int i = 0; i < m_PathDepth; i++)
            {
                fn.Append(md5Key.Substring(0, i + 1)).Append("\\");
            }
            fn.Append(md5Key + ".heycache");
            return fn.ToString();
        }
        /// <summary>
        /// 根据传入的相对路径，合成一个完整的缓存文件保存路径
        /// </summary>
        /// <param name="FilePath"></param>
        /// <returns></returns>
        private string GetFullPath(string FilePath)
        {
            //清除绝对路径
            System.Text.RegularExpressions.Regex regex = new System.Text.RegularExpressions.Regex("[A-Za-z]{1}:\\+?", System.Text.RegularExpressions.RegexOptions.Compiled);
            FilePath = regex.Replace(FilePath, "");

            //
            FilePath = FilePath.Replace("/", "\\");
            StringBuilder fn = new StringBuilder(m_RootPath);
            if (m_RootPath[m_RootPath.Length - 1] != '\\') fn.Append("\\");
            fn.Append(FilePath);
            return fn.ToString();
        }

        private byte[] ReadFile(string filename)
        {
            FileStream fs = new FileStream(filename, FileMode.Open, FileAccess.Read, FileShare.Read);
            byte[] buf = new byte[fs.Length];
            fs.Read(buf, 0, (int)fs.Length);
            fs.Close();
            return buf;
        }
        private bool WriteFile(string filename, byte[] Context)
        {
            if (!Cnlamar.IO.Directory.Exists(Path.GetDirectoryName(filename), true))
            {
                //错误，路径不对，无法建立
                return false;
            }

            bool lockWrite = false;
            do
            {
                try
                {
                    FileStream fs = new FileStream(filename, FileMode.Create, FileAccess.Write, FileShare.Read);
                    fs.Write(Context, 0, Context.Length);
                    fs.Close();
                    lockWrite = true;
                }
                catch (System.IO.IOException)
                {
                    System.Threading.Thread.Sleep(1);
                }
                catch (Exception ex)
                {
                    //错误，路径不对，无法建立
                    Caches.log.Error("写文件的时候发生了未知错误，路径为：" + filename, ex);
                    return false;
                }
            }
            while (!lockWrite);

            return true;
        }
        private bool DeleteFile(string filename)
        {
            if (!Cnlamar.IO.Directory.Exists(Path.GetDirectoryName(filename), false))
            {
                //错误，路径不对，无法建立
                Caches.log.Error("文件路径无法找到(自动创建目录已打开)，文件路径为：" + filename);
                return false;
            }

            bool lockWrite = false;
            do
            {
                try
                {
                    System.IO.File.Delete(filename);
                    lockWrite = true;
                }
                catch (System.IO.IOException)
                {
                    System.Threading.Thread.Sleep(1);
                }
                catch (Exception ex)
                {
                    //错误，路径不对，无法建立
                    Caches.log.Error("删除文件的时候发生了未知错误，路径为：" + filename, ex);
                    return false;
                }
            }
            while (!lockWrite);

            return true;
        }
        private bool DeleteDirectory(string directoryName)
        {
            if (!System.IO.Directory.Exists(directoryName))
            {
                return false;
            }

            bool lockWrite = false;
            string NewName = System.Guid.NewGuid().ToString();
            do
            {
                try
                {
                    System.IO.Directory.Move(directoryName, NewName);
                    System.IO.Directory.Delete(directoryName, true);
                    lockWrite = true;
                }
                catch (System.IO.IOException)
                {
                    System.Threading.Thread.Sleep(1);
                }
                catch (Exception ex)
                {
                    //错误，路径不对，无法建立
                    Caches.log.Error("删除目录的时候发生了未知错误，目录为：" + directoryName, ex);
                    return false;
                }
            }
            while (!lockWrite);

            return true;
        }
        #endregion
    }
}