常用工具类（持续更新）

1.缓存工具类

/// <summary>
    /// 缓存读写工具类
    /// </summary>
    public class CacheHelper
    {
        /// <summary>
        /// 创建缓存项的文件
        /// </summary>
        /// <param name="key">缓存Key</param>
        /// <param name="obj">object对象</param>
        public static void Insert(string key, object obj)
        {
            //创建缓存
            HttpContext.Current.Cache.Insert(key, obj);
        }
        /// <summary>
        /// 移除缓存项的文件
        /// </summary>
        /// <param name="key">缓存Key</param>
        public static void Remove(string key)
        {
            //创建缓存
            HttpContext.Current.Cache.Remove(key);
        }
        /// <summary>
        /// 创建缓存项的文件依赖
        /// </summary>
        /// <param name="key">缓存Key</param>
        /// <param name="obj">object对象</param>
        /// <param name="fileName">文件绝对路径</param>
        public static void Insert(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>
        /// <param name="obj">object对象</param>
        /// <param name="expires">过期时间(分钟)</param>
        public static void Insert(string key, object obj, int expires)
        {
            HttpContext.Current.Cache.Insert(key, obj, null, Cache.NoAbsoluteExpiration, new TimeSpan(0, expires, 0));
        }

        /// <summary>
        /// 获取缓存对象
        /// </summary>
        /// <param name="key">缓存Key</param>
        /// <returns>object对象</returns>
        public static object Get(string key)
        {
            if (string.IsNullOrEmpty(key))
            {
                return null;
            }
            return HttpContext.Current.Cache.Get(key);
        }

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

    }

View Code

 2.获取web.config节点类

public class Configurator
    {
        /// <summary>
        /// 获取AppSetting属性
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public static string GetAppSetting(string key)
        {
            var appSetting = ConfigurationManager.AppSettings[key];

            if (string.IsNullOrEmpty(appSetting))
            {
                return string.Format("未配置节点" + key);
            }
            return appSetting;
        }

        /// <summary>
        /// 获取连接字符串
        /// </summary>
        /// <param name="name"></param>
        /// <returns></returns>
        public static string GetConnectiongString(string name)
        {
            return ConfigurationManager.ConnectionStrings[name].ConnectionString;
        }

        /// <summary>
        /// 数据库链接
        /// </summary>
        public static string DbConnectionString
        {
            get { return GetConnectiongString("DbConnectionString"); }
        }

        /// <summary>
        /// 获取config值
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public static string GetConfigValue(string key)
        {
            return GetAppSetting(key);
        }
    }

View Code

3.数据类型转换类

public class Converter
    {
        /// <summary>
        /// 获得int
        /// </summary>
        /// <param name="obj">转换前值</param>
        /// <param name="defValue">默认Int值</param>
        /// <returns>转换后值</returns>
        public static int ParseInt(object obj, int defValue)
        {
            int result = -1;
            try
            {
                if (obj != null)
                {
                    string res = obj.ToString();
                    if (!int.TryParse(res, out result))
                    {
                        result = defValue;
                    }
                }
                else
                {
                    result = defValue;
                }
            }
            catch
            {
                result = defValue;
            }
            return result;
        }

        /// <summary>
        /// obj转string
        /// </summary>
        /// <param name="obj"></param>
        /// <param name="defValue"></param>
        /// <returns></returns>
        public static string ParseString(object obj, string defValue)
        {
            string result = string.Empty;
            try
            {
                if (obj == null)
                    result = defValue;
                else
                    result = obj.ToString();
            }
            catch
            {
                result = defValue;
            }
            return result;
        }

        /// <summary>
        /// 将金额转换成 int 类型
        /// </summary>
        /// <param name="obj"></param>
        /// <param name="defValue"></param>
        /// <returns></returns>
        public static int ParseIntDecimal(decimal? dec, int defValue)
        {
            int result = 0;

            try
            {
                return Convert.ToInt32((dec * 100));
            }
            catch
            {
                result = defValue;
            }

            return result;
        }

        /// <summary>
        /// 将空类型转换不为空
        /// </summary>
        /// <param name="dec"></param>
        /// <param name="defValue"></param>
        /// <returns></returns>
        public static decimal ParseDecimalNull(decimal? dec, decimal defValue)
        {
            decimal result = 0;

            try
            {
                if (dec != null)
                {
                    result = (decimal)dec;
                }
                else
                {
                    result = defValue;
                }
            }
            catch
            {
                result = defValue;
            }

            return result;
        }

        /// <summary>
        /// 获得Datetime
        /// </summary>
        /// <param name="obj">转换前值</param>
        /// <param name="defValue">默认时间</param>
        /// <returns>转换后值</returns>
        public static DateTime ParseDateTime(object obj, DateTime defValue)
        {
            DateTime result = DateTime.Now;
            try
            {
                if (!DateTime.TryParse(obj.ToString(), out result))
                {
                    result = defValue;
                }
            }
            catch
            {

            }
            return result;
        }

        /// <summary>
        /// 获得Decimal
        /// </summary>
        /// <param name="obj">转换前值</param>
        /// <param name="defValue">默认decimal值</param>
        /// <returns>转换后值</returns>
        public static decimal ParseDecimal(object obj, decimal defValue)
        {
            decimal result = new decimal(0);
            try
            {
                string res = obj.ToString();
                if (!decimal.TryParse(res, out result))
                {
                    result = defValue;
                }
            }
            catch
            {
            }
            return result;
        }
        /// <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;
        }
    }

View Code

4.日期操作类

/// <summary>
    /// 日期扩展类
    /// </summary>
    public class DateExt
    {
        /// <summary>
        /// 格式化开始时间
        /// </summary>
        /// <param name="dt"></param>
        /// <returns></returns>
        public static DateTime ToStartDateTime(DateTime? dt)
        {
            var date = new DateTime();
            if (dt == null) return date;
            return DateTime.TryParse(dt.Value.ToString("yyyy-MM-dd") + " 00:00:00", out date) ? date : new DateTime();
        }

        /// <summary>
        /// 格式化结束时间
        /// </summary>
        /// <param name="dt"></param>
        /// <returns></returns>
        public static DateTime ToEndDateTime(DateTime? dt)
        {
            var date = new DateTime();
            if (dt == null) return date;
            return DateTime.TryParse(dt.Value.ToString("yyyy-MM-dd") + " 23:59:59",out date) ? date : new DateTime();
        }

        /// <summary>
        /// 格式化时间
        /// </summary>
        /// <returns></returns>
        public static string ToyyyyMMddHHmmss(DateTime time, string format = "yyyy-MM-dd HH:mm:ss")
        {
            return time.ToString(format);
        }

        /// <summary>
        /// 生成时间戳，标准北京时间，时区为东八区，自1970年1月1日 0点0分0秒以来的秒数
        /// </summary>
        /// <returns>时间戳</returns>
        public static string GenerateTimeStamp()
        {
            TimeSpan ts = DateTime.UtcNow - new DateTime(1970, 1, 1, 0, 0, 0, 0);
            return Convert.ToInt64(ts.TotalSeconds).ToString();
        }
    }

View Code

5.DES加/解密类

/// <summary>
    /// DES加密/解密类。
    /// </summary>
    public class DESEncrypt
    {

        #region ========加密========

        /// <summary>
        /// 加密
        /// </summary>
        /// <param name="Text"></param>
        /// <returns></returns>
        public static string Encrypt(string Text)
        {
            return Encrypt(Text, "HYD");
        }

        /// <summary> 
        /// 加密数据 
        /// </summary> 
        /// <param name="Text"></param> 
        /// <param name="sKey"></param> 
        /// <returns></returns> 
        public static string Encrypt(string Text, string sKey)
        {
            DESCryptoServiceProvider des = new DESCryptoServiceProvider();
            byte[] inputByteArray;
            inputByteArray = Encoding.Default.GetBytes(Text);
            des.Key = ASCIIEncoding.ASCII.GetBytes(System.Web.Security.FormsAuthentication.HashPasswordForStoringInConfigFile(sKey, "md5").Substring(0, 8));
            des.IV = ASCIIEncoding.ASCII.GetBytes(System.Web.Security.FormsAuthentication.HashPasswordForStoringInConfigFile(sKey, "md5").Substring(0, 8));
            System.IO.MemoryStream ms = new System.IO.MemoryStream();
            CryptoStream cs = new CryptoStream(ms, des.CreateEncryptor(), CryptoStreamMode.Write);
            cs.Write(inputByteArray, 0, inputByteArray.Length);
            cs.FlushFinalBlock();
            StringBuilder ret = new StringBuilder();
            foreach (byte b in ms.ToArray())
            {
                ret.AppendFormat("{0:X2}", b);
            }
            return ret.ToString();
        }

        #endregion

        #region ========解密========

        /// <summary>
        /// 解密
        /// </summary>
        /// <param name="Text"></param>
        /// <returns></returns>
        public static string Decrypt(string Text)
        {
            return Decrypt(Text, "HYD");
        }
        /// <summary> 
        /// 解密数据 
        /// </summary> 
        /// <param name="Text"></param> 
        /// <param name="sKey"></param> 
        /// <returns></returns> 
        public static string Decrypt(string Text, string sKey)
        {
            DESCryptoServiceProvider des = new DESCryptoServiceProvider();
            int len;
            len = Text.Length / 2;
            byte[] inputByteArray = new byte[len];
            int x, i;
            for (x = 0; x < len; x++)
            {
                i = Convert.ToInt32(Text.Substring(x * 2, 2), 16);
                inputByteArray[x] = (byte)i;
            }
            des.Key = ASCIIEncoding.ASCII.GetBytes(System.Web.Security.FormsAuthentication.HashPasswordForStoringInConfigFile(sKey, "md5").Substring(0, 8));
            des.IV = ASCIIEncoding.ASCII.GetBytes(System.Web.Security.FormsAuthentication.HashPasswordForStoringInConfigFile(sKey, "md5").Substring(0, 8));
            System.IO.MemoryStream ms = new System.IO.MemoryStream();
            CryptoStream cs = new CryptoStream(ms, des.CreateDecryptor(), CryptoStreamMode.Write);
            cs.Write(inputByteArray, 0, inputByteArray.Length);
            cs.FlushFinalBlock();
            return Encoding.Default.GetString(ms.ToArray());
        }

        #endregion

    }

View Code

6.List转DataTable

public static class Extensions
    {
        public static DataTable ToDataTable<T>(this IList<T> list,string tableName)
        {
            Type elementType = typeof(T);

            var t = new DataTable();

            elementType.GetProperties().ToList().ForEach(propInfo => t.Columns.Add(propInfo.Name, Nullable.GetUnderlyingType(propInfo.PropertyType) ?? propInfo.PropertyType));
            foreach (T item in list)
            {
                var row = t.NewRow();
                elementType.GetProperties().ToList().ForEach(propInfo => row[propInfo.Name] = propInfo.GetValue(item, null) ?? DBNull.Value);
                t.Rows.Add(row);
            }
            t.TableName = tableName;
            return t;
        }
    }

View Code

7.Json帮助类

/// <summary>
    /// JSON帮助类
    /// </summary>
    public class JsonHelper
    {
        /// <summary> 
        /// 对象转JSON 
        /// </summary> 
        /// <param name="obj">对象</param> 
        /// <returns>JSON格式的字符串</returns> 
        public static string ObjectToJSON(object obj)
        {
            JavaScriptSerializer jss = new JavaScriptSerializer();
            try
            {
                byte[] b = Encoding.UTF8.GetBytes(jss.Serialize(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 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);
        }
    }

View Code

8.Json序列化类

public class JsonSerializeHelper
    {
        public static void Serialize(object value, Stream s)
        {
            JsonTextWriter jsonTextWriter = new JsonTextWriter((TextWriter)new StreamWriter(s));
            new JsonSerializer().Serialize((JsonWriter)jsonTextWriter, value);
            jsonTextWriter.Flush();
        }

        public static string Serialize(object value)
        {
            using (MemoryStream memoryStream = new MemoryStream())
            {
                JsonTextWriter jsonTextWriter = new JsonTextWriter((TextWriter)new StreamWriter((Stream)memoryStream));
                new JsonSerializer().Serialize((JsonWriter)jsonTextWriter, value);
                jsonTextWriter.Flush();
                return Encoding.UTF8.GetString(memoryStream.ToArray());
            }
        }

        public static T Deserialize<T>(Stream s)
        {
            return new JsonSerializer().Deserialize<T>((JsonReader)new JsonTextReader((TextReader)new StreamReader(s)));
        }

        public static string DataTableToJson(DataTable dt)
        {
            string str1 = string.Empty;
            string str2;
            try
            {
                string str3 = dt.TableName + ":[";
                for (int index1 = 0; index1 < dt.Rows.Count; ++index1)
                {
                    string str4 = str3 + "{";
                    for (int index2 = 0; index2 < dt.Columns.Count; ++index2)
                    {
                        str4 = str4 + (object)dt.Columns[index2].ColumnName + ":'" + (string)dt.Rows[index1][index2] + "'";
                        if (index2 != dt.Columns.Count - 1)
                            str4 = str4 + ",";
                    }
                    str3 = str4 + "}";
                    if (index1 != dt.Rows.Count - 1)
                        str3 = str3 + ",";
                }
                str2 = str3 + "]";
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
            return str2;
        }
    }

View Code

9.分页类

/// <summary>  
    /// ROW_NUMBER高效率分页(仅支持MSSQL2005及以上)
    /// </summary>  
    public static class PagingHelper
    {
        /// <summary>
        /// 获取分页SQL语句，默认row_number为关健字，所有表不允许使用该字段名
        /// </summary>
        /// <param name="_recordCount">记录总数</param>
        /// <param name="_pageSize">每页记录数</param>
        /// <param name="_pageIndex">当前页数</param>
        /// <param name="_safeSql">SQL查询语句</param>
        /// <param name="_orderField">排序字段，多个则用“,”隔开</param>
        /// <returns>分页SQL语句</returns>
        public static string CreatePagingSql(int _recordCount, int _pageSize, int _pageIndex, string _safeSql, string _orderField)
        {
            //计算总页数
            _pageSize = _pageSize == 0 ? _recordCount : _pageSize;
            int pageCount = (_recordCount + _pageSize - 1) / _pageSize;

            //检查当前页数
            if (_pageIndex < 1)
            {
                _pageIndex = 1;
            }
            else if (_pageIndex > pageCount)
            {
                _pageIndex = pageCount;
            }
            //拼接SQL字符串，加上ROW_NUMBER函数进行分页
            StringBuilder newSafeSql = new StringBuilder();
            newSafeSql.AppendFormat("SELECT ROW_NUMBER() OVER(ORDER BY {0}) as row_number,", _orderField);
            newSafeSql.Append(_safeSql.Substring(_safeSql.ToUpper().IndexOf("SELECT") + 6));

            //拼接成最终的SQL语句
            StringBuilder sbSql = new StringBuilder();
            sbSql.Append("SELECT * FROM (");
            sbSql.Append(newSafeSql.ToString());
            sbSql.Append(") AS T");
            sbSql.AppendFormat(" WHERE row_number between {0} and {1}", ((_pageIndex - 1) * _pageSize) + 1, _pageIndex * _pageSize);

            return sbSql.ToString();
        }

        /// <summary>
        /// 获取记录总数SQL语句
        /// </summary>
        /// <param name="_safeSql">SQL查询语句</param>
        /// <returns>记录总数SQL语句</returns>
        public static string CreateCountingSql(string _safeSql)
        {
            return string.Format(" SELECT COUNT(1) AS RecordCount FROM ({0}) AS T ", _safeSql);
        }
    }

View Code

10.序列化类

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

        }

    }

View Code

11.XML帮助类

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 扩展方法===================================================
        /// <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 扩展方法
    }

View Code

 12.Excel操作类（需导入Aspose.Cells.dll，Excel通过&=[DataTableName].FiledName绑定数据）

    public static class ExcelHelper
    {
        public static readonly string sourceDir = HttpContext.Current.Server.MapPath("/ExcelData/TemplateSource/");
        public static readonly string reciveDir = HttpContext.Current.Server.MapPath("/ExcelData/ReciveSource/");
       
        public static bool Export(string templateName, string outputName, DataTable data)
        {
            WorkbookDesigner designer = new WorkbookDesigner();

            string temp = string.Empty;
            string extension = string.Empty;
            bool isXls = false;

            if (File.Exists(sourceDir + templateName + ".xls"))
            {
                temp = sourceDir + templateName + ".xls";
                extension = ".xls";
                isXls = true;
            }
            else if (File.Exists(sourceDir + templateName + ".xlsx"))
            {
                temp = sourceDir + templateName + ".xlsx";
                extension = ".xlsx";
                
            }
            else
            {
                return false;
            }

            try
            {
                Workbook book = new Workbook(temp);
                designer.Workbook = book;

                designer.SetDataSource(data);
                designer.Process();
                if (isXls)
                {
                    book.Save(HttpContext.Current.Response, HttpUtility.UrlEncode(outputName, System.Text.Encoding.UTF8) + extension, ContentDisposition.Inline, new XlsSaveOptions());
                }
                else
                {
                    book.Save(HttpContext.Current.Response, HttpUtility.UrlEncode(outputName, System.Text.Encoding.UTF8) + extension, ContentDisposition.Attachment, new XlsSaveOptions(SaveFormat.Xlsx));
                }
                
                HttpContext.Current.Response.End();
                return true;
            }
            catch (Exception ex)
            {
                return false;
            }

        }

        public static List<Dictionary<string, object>> Import(string fileName)
        {
            WorkbookDesigner designer = new WorkbookDesigner();

            string file = File.Exists(reciveDir + fileName + ".xls")
                ? reciveDir + fileName + ".xls"
                : reciveDir + fileName + ".xlsx";

            Workbook book = new Workbook(file);
            designer.Workbook = book;

            Cells cells = book.Worksheets[0].Cells;
            DataTable datatable = cells.ExportDataTableAsString(0, 0, cells.MaxDataRow + 1, cells.MaxColumn + 1, true);
            return DataTableConvert.DataTableToList(datatable);
        }

        public static List<Dictionary<string, object>> Import(string fileName, int workSheet)
        {
            WorkbookDesigner designer = new WorkbookDesigner();

            string file = File.Exists(reciveDir + fileName + ".xls")
                ? reciveDir + fileName + ".xls"
                : reciveDir + fileName + ".xlsx";

            Workbook book = new Workbook(file);
            designer.Workbook = book;

            Cells cells = book.Worksheets[workSheet].Cells;
            DataTable datatable = cells.ExportDataTableAsString(0, 0, cells.MaxDataRow + 1, cells.MaxColumn + 1, true);
            return DataTableConvert.DataTableToList(datatable);
        }
    }

View Code

13.文件上传（demo只接受.xls和.xlsx类型，需要传其他类型可删除判断）

        public static bool UploadFile(HttpPostedFileBase uploadFile)
        {
            var files = HttpContext.Current.Request.Files;
            var exName = string.Empty;

            if (files != null && files.Count > 0)
            {
                for (int i = 0; i < files.Count; i++)
                {
                    var file = files[i];
                    exName = System.IO.Path.GetExtension(file.FileName); //得到扩展名

                    using (var sr = new StreamReader(file.InputStream))
                    {
                        try
                        {
                            if (".xlsx".Equals(exName) || ".xls".Equals(exName))
                            {
                                file.SaveAs(reciveDir+file.FileName);
                            }
                        }
                        catch (Exception ex)
                        {
                            return false;
                        }
                    }
                }
                return true;
            }
            return false;
        }

View Code

 

转载于:https://www.cnblogs.com/xuxing2016/p/7839155.html