美文网首页
简易项目搭建(用于一般杂七杂八的小功能点)2

简易项目搭建(用于一般杂七杂八的小功能点)2

作者: HapplyFox | 来源:发表于2019-04-23 14:57 被阅读0次

    接着上文章的内容,在日志和json都简单封装的情况下
    我们开始对Models层进行封装
    Models主要存放数据库的上下文Orm和不同的实体类(PocoModel,ExtendModel)

    Models层

    上下文的操作,因为小型控制台项目,不会涉及大的业务分层,所以选取SqlSugar做为Orm 首选,它具有小巧,轻便,可以使用Lambda表达式进行CURD操作,和EntityFramework有异曲同工之妙,以前项目大多用EF来做,后来接触SqlSugar之后 ,感受到了它的方便,大多都转了过来

    SqlSugar 官网

    image.png

    接下来开始使用SqlSugar,使用其实是一件特点简单的事情 ,大家可以简单看一个官网的使用文档1,2,3。10分钟看完,然后就可以开始做项目了

    基于自己的使用习惯,我喜欢将与数据库相当的核心内容放在一起,基本的类如下

    config.cs 数据库参数配置
    DbFactory.cs 数据库实例化工厂
    HttpRuntimeCache.cs 为Sqlsugarclient提供缓存的接口实现

    config.cs

        public class Config
        {
            /// <summary>
            /// 数据库连接字符串(私有字段)
            /// </summary>
            private static readonly string _connectionString = ConfigurationManager.ConnectionStrings["SQLDbCon"].ConnectionString;
    
            /// <summary>
            /// 数据库连接字符串(公有属性)
            /// </summary>
            public static string ConnectionString
            {
                get { return _connectionString; }
            }
        }
    

    DbFactory.cs

        public class DbFactory
        {
            /// <summary>
            /// SqlSugarClient属性
            /// </summary>
            /// <returns></returns>
            public static SqlSugarClient GetSqlSugarClient()
            {
                var db = new SqlSugarClient(new ConnectionConfig()
                {
                    ConnectionString = Config.ConnectionString, 
                    DbType = DbType.SqlServer, 
                    IsAutoCloseConnection = true,
                    ConfigureExternalServices = new ConfigureExternalServices()
                    {
                        DataInfoCacheService = new HttpRuntimeCache()
                    },
                    IsShardSameThread = true 
                });
                return db;
            }
        }
    

    HttpRuntimeCache.cs

        public class HttpRuntimeCache : ICacheService
        {
            public void Add<V>(string key, V value)
            {
                HttpRuntimeCacheHelper<V>.GetInstance().Add(key, value);
            }
    
            public void Add<V>(string key, V value, int cacheDurationInSeconds)
            {
                HttpRuntimeCacheHelper<V>.GetInstance().Add(key, value, cacheDurationInSeconds);
            }
    
            public bool ContainsKey<V>(string key)
            {
                return HttpRuntimeCacheHelper<V>.GetInstance().ContainsKey(key);
            }
    
            public V Get<V>(string key)
            {
                return HttpRuntimeCacheHelper<V>.GetInstance().Get(key);
            }
    
            public IEnumerable<string> GetAllKey<V>()
            {
                return HttpRuntimeCacheHelper<V>.GetInstance().GetAllKey();
            }
    
            public V GetOrCreate<V>(string cacheKey, Func<V> create, int cacheDurationInSeconds = int.MaxValue)
            {
                var cacheManager = HttpRuntimeCacheHelper<V>.GetInstance();
                if (cacheManager.ContainsKey(cacheKey))
                {
                    return cacheManager[cacheKey];
                }
                else
                {
                    var result = create();
                    cacheManager.Add(cacheKey, result, cacheDurationInSeconds);
                    return result;
                }
            }
    
            public void Remove<V>(string key)
            {
                HttpRuntimeCacheHelper<V>.GetInstance().Remove(key);
            }
        }
    
        internal class HttpRuntimeCacheHelper<V>
        {
    
            #region 全局变量
            private static HttpRuntimeCacheHelper<V> _instance = null;
            private static readonly object _instanceLock = new object();
            #endregion
    
            #region 构造函数
    
            private HttpRuntimeCacheHelper() { }
            #endregion
    
            #region  属性
            /// <summary>         
            ///根据key获取value     
            /// </summary>         
            /// <value></value>      
            public V this[string key]
            {
                get { return (V)HttpRuntime.Cache[CreateKey(key)]; }
            }
            #endregion
    
            #region 公共函数
    
            /// <summary>         
            /// key是否存在       
            /// </summary>         
            /// <param name="key">key</param>         
            /// <returns> ///  存在<c>true</c> 不存在<c>false</c>.        /// /// </returns>         
            public bool ContainsKey(string key)
            {
                return HttpRuntime.Cache[CreateKey(key)] != null;
            }
    
            /// <summary>         
            /// 获取缓存值         
            /// </summary>         
            /// <param name="key">key</param>         
            /// <returns></returns>         
            public V Get(string key)
            {
                return (V)HttpRuntime.Cache.Get(CreateKey(key));
            }
    
            /// <summary>         
            /// 获取实例 (单例模式)       
            /// </summary>         
            /// <returns></returns>         
            public static HttpRuntimeCacheHelper<V> GetInstance()
            {
                if (_instance == null)
                    lock (_instanceLock)
                        if (_instance == null)
                            _instance = new HttpRuntimeCacheHelper<V>();
                return _instance;
            }
    
            /// <summary>         
            /// 插入缓存(默认20分钟)        
            /// </summary>         
            /// <param name="key"> key</param>         
            /// <param name="value">value</param>          
            public void Add(string key, V value)
            {
                Add(key, value, 60 * 20);
            }
    
            /// <summary>         
            /// 插入缓存        
            /// </summary>         
            /// <param name="key"> key</param>         
            /// <param name="value">value</param>         
            /// <param name="cacheDurationInSeconds">过期时间单位秒</param>         
            public void Add(string key, V value, int cacheDurationInSeconds)
            {
                Add(key, value, cacheDurationInSeconds, CacheItemPriority.Default);
            }
    
            /// <summary>         
            /// 插入缓存.         
            /// </summary>         
            /// <param name="key">key</param>         
            /// <param name="value">value</param>         
            /// <param name="cacheDurationInSeconds">过期时间单位秒</param>         
            /// <param name="priority">缓存项属性</param>         
            public void Add(string key, V value, int cacheDurationInSeconds, CacheItemPriority priority)
            {
                string keyString = CreateKey(key);
                HttpRuntime.Cache.Insert(keyString, value, null,
                DateTime.Now.AddSeconds(cacheDurationInSeconds), Cache.NoSlidingExpiration, priority, null);
            }
    
            /// <summary>         
            /// 插入缓存.         
            /// </summary>         
            /// <param name="key">key</param>         
            /// <param name="value">value</param>         
            /// <param name="cacheDurationInSeconds">过期时间单位秒</param>         
            /// <param name="priority">缓存项属性</param>         
            public void Add(string key, V value, int
             cacheDurationInSeconds, CacheDependency dependency, CacheItemPriority priority)
            {
                string keyString = CreateKey(key);
                HttpRuntime.Cache.Insert(keyString, value,
                 dependency, DateTime.Now.AddSeconds(cacheDurationInSeconds), Cache.NoSlidingExpiration, priority, null);
            }
    
            /// <summary>         
            /// 删除缓存         
            /// </summary>         
            /// <param name="key">key</param>         
            public void Remove(string key)
            {
                HttpRuntime.Cache.Remove(CreateKey(key));
            }
    
            /// <summary>
            /// 清除所有缓存
            /// </summary>
            public void RemoveAll()
            {
                System.Web.Caching.Cache cache = HttpRuntime.Cache;
                IDictionaryEnumerator CacheEnum = cache.GetEnumerator();
                ArrayList al = new ArrayList();
                while (CacheEnum.MoveNext())
                {
                    al.Add(CacheEnum.Key);
                }
                foreach (string key in al)
                {
                    cache.Remove(key);
                }
            }
    
            /// <summary>
            /// 清除所有包含关键字的缓存
            /// </summary>
            /// <param name="removeKey">关键字</param>
            public void RemoveAll(Func<string, bool> removeExpression)
            {
                System.Web.Caching.Cache _cache = HttpRuntime.Cache;
                var allKeyList = GetAllKey();
                var delKeyList = allKeyList.Where(removeExpression).ToList();
                foreach (var key in delKeyList)
                {
                    HttpRuntime.Cache.Remove(key); ;
                }
            }
    
            /// <summary>
            /// 获取所有缓存key
            /// </summary>
            /// <returns></returns>
            public IEnumerable<string> GetAllKey()
            {
                IDictionaryEnumerator CacheEnum = HttpRuntime.Cache.GetEnumerator();
                while (CacheEnum.MoveNext())
                {
                    yield return CacheEnum.Key.ToString();
                }
            }
            #endregion
    
            #region 私有函数
    
            /// <summary>         
            ///创建KEY   
            /// </summary>         
            /// <param name="key">Key</param>         
            /// <returns></returns>         
            private string CreateKey(string key)
            {
                return key;
            }
            #endregion
        }
    

    Models层完成

    相关文章

      网友评论

          本文标题:简易项目搭建(用于一般杂七杂八的小功能点)2

          本文链接:https://www.haomeiwen.com/subject/lkpvgqtx.html