补充ICache

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
namespace System
{

    /// <summary>
    /// 一个接口,表示缓存
    /// </summary>
    /// <typeparam name="TKey"></typeparam>
    /// <typeparam name="TValue"></typeparam>
    public interface ICache<TKey, TValue> : IEnumerable<KeyValuePair<TKey, TValue>>
    {
        /// <summary>
        /// 获取当前缓存的数量
        /// </summary>
        int Count { get; }

        IEnumerable<TKey> Keys { get; }

        /// <summary>
        /// 是否包含键
        /// </summary>
        bool ContainsKey(TKey key);

        /// <summary>
        /// 查询缓存
        /// </summary>
        /// <param name="key"></param>
        /// <param name="factory"></param>
        /// <returns></returns>
        TValue Get(TKey key, Func<TValue> factory);

        ///// <summary>
        ///// 查询缓存
        ///// </summary>
        ///// <param name="key"></param>
        ///// <returns></returns>
        //TValue Get(TKey key);

        /// <summary>
        /// 查询缓存
        /// </summary>
        /// <param name="key"></param>
        /// <param name="factory"></param>
        /// <returns></returns>
        Task<TValue> GetAsync(TKey key, Func<Task<TValue>> factory);

        ///// <summary>
        ///// 查询缓存
        ///// </summary>
        ///// <param name="key"></param>
        ///// <returns></returns>
        //Task<TValue> GetAsync(TKey key);

        /// <summary>
        /// 获取数据,没有返回默认值
        /// </summary>
        /// <param name="index"></param>
        /// <returns></returns>
        TValue this[TKey key] { get; set; }

        /// <summary>
        /// 清空缓存
        /// </summary>
        void Flush();

        /// <summary>
        /// 更新缓存
        /// </summary>
        /// <param name="key"></param>
        /// <param name="value"></param>
        /// <returns></returns>
        bool Update(TKey key, TValue value);

        /// <summary>
        /// 添加缓存
        /// </summary>
        /// <param name="key"></param>
        /// <param name="value"></param>
        /// <returns></returns>
        bool Add(TKey key, TValue value);

        /// <summary>
        /// 添加或更新缓存
        /// </summary>
        /// <param name="key"></param>
        /// <param name="value"></param>
        /// <returns></returns>
        void AddOrUpdate(TKey key, TValue value);

        /// <summary>
        /// 移除缓存
        /// </summary>
        /// <param name="key"></param>
        /// <param name="value"></param>
        /// <returns></returns>
        bool Remove(TKey key);

    }
}
using System.Collections;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;
using System.Linq;

namespace System
{

    internal class Cache<TKey, TValue> : ICache<TKey, TValue>
    {
        Dictionary<TKey, TValue> _map = new Dictionary<TKey, TValue>();
        ReaderWriterLockSlim _lock = new ReaderWriterLockSlim();

        SemaphoreSlim _asyncLock;

        SemaphoreSlim AsyncLock
        {
            get
            {
                if (_asyncLock == null)
                {
                    _asyncLock = new SemaphoreSlim(1, 1);
                }
                return _asyncLock;
            }
        }

        public int Count
        {
            get
            {
                return _map.Count;
            }
        }

        public IEnumerable<TKey> Keys
        {
            get
            {
                return _map.Keys;
            }
        }

        #region Get
        public TValue Get(TKey key, Func<TValue> factory)
        {
            // Check cache
            _lock.EnterReadLock();
            TValue val;
            try
            {
                if (_map.TryGetValue(key, out val))
                    return val;
            }
            finally
            {
                _lock.ExitReadLock();
            }

            // Cache it
            _lock.EnterWriteLock();
            try
            {
                // Check again
                if (_map.TryGetValue(key, out val))
                    return val;

                // Create it
                val = factory();

                // Store it
                _map.Add(key, val);

                // Done
                return val;
            }
            finally
            {
                _lock.ExitWriteLock();
            }
        }

        //public TValue Get(TKey key)
        //{
        //    // Check cache
        //    _lock.EnterReadLock();
        //    TValue val;
        //    try
        //    {
        //        _map.TryGetValue(key, out val);
        //        return val;
        //    }
        //    finally
        //    {
        //        _lock.ExitReadLock();
        //    }
        //}

        public async Task<TValue> GetAsync(TKey key, Func<Task<TValue>> factory)
        {
            // Check cache
            //_lock.EnterReadLock();
            await AsyncLock.WaitAsync(-1);
            TValue val;
            try
            {
                if (_map.TryGetValue(key, out val))
                    return val;
            }
            finally
            {
                AsyncLock.Release();
                //_lock.ExitReadLock();
            }

            // Cache it
            //_lock.EnterWriteLock();
            await AsyncLock.WaitAsync(-1);
            try
            {
                // Check again
                if (_map.TryGetValue(key, out val))
                    return val;

                // Create it
                val = await factory();

                // Store it
                _map.Add(key, val);

                // Done
                return val;
            }
            finally
            {
                //_lock.ExitWriteLock();
                AsyncLock.Release();
            }
        }

        //public async Task<TValue> GetAsync(TKey key)
        //{
        //    // Check cache
        //    //_lock.EnterReadLock();
        //    await AsyncLock.WaitAsync(-1);
        //    TValue val;
        //    try
        //    {
        //        _map.TryGetValue(key, out val);
        //        return val;
        //    }
        //    finally
        //    {
        //        AsyncLock.Release();
        //        //_lock.ExitReadLock();
        //    }

        //}

        #endregion

        /// <summary>
        /// 获取数据,没有返回默认值
        /// </summary>
        /// <param name="index"></param>
        /// <returns></returns>
        public TValue this[TKey key]
        {
            get
            {
                _lock.EnterReadLock();
                TValue val;
                try
                {
                    if (_map.TryGetValue(key, out val))
                        return val;
                }
                finally
                {
                    _lock.ExitReadLock();
                }
                return default(TValue);
            }
            set
            {
                AddOrUpdate(key, value);
            }
        }

        public bool Update(TKey key, TValue value)
        {
            _lock.EnterReadLock();
            TValue val;
            try
            {
                if (!_map.TryGetValue(key, out val))
                    return false;
                //val = value;
                _map[key] = value;
                return true;
            }
            finally
            {
                _lock.ExitReadLock();
            }
        }

        public bool Add(TKey key, TValue value)
        {
            _lock.EnterReadLock();
            TValue val;
            try
            {
                if (_map.TryGetValue(key, out val))
                    return false;
                _map.Add(key, value);
                return true;
            }
            finally
            {
                _lock.ExitReadLock();
            }
        }

        public void AddOrUpdate(TKey key, TValue value)
        {
            _lock.EnterReadLock();
            TValue val;
            try
            {
                if (_map.TryGetValue(key, out val))
                    // val = value;
                    _map[key] = value;
                else
                    _map.Add(key, value);
            }
            finally
            {
                _lock.ExitReadLock();
            }

        }

        public bool Remove(TKey key)
        {
            _lock.EnterReadLock();
            try
            {
                return _map.Remove(key);
            }
            finally
            {
                _lock.ExitReadLock();
            }
        }

        public void Flush()
        {
            // Cache it
            _lock.EnterWriteLock();
            try
            {
                _map.Clear();
            }
            finally
            {
                _lock.ExitWriteLock();
            }

        }

        public bool ContainsKey(TKey key)
        {
            _lock.EnterReadLock();
            TValue val;
            try
            {
                if (_map.TryGetValue(key, out val))
                    return true;
                return false;
            }
            finally
            {
                _lock.ExitReadLock();
            }
        }

        public IEnumerator<KeyValuePair<TKey, TValue>> GetEnumerator()
        {
            return _map.GetEnumerator();
        }

        IEnumerator IEnumerable.GetEnumerator()
        {
            return ((IEnumerable)_map).GetEnumerator();
        }
    }
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace System
{
    /// <summary>
    /// 缓存工厂
    /// </summary>
    public static class CacheFactory
    {

        internal static readonly List<Action> _actions;

        internal static readonly Timer _timer;

        static CacheFactory()
        {
            _expireTime = 60;
            _actions = new List<Action>();
            _timer = new Timer(o =>
            {
                var actions = o as IEnumerable<Action>;

                object lockObj = new object();

                lock (lockObj)
                {
                    foreach (var item in actions)
                    {
                        try
                        {
                            item();
                        }
                        catch
                        {
                        }
                    }
                }
            }, _actions, Timeout.Infinite, Timeout.Infinite);

            int time = 1000 * 60 * _expireTime;
            _timer.Change(time, time);
        }

        static int _expireTime;
        /// <summary>
        /// 获取或设置过期时间
        /// </summary>
        public static int ExpireTime
        {
            get { return _expireTime; }
            set
            {
                _expireTime = value;
                int time = 1000 * 60 * _expireTime;
                _timer.Change(time, time);
            }
        }

        /// <summary>
        /// 创建一个缓存
        /// </summary>
        /// <typeparam name="TKey"></typeparam>
        /// <typeparam name="TValue"></typeparam>
        /// <returns></returns>
        public static ICache<TKey, TValue> CreateCache<TKey, TValue>()
        {
            return new Cache<TKey, TValue>();
            //return ActivatorFactory.CreateInstance<ICache<TKey, TValue>>();
        }

        /// <summary>
        /// 创建一个过期缓存
        /// </summary>
        /// <typeparam name="TKey"></typeparam>
        /// <typeparam name="TValue"></typeparam>
        /// <returns></returns>
        public static IExpireCache<TKey, TValue> CreateExpireCache<TKey, TValue>()
        {
            return new ExpireCache<TKey, TValue>();
            //return ActivatorFactory.CreateInstance<IExpireCache<TKey, TValue>>();
        }

        /// <summary>
        /// 创建一个过期缓存
        /// </summary>
        /// <typeparam name="TKey"></typeparam>
        /// <typeparam name="TValue"></typeparam>
        /// <returns></returns>
        public static IExpireCache<TValue> CreateExpireCache<TValue>()
        {
            return new ExpireCache<TValue>();
            //return ActivatorFactory.CreateInstance<IExpireCache<TValue>>();
        }

    }
}
时间: 2024-10-13 09:50:20

补充ICache的相关文章

031医疗项目-模块三:药品供应商目录模块——sql补充知识

这个补充知识有一个点很有必要,视屏上的老师提出一点: 内链接关联查询: 如果表A和表B有一个外键关联 ,可以通过外键进行内链接查询 select dictinfo.*, dicttype.typename from dictinfo, dicttype where dictinfo.typecode = dicttype.typecode --不通过外键,通过groupid查询用户类型的代码结果集,只能查询出一条记录,可以使用内链接 select sysuser.*, dictinfo.info

WebView使用详解(三)——WebChromeClient与LoadData补充

前言: 我不会忘了我 忘了我曾说过一定会得到的梦想 --<老大>小柯 相关文章 1.<WebView使用详解(一)--Native与JS相互调用(附JadX反编译)> 2.<WebView使用详解(二)--WebViewClient与常用事件监听> 一.WebChromeClient 1.概述 (1). 与WebViewClient的区别 很多同学一看到这里有Chrome,立马就会想到google 的Chrome浏览器:这里并不是指Chrome浏览器的意思,而是泛指浏览

Nancy之基于Self Hosting的补充小Demo

前面把Hosting Nancy with ASP.NET.Self Hosting Nancy和Hosting Nancy with OWIN 以demo的形式简单描述了一下. 这篇是为Self Hosting Nancy.和Owin 下面的Self Hosting作个补充. 首先是Self Hosting Nancy的补充: 这里主要是介绍一下Topshelf 官网:http://topshelf-project.com/ GitHub地址:https://github.com/Topshe

UGC补充

成功案例 WIKI:最大也是最小的百科全书 WIKI指的是一种网上共同协作的超文本系统,可由多人共同对网站内容进行维护和更新,是典型的靠UGC运作的系统.其中,WIKI利用UGC概念,使网站的内容制作和编辑成本最小化,但是能够实现领域知识的积累和最大化. 用户可以通过网页浏览器对WIKI文本进行浏览.创建.更改,与其他超文本系统相比,WIKI有使用方便及开放的特点,所以WIKI系统可以帮助用户在一个社群内共同收集.创作某领域的知识,发布所有领域用户都关心和感兴趣的话题.WIKI使用了UGC概念,

jstl标签 core fmt fn函数使用参考(为第一篇的补充,更为实用)

JSTL标签 参考手册 前言 ========================================================================= JSTL标签库,是日常开发经常使用的,也是众多标签中性能最好的.把常用的内容,放在这里备份一份,随用随查.尽量做到不用查,就可以随手就可以写出来.这算是Java程序员的基本功吧,一定要扎实. JSTL全名为JavaServer Pages Standard Tag Library,目前最新的版本为1.1版.JSTL是由J

使用NHibernate(10) -- 补充(inverse &amp;&amp; cascade)

1,inverse属性的作用: 只有集合标记(set/map/list/array/bag)才有invers属性: 以set为例,set的inverse属性决定是否把对set的改动反应到数据库中去,inverse=false(反应),inverse=true(不反应):默认值是false; one-to-many 和many-to-many都适用: inverse等于false时,对于one-to-many,如果删除"一"方,NH会先执行Update语句来把"多"方

重修课程day7(python基础4之基础补充)

一 bit,和bytes的关系 bit:就是计算机的最小的表示单位. bytes:就是计算机的最小的储存单位. 1  字节(bytes) = 8 位(bit) 格式: print(bytes('字符',encoding='utf-8')) 文件默认读取文件 二 strip的其他功能 strip去掉两边的空格,换行符,制表符等等,还可以指定删除字符 a=' dsad ' print(a.strip()) b='\ndsfsadagh\t' print(b.strip()) print(123) c

Sass学习笔记(补充)

阅读目录 1. Sass和SCSS的区别 2. @while循环 3. @at-root 4. @content 5. 凸显注释 6. CSS输出样式 7. 重置浏览器样式 8. Sass调试和@debug命令.@warn命令 9. 使用Sass时的注意事项 相关链接:Sass学习笔记前篇 Sass关于颜色函数的乐趣 在Sass学习笔记前篇,记载了Sass安装.基本用法.编程语法,在这篇,将补充在前篇未记载的知识. 1. Sass和SCSS的区别 参考链接:http://sass.bootcss

软件工程第一次作业补充

软件工程第一次作业的补充 对于作业"在一周之内快速看完<构建之法>,列出你不懂的5-10个问题". 作业要求有: (1)在每个问题后面,请说明哪一章节的什么内容引起了你的提问,提供一些上下文 (2)列出一些事例或资料,支持你的提问 (3)说说你提问题的原因,你说因为自己的假设和书中的不同而提问,还是不懂书中的术语,还是对推理过程有疑问,还是书中的描述和你的经验(直接经验或间接经验)矛盾? 例如:我看了这一段文字 (引用文字),有这个问题 (提出问题):我查了资料,有这些说法