Asp.Net Core 2.0 項目實戰（8）Core下緩存操作、序列化操作、JSON操作等Helper集合類

本文轉載自查看原文 2018-04-12 12:51 3167 JsonHelper/ XmlHelper/ Asp.Net Core 2.0 項目實戰/ NET環境/ 緩存Helper

Asp.Net Core 2.0 項目實戰（1） NCMVC開源下載了

Asp.Net Core 2.0 項目實戰（2）NCMVC一個基於Net Core2.0搭建的角色權限管理開發框架

Asp.Net Core 2.0 項目實戰（3）NCMVC角色權限管理前端UI預覽及下載

Asp.Net Core 2.0 項目實戰（4）ADO.NET操作數據庫封裝、 EF Core操作及實例

Asp.Net Core 2.0 項目實戰（5）Memcached踩坑，基於EnyimMemcachedCore整理MemcachedHelper幫助類。

Asp.Net Core 2.0 項目實戰（6）Redis配置、封裝幫助類RedisHelper及使用實例

Asp.Net Core 2.0 項目實戰（7）MD5加密、AES&DES對稱加解密

Asp.Net Core 2.0 項目實戰（8）Core下緩存操作、序列化操作、JSON操作等Helper集合類

Asp.Net Core 2.0 項目實戰（9）日志記錄，基於Nlog或Microsoft.Extensions.Logging的實現及調用實例

Asp.Net Core 2.0 項目實戰（10）基於cookie登錄授權認證並實現前台會員、后台管理員同時登錄

Asp.Net Core 2.0 項目實戰（11）基於OnActionExecuting全局過濾器，頁面操作權限過濾控制到按鈕級

本文目錄

1. 前沿
2.CacheHelper基於Microsoft.Extensions.Caching.Memory封裝
3.XmlHelper快速操作xml文檔
4.SerializationHelper文件序列化操作
5.JsonHelper基於Newtonsoft.Json封裝
6.ByteConvertHelper byte轉換操作類
7. 總結

1. 前沿

　　Net Core2.0以前緩存操作、XML操作文檔、處理JSON、序列化等都整理過相關幫助類，方便項目全局開發調用，但這些Helper在Net Core下面需要做調整才能使用，下面是我開發過程中整理的幾個幫助類，可單獨使用，僅供參考。

2. CacheHelper基於Microsoft.Extensions.Caching.Memory封裝

　　在net core2.0下System.Web.Caching不在提供支持，取而代之的是Microsoft.Extensions.Caching.Memory，現在就基於新的類庫做擴展封裝。注意：netcore2.0文件依賴緩存好像沒有擴展，修改文件信息后緩存自動更新功能暫未整合。

using System;
//using System.Web.Caching;//netcore2.0不再提供支持

using Microsoft.Extensions.Caching.Memory;
namespace NC.Common
{
    /// <summary>
    /// 為當前 HTTP 請求獲取 Cache 對象。
    /// </summary>
    public class CacheHelper
    {
        static MemoryCache cache = new MemoryCache(new MemoryCacheOptions());
        /// <summary>
        /// 創建緩存項的文件
        /// </summary>
        /// <param name="key">緩存Key</param>
        /// <param name="obj">object對象</param>
        public static void Set(string key, object value)
        {
            if (key != null)
            {
                cache.Set(key, value);
            }
        }
        /// <summary>
        /// 創建緩存項過期
        /// </summary>
        /// <param name="key">緩存Key</param>
        /// <param name="obj">object對象</param>
        /// <param name="expires">過期時間(秒)</param>
        public static void Set(string key, object value, int expires)
        {
            if (key != null)
            {
                cache.Set(key, value, new MemoryCacheEntryOptions()
                    //設置緩存時間，如果被訪問重置緩存時間。設置相對過期時間x秒
                    .SetSlidingExpiration(TimeSpan.FromSeconds(expires)));
            }
        }
        //dotnetcore2.0 文件依賴緩存好像沒有，暫未找到。
        ///// <summary>
        ///// 創建緩存項的文件依賴
        ///// </summary>
        ///// <param name="key">緩存Key</param>
        ///// <param name="obj">object對象</param>
        ///// <param name="fileName">文件絕對路徑</param>
        //public static void Set(string key, object obj, string fileName)
        //{
        //    //創建緩存依賴項
        //    CacheDependency dep = new CacheDependency(fileName);
        //    //創建緩存
        //    HttpContext.Current.Cache.Insert(key, obj, dep);
        //}

        /// <summary>
        /// 獲取緩存對象
        /// </summary>
        /// <param name="key">緩存Key</param>
        /// <returns>object對象</returns>
        public static object Get(string key)
        {
            object val = null;
            if (key != null && cache.TryGetValue(key, out val))
            {

                return val;
            }
            else
            {
                return default(object);
            }
        }

        /// <summary>
        /// 獲取緩存對象
        /// </summary>
        /// <typeparam name="T">T對象</typeparam>
        /// <param name="key">緩存Key</param>
        /// <returns></returns>
        public static T Get<T>(string key)
        {
            object obj = Get(key);
            return obj == null ? default(T) : (T)obj;
        }


        /// <summary>
        /// 移除緩存項的文件
        /// </summary>
        /// <param name="key">緩存Key</param>
        public static void Remove(string key)
        {
            cache.Remove(key);
        }

    }
}

3. XmlHelper快速操作xml文檔

　　這里封裝常見的對xml的操作和讀取方法，追加節點，刪除節點操作處理方法。配合序列化Hepler類處理。Core項目中實際使用過程中現僅用到SerializationHelper，里面序列化了xml並操作。由於xmlhelper做好了分享出來。

using System;
using System.Collections.Generic;
using System.Text;
using System.Xml;

namespace NC.Common
{
    public class XmlHelper
    {
        #region --增、刪、改操作--

        /// <summary>
        /// 追加節點
        /// </summary>
        /// <param name="filePath">XML文檔絕對路徑</param>
        /// <param name="xPath">范例: @"Skill/First/SkillItem"</param>
        /// <param name="xmlNode">XmlNode節點</param>
        /// <returns></returns>
        public static bool AppendChild(string filePath, string xPath, XmlNode xmlNode)
        {
            try
            {
                XmlDocument doc = new XmlDocument();
                doc.Load(filePath);
                XmlNode xn = doc.SelectSingleNode(xPath);
                XmlNode n = doc.ImportNode(xmlNode, true);
                xn.AppendChild(n);
                doc.Save(filePath);
                return true;
            }
            catch
            {
                return false;
            }
        }

        /// <summary>
        /// 從XML文檔中讀取節點追加到另一個XML文檔中
        /// </summary>
        /// <param name="filePath">需要讀取的XML文檔絕對路徑</param>
        /// <param name="xPath">范例: @"Skill/First/SkillItem"</param>
        /// <param name="toFilePath">被追加節點的XML文檔絕對路徑</param>
        /// <param name="toXPath">范例: @"Skill/First/SkillItem"</param>
        /// <returns></returns>
        public static bool AppendChild(string filePath, string xPath, string toFilePath, string toXPath)
        {
            try
            {
                XmlDocument doc = new XmlDocument();
                doc.Load(toFilePath);
                XmlNode xn = doc.SelectSingleNode(toXPath);

                XmlNodeList xnList = ReadNodes(filePath, xPath);
                if (xnList != null)
                {
                    foreach (XmlElement xe in xnList)
                    {
                        XmlNode n = doc.ImportNode(xe, true);
                        xn.AppendChild(n);
                    }
                    doc.Save(toFilePath);
                }
                return true;
            }
            catch
            {
                return false;
            }
        }

        /// <summary>
        /// 修改節點的InnerText的值
        /// </summary>
        /// <param name="filePath">XML文件絕對路徑</param>
        /// <param name="xPath">范例: @"Skill/First/SkillItem"</param>
        /// <param name="value">節點的值</param>
        /// <returns></returns>
        public static bool UpdateNodeInnerText(string filePath, string xPath, string value)
        {
            try
            {
                XmlDocument doc = new XmlDocument();
                doc.Load(filePath);
                XmlNode xn = doc.SelectSingleNode(xPath);
                XmlElement xe = (XmlElement)xn;
                xe.InnerText = value;
                doc.Save(filePath);
            }
            catch
            {
                return false;
            }
            return true;
        }

        /// <summary>
        /// 讀取XML文檔
        /// </summary>
        /// <param name="filePath">XML文件絕對路徑</param>
        /// <returns></returns>
        public static XmlDocument LoadXmlDoc(string filePath)
        {
            try
            {
                XmlDocument doc = new XmlDocument();
                doc.Load(filePath);
                return doc;
            }
            catch
            {
                return null;
            }
        }
        #endregion 增、刪、改操作

        #region --讀取XML的所有子節點--
        /// <summary>
        /// 讀取XML的所有子節點
        /// </summary>
        /// <param name="filePath">XML文件絕對路徑</param>
        /// <param name="xPath">范例: @"Skill/First/SkillItem"</param>
        /// <returns></returns>
        public static XmlNodeList ReadNodes(string filePath, string xPath)
        {
            try
            {
                XmlDocument doc = new XmlDocument();
                doc.Load(filePath);
                XmlNode xn = doc.SelectSingleNode(xPath);
                XmlNodeList xnList = xn.ChildNodes;  //得到該節點的子節點
                return xnList;
            }
            catch
            {
                return null;
            }
        }

        #endregion 擴展方法
    }
}

　　以上用的是try catch這種處理，如果使用using可以參考一下鏈接：https://www.cnblogs.com/Chary/p/No0000DE.html

4. SerializationHelper文件序列化操作

　　對xml文件進行序列化並操作，可以參考。

using System;
using System.Collections.Generic;
using System.IO;
using System.Text;
using System.Xml.Serialization;

namespace NC.Common
{
    public class SerializationHelper
    {
        public SerializationHelper() { }

        /// <summary>
        /// 反序列化
        /// </summary>
        /// <param name="type">對象類型</param>
        /// <param name="filename">文件路徑</param>
        /// <returns></returns>
        public static object Load(Type type, string filename)
        {
            FileStream fs = null;
            try
            {
                // open the stream...
                fs = new FileStream(filename, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
                XmlSerializer serializer = new XmlSerializer(type);
                return serializer.Deserialize(fs);
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                if (fs != null)
                    fs.Close();
            }
        }


        /// <summary>
        /// 序列化
        /// </summary>
        /// <param name="obj">對象</param>
        /// <param name="filename">文件路徑</param>
        public static void Save(object obj, string filename)
        {
            FileStream fs = null;
            // serialize it...
            try
            {
                fs = new FileStream(filename, FileMode.Create, FileAccess.Write, FileShare.ReadWrite);
                XmlSerializer serializer = new XmlSerializer(obj.GetType());
                serializer.Serialize(fs, obj);
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                if (fs != null)
                    fs.Close();
            }

        }

    }
}

　　調用案例：

#region--站點配置文件--
        /// <summary>
        ///  讀取配置文件
        /// </summary>
        public NC.Model.siteconfig loadConfig()
        {
            NC.Model.siteconfig model = CacheHelper.Get<NC.Model.siteconfig>(JHKeys.CACHE_SYS_CONFIG);
            if (model == null)
            {
                //netcore2.0文件依賴緩存沒有，暫時只能修改文件后手動清空一次緩存
                 //Utils.GetXmlMapPath(JHKeys.FILE_SYS_XML_CONFING);
//CacheHelper是NET Core下Microsoft.Extensions.Caching.Memory緩存幫助類
                CacheHelper.Set(JHKeys.CACHE_SYS_CONFIG, (NC.Model.siteconfig)SerializationHelper.Load(typeof(NC.Model.siteconfig), Utils.GetXmlMapPath(JHKeys.FILE_SYS_XML_CONFING)));
                model = CacheHelper.Get<NC.Model.siteconfig>(JHKeys.CACHE_SYS_CONFIG);
            }
            return model;
        }
        /// <summary>
        ///  保存配置文件
        /// </summary>
        public NC.Model.siteconfig saveConifg(NC.Model.siteconfig model)
        {
            return saveConifg(model, Utils.GetXmlMapPath(JHKeys.FILE_SYS_XML_CONFING));
        }
        private static object lockHelper = new object();
        /// <summary>
        /// 寫入站點配置文件
        /// </summary>
        public NC.Model.siteconfig saveConifg(NC.Model.siteconfig model, string configFilePath)
        {
            // 清緩存
CacheHelper.Remove(JHKeys.CACHE_SYS_CONFIG);
            lock (lockHelper)
            {
                SerializationHelper.Save(model, configFilePath);
            }
            return model;
        }
#endregion

站點配置文件

5. JsonHelper基於Newtonsoft.Json封裝

using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Data;
using System.Text;

namespace NC.Common
{
    /// <summary>
    /// JSON幫助類
    /// </summary>
    public class JsonHelper
    {
        /// <summary> 
        /// 對象轉JSON 
        /// </summary> 
        /// <param name="obj">對象</param> 
        /// <returns>JSON格式的字符串</returns> 
        public static string ObjectToJSON(object obj)
        {
            try
            {
                byte[] b = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(obj));
                return Encoding.UTF8.GetString(b);
            }
            catch (Exception ex)
            {

                throw new Exception("JSONHelper.ObjectToJSON(): " + ex.Message);
            }
        }

        /// <summary> 
        /// 數據表轉鍵值對集合
        /// 把DataTable轉成 List集合, 存每一行 
        /// 集合中放的是鍵值對字典,存每一列 
        /// </summary> 
        /// <param name="dt">數據表</param> 
        /// <returns>哈希表數組</returns> 
        public static List<Dictionary<string, object>> DataTableToList(DataTable dt)
        {
            List<Dictionary<string, object>> list
                 = new List<Dictionary<string, object>>();

            foreach (DataRow dr in dt.Rows)
            {
                Dictionary<string, object> dic = new Dictionary<string, object>();
                foreach (DataColumn dc in dt.Columns)
                {
                    dic.Add(dc.ColumnName, dr[dc.ColumnName]);
                }
                list.Add(dic);
            }
            return list;
        }

        /// <summary> 
        /// 數據集轉鍵值對數組字典 
        /// </summary> 
        /// <param name="dataSet">數據集</param> 
        /// <returns>鍵值對數組字典</returns> 
        public static Dictionary<string, List<Dictionary<string, object>>> DataSetToDic(DataSet ds)
        {
            Dictionary<string, List<Dictionary<string, object>>> result = new Dictionary<string, List<Dictionary<string, object>>>();

            foreach (DataTable dt in ds.Tables)
                result.Add(dt.TableName, DataTableToList(dt));

            return result;
        }

        /// <summary> 
        /// 數據表轉JSON 
        /// </summary> 
        /// <param name="dataTable">數據表</param> 
        /// <returns>JSON字符串</returns> 
        public static string DataTableToJSON(DataTable dt)
        {
            return ObjectToJSON(DataTableToList(dt));
        }

        /// <summary> 
        /// JSON文本轉對象,泛型方法 
        /// </summary> 
        /// <typeparam name="T">類型</typeparam> 
        /// <param name="jsonText">JSON文本</param> 
        /// <returns>指定類型的對象</returns> 
        public static T JSONToObject<T>(string jsonText)
        {
            //JavaScriptSerializer jss = new JavaScriptSerializer();
            try
            {
                return JsonConvert.DeserializeObject<T>(jsonText);
                //return jss.Deserialize<T>(jsonText);
            }
            catch (Exception ex)
            {
                throw new Exception("JSONHelper.JSONToObject(): " + ex.Message);
            }
        }

        /// <summary> 
        /// 將JSON文本轉換為數據表數據 
        /// </summary> 
        /// <param name="jsonText">JSON文本</param> 
        /// <returns>數據表字典</returns> 
        public static Dictionary<string, List<Dictionary<string, object>>> TablesDataFromJSON(string jsonText)
        {
            return JSONToObject<Dictionary<string, List<Dictionary<string, object>>>>(jsonText);
        }

        /// <summary> 
        /// 將JSON文本轉換成數據行 
        /// </summary> 
        /// <param name="jsonText">JSON文本</param> 
        /// <returns>數據行的字典</returns>
        public static Dictionary<string, object> DataRowFromJSON(string jsonText)
        {
            return JSONToObject<Dictionary<string, object>>(jsonText);
        }
    }
}

JsonHelper

6. ByteConvertHelper byte轉換操作類

　　　　Byte轉換操作類這里主要配合session存儲使用，net core 2.0存儲session 類型為object，先轉成byte存儲，讀取再通過byte轉object。

　　　　例如Session存儲值是字符串；設置session：HttpContext.Session.SetString("name","hello world!"); 獲取session：string str = HttpContext.Session.GetString("name");

using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Text;

namespace NC.Common
{
    /// <summary>
    /// byte轉換操作類，主要用於Session存儲
    /// </summary>
    public class ByteConvertHelper
    {
        /// <summary>
        /// 將對象轉換為byte數組
        /// </summary>
        /// <param name="obj">被轉換對象</param>
        /// <returns>轉換后byte數組</returns>
        public static byte[] Object2Bytes(object obj)
        {
            byte[] serializedResult = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(obj));
            return serializedResult;
        }

        /// <summary>
        /// 將byte數組轉換成對象
        /// </summary>
        /// <param name="buff">被轉換byte數組</param>
        /// <returns>轉換完成后的對象</returns>
        public static object Bytes2Object(byte[] buff)
        {
            return JsonConvert.DeserializeObject<object>(Encoding.UTF8.GetString(buff));
        }

        /// <summary>
        /// 將byte數組轉換成對象
        /// </summary>
        /// <param name="buff">被轉換byte數組</param>
        /// <returns>轉換完成后的對象</returns>
        public static T Bytes2Object<T>(byte[] buff)
        {
            return JsonConvert.DeserializeObject<T>(Encoding.UTF8.GetString(buff));
        }
    }
}

　　調用實例參考《Asp.Net Core 2.0 項目實戰（11）基於OnActionExecuting全局過濾器，頁面操作權限過濾控制到按鈕級》中的<3.5 Session相關操作>。

7. 總結

　　以上幫助類只是為了快速開發，文中有些幫助類是由webform項目升級改造的，適合自己項目的一些封裝，僅供參考。需要做成幫助類全局調用的Helper還有很多，歡迎大家多多交流，謝謝！

免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。

猜您在找 Asp.Net Core 2.0 項目實戰（4）ADO.NET操作數據庫封裝、 EF Core操作及實例 Asp.Net Core 2.0 項目實戰（11）基於OnActionExecuting全局過濾器，頁面操作權限過濾控制到按鈕級 [譯]ASP.NET Core 2.0 本地文件操作 ASP.NET Core ResponseCache進行緩存操作在ASP.NET Core中使用AOP來簡化緩存操作基於.net core封裝的xml序列化，反序列化操作【無私分享：ASP.NET CORE 項目實戰（第七章）】文件操作 FileHelper Asp.Net Core Mvc上Json序列化首字母大小寫的問題如何配置 asp.net core webapi 的 json 序列化行為在Asp.Net Core 3.0中如何使用 Newtonsoft.Json 庫序列化數據