DomHelper

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Text.RegularExpressions;


namespace Entity
{
    public class DomHelper
    {
        /// <summary>
        /// 枚举帮助类
        /// </summary>
        public static class EnumHelper
        {
            /// <summary>
            /// 根据枚举获取描述
            /// </summary>
            /// <param name="en">枚举</param>
            /// <returns></returns>
            public static string GetEnumDesc(System.Enum en)
            {
                Type type = en.GetType();
                MemberInfo[] memInfo = type.GetMember(en.ToString());
                if (memInfo.Length > 0)
                {
                    object[] attrs = memInfo[0].GetCustomAttributes(typeof(DescriptionAttribute), false);
                    if (attrs.Length > 0)
                        return ((DescriptionAttribute)attrs[0]).Description;
                }
                return en.ToString();
            }
            /// <summary>
            /// 根据枚举描述获取枚举值
            /// </summary>
            /// <param name="en">枚举</param>
            /// <param name="description">描述</param>
            /// <returns>值</returns>
            public static int GetEnumByDesc(System.Enum en, string description)
            {
                if (en == null)
                    return -1;
                if (String.IsNullOrEmpty(description))
                    return -1;
                Type type = en.GetType();
                FieldInfo[] fields = type.GetFields();
                if (fields.Length == 0)
                    return -1;
                for (int i = 0; i < fields.Length; i++)
                {
                    FieldInfo field = fields[i];
                    object[] attributes = field.GetCustomAttributes(typeof(DescriptionAttribute), false);
                    if (attributes.Length == 0)
                        continue;
                    if (((DescriptionAttribute)attributes[0]).Description == description)
                        return (int)(field.GetValue(null));
                }
                return -1;
            }
            /// <summary>
            /// 根据枚举类型描述获取枚举值
            /// </summary>
            /// <param name="type">类型</param>
            /// <param name="description">描述</param>
            /// <returns>值</returns>
            public static int GetEnumByDesc(Type type, string description)
            {
                if (type == null)
                    return -1;
                if (String.IsNullOrEmpty(description))
                    return -1;
                FieldInfo[] fields = type.GetFields();
                if (fields.Length == 0)
                    return -1;
                for (int i = 0; i < fields.Length; i++)
                {
                    FieldInfo field = fields[i];
                    object[] attributes = field.GetCustomAttributes(typeof(DescriptionAttribute), false);
                    if (attributes.Length == 0)
                        continue;
                    if (((DescriptionAttribute)attributes[0]).Description == description)
                        return (int)(field.GetValue(null));
                }
                return -1;
            }
            /// <summary>
            /// 根据枚举键获取枚举
            /// </summary>
            /// <typeparam name="T">枚举类</typeparam>
            /// <param name="name">Key</param>
            /// <returns>枚举</returns>
            public static T GetEnumTypeByName<T>(string name)
            {
                foreach (T dbt in System.Enum.GetValues(typeof(T)))
                    if (dbt.ToString().ToUpper() == name.ToUpper()
                        || dbt.ToString() == name)
                        return dbt;


                throw new Exception("异常发生！尚未为此数据库类型定义枚举:" + name);
            }
            /// <summary>
            /// 根据枚举值获取枚举
            /// </summary>
            /// <typeparam name="T">枚举类</typeparam>
            /// <param name="value">Value</param>
            /// <returns>枚举</returns>
            public static T GetEnumTypeByValue<T>(int value)
            {
                foreach (T dbt in System.Enum.GetValues(typeof(T)))
                    if (Convert.ToInt32(dbt) == value)
                        return dbt;


                throw new Exception("异常发生！尚未为此数据库类型定义枚举:" + value);
            }
            /// <summary>
            /// 根据描述获取枚举
            /// </summary>
            /// <typeparam name="T">枚举类</typeparam>
            /// <param name="desc">描述</param>
            /// <returns>枚举</returns>
            public static T GetEnumTypeByDesc<T>(string desc)
            {
                var res = GetEnumInfo(typeof(T));
                foreach (var re in res)
                {
                    if (re.Text == desc)
                    {
                        return GetEnumTypeByValue<T>(re.Value);
                    }
                }
                throw new Exception("异常发生！尚未为此数据库类型定义枚举:" + desc);
            }
            /// <summary>
            /// 根据枚举Name获取枚举信息
            /// </summary>
            /// <typeparam name="T"></typeparam>
            /// <param name="name"></param>
            /// <returns></returns>
            public static EnumInf GetEnumInfoByName<T>(string name)
            {
                var res = GetEnumInfo(typeof(T));
                foreach (var re in res)
                {
                    if (re.Name == name)
                        return re;
                }
                return null;
            }
            /// <summary>
            /// 根据枚举Value获取枚举信息
            /// </summary>
            /// <typeparam name="T"></typeparam>
            /// <param name="value"></param>
            /// <returns></returns>
            public static EnumInf GetEnumInfoByValue<T>(int value)
            {
                var res = GetEnumInfo(typeof(T));
                foreach (var re in res)
                {
                    if (re.Value == value)
                        return re;
                }
                return null;
            }
            /// <summary>
            /// 根据枚举描述获取枚举信息
            /// </summary>
            /// <typeparam name="T"></typeparam>
            /// <param name="desc"></param>
            /// <returns></returns>
            public static EnumInf GetEnumInfoByDesc<T>(string desc)
            {
                var res = GetEnumInfo(typeof(T));
                foreach (var re in res)
                {
                    if (re.Text == desc)
                        return re;
                }
                return null;
            }
            /// <summary>
            /// 根据枚举类型返回类型中的所有值，文本及描述
            /// </summary>
            /// <param name="type"></param>
            /// <returns>返回三列数组，第0列为Description,第1列为Value，第2列为Text</returns>
            public static List<EnumInf> GetEnumInfo(Type type)
            {
                var Strs = new List<EnumInf>();
                var fields = type.GetFields();
                for (int i = 1, count = fields.Length; i < count; i++)
                {
                    var strEnum = new EnumInf();
                    var field = fields[i];
                    //值列
                    strEnum.Value = (int)System.Enum.Parse(type, field.Name);
                    //文本列赋值
                    strEnum.Name = field.Name;


                    var objs = field.GetCustomAttributes(typeof(DescriptionAttribute), false);
                    if (objs.Length == 0)
                    {
                        strEnum.Text = field.Name;
                    }
                    else
                    {
                        var da = (DescriptionAttribute)objs[0];
                        strEnum.Text = da.Description;
                    }


                    Strs.Add(strEnum);
                }
                return Strs;
            }
        }
        /// <summary>
        /// 转换帮助类
        /// </summary>
        public static class ConvertHelper
        {
            /// <summary>
            /// DataCell值转为string
            /// </summary>
            /// <param name="cellValue">数据库值</param>
            /// <returns>为空时，返回null</returns>
            public static string GetDbString(object cellValue)
            {
                if (cellValue is DBNull)
                {
                    return null;
                }
                if(cellValue == null)
                {
                    return null;
                }
                return cellValue.ToString();
            }
            /// <summary>
            /// DataCell值转为datetime
            /// </summary>
            /// <param name="cellValue"></param>
            /// <returns>为空时，返回null</returns>
            public static DateTime? GetDbTime(object cellValue)
            {
                if (cellValue is DBNull)
                {
                    return null;
                }
                try
                {
                    return Convert.ToDateTime(cellValue);
                }
                catch (Exception)
                {
                    return null;
                }
            }
            /// <summary>
            /// DataCell值转为int
            /// </summary>
            /// <param name="cellValue"></param>
            /// <returns>为空时，返回0</returns>
            public static int GetDbInt(object cellValue)
            {
                if (cellValue is DBNull)
                {
                    return 0;
                }
                try
                {
                    return Convert.ToInt32(cellValue);
                }
                catch (Exception)
                {
                    return 0;
                }
            }
            /// <summary>
            /// DataCell值转为Decimal
            /// </summary>
            /// <param name="cellValue"></param>
            /// <returns>为空时，返回0</returns>
            public static decimal GetDbDecimal(object cellValue)
            {
                if (cellValue is DBNull)
                {
                    return 0M;
                }
                try
                {
                    return Convert.ToDecimal(cellValue);
                }
                catch (Exception)
                {
                    return 0M;
                }
            }
            /// <summary>
            /// 字符串根据分隔符转列表(空值被忽略)
            /// </summary>
            /// <param name="source">字符串</param>
            /// <param name="splitChar">分隔符</param>
            /// <returns>结果</returns>
            public static List<string> StringToList(string source, string splitChar)
            {
                var res = source.Split(new[] { splitChar }, StringSplitOptions.RemoveEmptyEntries);
                return res.Select(t => t.Trim()).ToList();
            }
            /// <summary>
            /// List数据转为字符串
            /// </summary>
            /// <typeparam name="T">数据类型</typeparam>
            /// <param name="list">数据集合</param>
            /// <param name="splitChar">字符串中的分隔符</param>
            /// <param name="upChar">Item前后包装符(不可为空格)</param>
            /// <returns></returns>
            public static string ListToString<T>(IList<T> list, char splitChar, char upChar = ' ')
            {
                var str = String.Empty;
                if (list.Count > 0)
                {
                    if (upChar == ' ')
                    {
                        foreach (var item in list)
                        {
                            str += String.Format("{0}{1}", item, splitChar);
                        }
                    }
                    else
                    {
                        foreach (var item in list)
                        {
                            str += String.Format("{1}{0}{1}{2}", item, upChar, splitChar);
                        }
                    }
                    return str.TrimEnd(new[] { splitChar });
                }
                return str;
            }
        }


        /// <summary>
        /// 返回字符串的字节长度(汉字长度为2)
        /// </summary>
        /// <param name="str">字符串</param>
        /// <returns>长度</returns>
        public static int GetStringLen(string str)
        {
            return Encoding.Default.GetBytes(str).Length;
        }


        /// <summary>
        /// 是否是浮点数 可带正负号
        /// </summary>
        /// <param name="inputData">输入字符串</param>
        /// <returns></returns>
        public static bool IsDecimalSign(string inputData)
        {
            var regDecimalSign = new Regex("^[+-]?[0-9]+[.]?[0-9]+$");
            var m = regDecimalSign.Match(inputData);
            return m.Success;
        }
        /// <summary>
        /// 是否为正负整数
        /// </summary>
        /// <param name="inputData">输入字符串</param>
        /// <returns></returns>
        public static bool IsIntegerSign(string inputData)
        {
            var regIntegerSign = new Regex("^[+-]?[0-9]+$");
            var m = regIntegerSign.Match(inputData);
            return m.Success;
        }
        /// <summary>
        /// 是否为正整数
        /// </summary>
        /// <param name="inputData">输入字符串</param>
        /// <returns></returns>
        public static bool IsNumericSign(string inputData)
        {
            var regIntegerSign = new Regex("^[0-9]+$");
            var m = regIntegerSign.Match(inputData);
            return m.Success;
        }
        /// <summary>
        /// 加密手机号
        /// </summary>
        /// <param name="tel">手机号</param>
        /// <param name="encrypt">异常手机号是否全部字符加密</param>
        /// <returns></returns>
        public static string EncryptTel(string tel,bool encrypt = true)
        {
            var result = String.Empty;
            if (!String.IsNullOrEmpty(tel))
            {
                tel = tel.Trim();
                if (tel.Length == 11)
                {
                    result = tel.Substring(0, 3) + "****" + tel.Substring(7, 4);
                }
                else
                {
                    if(encrypt)
                    {
                        result = "***********";
                    }
                    else
                    {
                        result = tel;
                    }
                }
            }
            return result;
        }


        /// <summary>判断指定字符串是否包含有汉字</summary>
        /// <param name="strChineseString">指定的字符串</param>
        /// <returns>若包含有汉字则返回True,否则返回False</returns>
        public static bool InChinese(string strChineseString)
        {
            return Regex.IsMatch(strChineseString, @"[\u4e00-\u9fa5]");
        }


        /// <summary>
        /// 对LIST进行分组
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="source"></param>
        /// <param name="groupCount">每组数量</param>
        /// <returns></returns>
        public static List<List<T>> SplitList<T>(List<T> source, int groupCount)
        {
            var res = new List<List<T>>();
            if (source == null) return res;
            if (groupCount <= 0) groupCount = source.Count;
            var num = (int)Math.Ceiling((double)source.Count / groupCount);


            for (var i = 1; i <= num; i++)
            {
                if (i == num)
                {
                    var yu = source.Count % groupCount;
                    if (yu == 0) yu = groupCount;
                    var start = (i - 1) * groupCount;
                    res.Add(source.GetRange(start, yu));
                }
                else
                {
                    var start = (i - 1) * groupCount;
                    res.Add(source.GetRange(start, groupCount));
                }
            }
            return res;
        }
        /// <summary>
        /// 截取指定长度的字符串
        /// </summary>
        /// <param name="input">原始字符串</param>
        /// <param name="maxLenth">截取的长度</param>
        /// <returns>新字符串</returns>
        public static string GetSubString(string input,int maxLenth)
        {
            if(input == null || input.Length <= maxLenth) return input;
            return input.Substring(0, maxLenth);
        }
        /// <summary>
        /// 获取列名集合
        /// </summary>
        /// <param name="dt">表</param>
        /// <returns>列名集合</returns>
        public static List<string> GetColunmName(DataTable dt)
        {
            var res = new List<string>();
            if(dt != null)
            {
                foreach (DataColumn column in dt.Columns)
                {
                    res.Add(column.ColumnName);
                }
            }
            return res;
        }
    }
}