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