/// <summary> /// 将对象转换为String类型 /// 特定的数据类型将进行格式化处理 /// 如为空, 则返回 string.Empty /// </summary> /// <param name="ov">通用object对象数据</param> /// <returns>格式化/ToString得到的string结果</returns> public static string ToString(object ov) { if (CheckData.IsObjectNull(ov)) { return(string.Empty); } Type vt = ov.GetType(); if (CheckData.IsTypeEqualDepth(vt, typeof(string), true)) { return(ov.ToString()); } if (CheckData.IsTypeEqualDepth(vt, typeof(DateTime), true)) { return(ToString((DateTime)ov)); } if (vt.IsEnum || CheckData.IsTypeEqualDepth(vt, typeof(Enum), true)) { return(((int)ov).ToString()); } if (CheckData.IsTypeEqualDepth(vt, typeof(Type), true)) { return(((Type)ov).FullName); } return(ov.ToString()); }
/// <summary> /// 数组列表转字符串 /// </summary> /// <param name="list">需要合并的字符串数组</param> /// <param name="symbolSign">用于间隔内容的间隔符号</param> public static string ToString <T>(IList <T> list, IConvertible symbolSign) { try { if (CheckData.IsObjectNull(list) || CheckData.IsObjectNull(symbolSign)) { return(string.Empty); } StringBuilder strs = new StringBuilder(); int firstSign = 0; bool isHavefirstValue = false; for (int i = firstSign; i < list.Count; i++) { if (CheckData.IsObjectNull(list[i]) || CheckData.IsStringNull(list[i].ToString())) { if (!isHavefirstValue) { firstSign = i + 1; } continue; } if (i > firstSign) { strs.Append(symbolSign.ToString()); } else { isHavefirstValue = true; } strs.Append(list[i].ToString()); } return(strs.ToString()); } catch (Exception) { return(string.Empty); } }
/// <summary> /// 打乱序列列表的元素顺序 /// </summary> /// <typeparam name="T">数组类型</typeparam> /// <param name="slist">数据源序列</param> /// <param name="need_num">需要的结果数量 如小于等于零取值序列个数</param> /// <returns>结果序列</returns> public static T[] Sample <T>(IList <T> slist, int need_num = 0) { if (CheckData.IsSizeEmpty(slist)) { return(new T[] { }); } List <T> rlist = new List <T>(); int slen_size = slist.Count; if (need_num <= 0) { need_num = slen_size; } if (need_num > slen_size) { rlist.AddRange(Sample(slist, need_num - slen_size)); need_num = slen_size; } while (need_num > 0) { int index = GetInt(0, need_num); need_num -= 1; rlist.Add(slist[index]); T C = slist[index]; slist[index] = slist[need_num]; slist[need_num] = C; } return(rlist.ToArray()); }
/// <summary> /// 数组列表之间的类型数据转换 /// </summary> /// <typeparam name="RT">结果返回值-数据类型</typeparam> /// <typeparam name="SLT">数据源-数据类型</typeparam> /// <typeparam name="SIT">数据源单个选项类型</typeparam> /// <param name="sourceslist">数据源数组</param> /// <param name="convertMethod">用户实现转换算法</param> /// <param name="isClearErrorValue">是否清除指定的错误值</param> /// <param name="errorValue">需要排除的错误值</param> private static RT[] ListConvertType <RT, SLT, SIT>(SLT sourceslist, Converter <SIT, RT> convertMethod, bool isClearErrorValue, RT errorValue = default(RT)) where SLT : IEnumerable { if (CheckData.IsObjectNull(sourceslist)) { return new RT[] { } } ; List <RT> list = new List <RT>(); isClearErrorValue = isClearErrorValue && !CheckData.IsObjectNull(errorValue); foreach (SIT item in sourceslist) { if (CheckData.IsObjectNull(item)) { continue; } RT value = convertMethod(item); if (CheckData.IsObjectNull(value)) { continue; } else if (isClearErrorValue && errorValue.Equals(value)) { continue; } list.Add(value); } return(list.ToArray()); }
/// <summary> /// 将对象转换为Int32类型 /// </summary> /// <param name="expression">要转换的字符串</param> /// <param name="defValue">缺省值</param> /// <returns>转换后的int类型结果</returns> public static int ToInt(object expression, int defValue) { if (!CheckData.IsObjectNull(expression)) { return(ToInt(expression.ToString(), defValue)); } return(defValue); }
/// <summary> /// 任意字符串转十六进制字符数据 /// </summary> /// <param name="obj_string">任意字符串</param> /// <returns></returns> public static string StringToHexadecimal(string obj_string) { if (CheckData.IsStringNull(obj_string)) { return(string.Empty); } return(Regex.Replace(obj_string, @"[^0-9a-fA-F]", "", RegexOptions.IgnoreCase).ToLower()); }
/// <summary> /// 随机选取其中一个选项 /// </summary> /// <typeparam name="T">数据类型</typeparam> /// <param name="source">数据源</param> /// <returns>结果选项, 数据源为空返回:数据类型默认值</returns> public static T Item <T>(IList <T> source) { if (CheckData.IsSizeEmpty(source)) { return(default(T)); } return(source[R.Next(0, source.Count)]); }
/// <summary> /// 是否是绝对路径 /// </summary> /// <param name="path_string">路径字符串</param> /// <returns>True是, False否</returns> public static bool IsAbsolute(string path_string) { if (CheckData.IsStringNull(path_string)) { return(false); } return(Regex.IsMatch(path_string, @"^([a-zA-Z]:\\){1}[^\/\:\*\?\""\<\>\|\,]*$")); }
/// <summary> /// 十六进制字符串 转 十进制Int32类型值 /// </summary> /// <param name="hexadecimal_string">十六进制字符串</param> /// <returns>十进制Int32类型值</returns> public static Int32 HexadecimalToDecimal(string hexadecimal_string, int deferrorval = 0) { hexadecimal_string = StringToHexadecimal(hexadecimal_string); if (CheckData.IsStringNull(hexadecimal_string)) { return(deferrorval); } return(Int32.Parse(hexadecimal_string, System.Globalization.NumberStyles.HexNumber)); }
/// <summary> /// string型转换为double型 /// </summary> /// <param name="expression">要转换的字符串</param> /// <param name="defvalue">缺省值</param> /// <returns>转换后的double类型结果</returns> public static double ToDouble(string expression, double defvalue) { if (CheckData.IsStringNull(expression)) { return(defvalue); } double v = defvalue; return(double.TryParse(expression, out v) ? v : defvalue); }
/// <summary> /// 获得解释特性信息 /// </summary> public static ExplainAttribute Extract(MemberInfo memberInfo) { ExplainAttribute explainAttr = ReflexHelp.AttributeFindOnly <ExplainAttribute>(memberInfo); if (CheckData.IsObjectNull(explainAttr)) { explainAttr = new ExplainAttribute(ERROR_EXPLAIN_TEXT); } return(explainAttr); }
/// <summary> /// 获取创建时间最新的 N 条记录 /// </summary> /// <param name="info">文件夹目录信息</param> /// <param name="N">最新几条</param> /// <returns>完成排序的目录列表</returns> public static DirectoryInfo[] UpToDateDirectorys(DirectoryInfo info, int index, int N) { if (CheckData.IsObjectNull(info)) { return(new DirectoryInfo[] { }); } List <DirectoryInfo> sondir = new List <DirectoryInfo>(info.GetDirectories()); sondir.Sort((d1, d2) => d1.CreationTime == d2.CreationTime ? 0 :d1.CreationTime > d2.CreationTime ? -1 : 1); return(ConvertTool.ToRangePage(sondir, index, N)); }
/// <summary> /// 字符串转字符串数组 /// </summary> /// <param name="strValue">要转化的字符串</param> /// <param name="Symbol">用于分隔的间隔符号</param> public static string[] ToArrayList(string strValue, IConvertible symbolSign) { try { if (CheckData.IsStringNull(strValue) || CheckData.IsObjectNull(symbolSign)) { throw new Exception(); } string[] strarr = strValue.Split(symbolSign.ToString().ToCharArray()); return(strarr); } catch (Exception) { return(new string[] { }); } }
/// <summary> /// 根据类型名称查找类型 /// </summary> /// <param name="typename">类型名称</param> /// <returns>类型</returns> public static Type ToType(string typename) { if (CheckData.IsStringNull(typename)) { return(null); } Type rtype = Type.GetType(typename); try { return(CheckData.IsObjectNull(rtype) ? null : rtype); } catch (Exception) { return(null); } }
/// <summary> /// 拼接随机字符串 /// </summary> /// <param name="source">指定字符进行拼接</param> /// <param name="max_charlength">指定字符个数</param> /// <returns>拼接结果</returns> public static string GetString(char[] source, int sum_length) { if (CheckData.IsSizeEmpty(source)) { return(string.Empty); } StringBuilder strbu = new StringBuilder(); for (int i = 0; i < sum_length; i++) { strbu.Append(Item(source)); } return(strbu.ToString()); }
/// <summary> /// 检查模型可以使用 多例 /// </summary> /// <typeparam name="M">数据模型类型</typeparam> /// <param name="array">数据来源</param> /// <param name="errorMethod">不能使用的判断条件</param> /// <returns>True: 可以使用, 反之亦然</returns> public static bool IsCanUse <M>(M[] array, Func <M, bool> errorMethod) where M : AbsBasicDataModel { if (!CheckData.IsSizeEmpty(array)) { foreach (M item in array) { if (IsCanUse(item, errorMethod)) { return(true); } } } return(false); }
/// <summary> /// 汉字转换为Unicode编码 (网络代码) /// </summary> /// <param name="gb2312_str">要编码的汉字字符串</param> /// <returns>Unicode编码的的字符串</returns> public static string GB2312ToUnicode(string gb2312_str) { if (CheckData.IsStringNull(gb2312_str)) { return(string.Empty); } byte[] bts = Encoding.Unicode.GetBytes(gb2312_str); string r = ""; for (int i = 0; i < bts.Length; i += 2) { r += "\\u" + bts[i + 1].ToString("x").PadLeft(2, '0') + bts[i].ToString("x").PadLeft(2, '0'); } return(r); }
/// <summary> /// 获取运行时间 /// </summary> /// <param name="method">需要执行的方法</param> /// <returns>执行方法所需的时间 单位: 秒</returns> public static double GetRunTime(Action method) { if (CheckData.IsObjectNull(method)) { method = () => { }; } Stopwatch stopwatch = new Stopwatch(); stopwatch.Start(); // 开始 method(); stopwatch.Stop(); // 结束 TimeSpan runtimeSpan = stopwatch.Elapsed; return(runtimeSpan.TotalSeconds); }
/// <summary> /// 是否存在这种名称的枚举选项 /// </summary> /// <typeparam name="E">枚举类型</typeparam> /// <param name="keyname">枚举名称</param> /// <returns>是否存在</returns> public static bool IsContains <E>(string keyname) { if (!typeof(E).IsEnum || CheckData.IsStringNull(keyname)) { return(false); } EnumInfo[] array = AnalysisList <E>(); foreach (EnumInfo info in array) { if (info.Name == keyname) { return(true); } } return(false); }
/// <summary> /// 过滤禁用的字符 /// </summary> /// <param name="source">需要处理的字符串</param> /// <param name="disable_chars">禁用字符列表</param> /// <returns>结果</returns> public static string FilterDisableChars(string source, char[] disable_chars) { if (CheckData.IsStringNull(source)) { return(string.Empty); } if (CheckData.IsSizeEmpty(disable_chars)) { return(source); } foreach (char c in disable_chars) { source = source.Replace(c.ToString(), ""); } return(source); }
/// <summary> /// 只读文件内容 /// </summary> /// <param name="file_path">文件路径</param> /// <param name="encoding">文件编码</param> /// <returns></returns> public static string OnlyRead(string file_path, Encoding encoding) { string abs_file_path = PathHelp.ToAbsolute(file_path); if (CheckData.IsStringNull(abs_file_path)) { return(string.Empty); } PathHelp.CreateFileExists(abs_file_path); using (FileStream rfs = File.OpenRead(abs_file_path)) { using (StreamReader sr = new StreamReader(rfs, encoding)) { string content = sr.ReadToEnd(); return(content); } } }
/// <summary> /// 将Unicode编码转换为汉字字符串 (网络代码) /// </summary> /// <param name="unicode_str">Unicode编码字符串</param> /// <returns>汉字字符串</returns> public static string UnicodeToGB2312(string unicode_str) { if (CheckData.IsStringNull(unicode_str)) { return(string.Empty); } string r = ""; MatchCollection mc = Regex.Matches(unicode_str, @"\\u([\w]{2})([\w]{2})", RegexOptions.Compiled | RegexOptions.IgnoreCase); byte[] bts = new byte[2]; foreach (Match m in mc) { bts[0] = (byte)int.Parse(m.Groups[2].Value, NumberStyles.HexNumber); bts[1] = (byte)int.Parse(m.Groups[1].Value, NumberStyles.HexNumber); r += Encoding.Unicode.GetString(bts); } return(r); }
/// <summary> /// 只写文件内容 /// </summary> /// <param name="file_path">文件路径</param> /// <param name="content">写入内容</param> /// <param name="encoding">文件编码</param> public static void OnlyWrite(string file_path, string content, Encoding encoding) { string abs_file_path = PathHelp.ToAbsolute(file_path); if (CheckData.IsStringNull(abs_file_path)) { return; } content = ConvertTool.ToString(content); File.Delete(abs_file_path); PathHelp.CreateFileExists(abs_file_path); using (FileStream wfs = File.OpenWrite(abs_file_path)) { using (StreamWriter sw = new StreamWriter(wfs, encoding)) { sw.Write(content); sw.Flush(); } } }
/// <summary> /// 将 不确定类型数据 转换为 指定数据类型值 /// </summary> /// <param name="type">指定数据类型</param> /// <param name="ov">不确定类型数据</param> /// <returns>确定类型数据</returns> public static object ToObject(Type type, object ov) { if (CheckData.IsObjectNull(type)) { return(ov); } if (CheckData.IsObjectNull(ov)) { return(type.IsValueType ? Activator.CreateInstance(type) : null); } if (CheckData.IsTypeEqualDepth(type, typeof(int), true)) { return(ToInt(ov, default(int))); } if (CheckData.IsTypeEqualDepth(type, typeof(Enum), true)) { return(ov.GetType().IsEnum ? (int)ov : ToInt(ov, default(int))); } if (CheckData.IsTypeEqualDepth(type, typeof(float), true)) { return(ToFloat(ov, default(float))); } if (CheckData.IsTypeEqualDepth(type, typeof(double), true)) { return(ToDouble(ov, default(double))); } if (CheckData.IsTypeEqualDepth(type, typeof(DateTime), true)) { Convert.ToDateTime(ov); return(ToDateTime(ov, default(DateTime))); } if (CheckData.IsTypeEqualDepth(type, typeof(bool), true)) { return(ToBool(ov, default(bool))); } if (CheckData.IsTypeEqualDepth(type, typeof(Type), true)) { string typename = ToString(ov); return(ToType(typename)); } return(ov); }
/// <summary> /// 所有子文件夹递归循环获取 /// </summary> /// <param name="olddir"></param> /// <returns></returns> public static DirectoryInfo[] AllSonDirectorys(DirectoryInfo olddir) { if (CheckData.IsObjectNull(olddir)) { return(new DirectoryInfo[] { }); } DirectoryInfo[] selfson = olddir.GetDirectories(); if (CheckData.IsSizeEmpty(selfson)) { return(new DirectoryInfo[] { }); } List <DirectoryInfo> sons = new List <DirectoryInfo>(selfson); foreach (DirectoryInfo item in selfson) { sons.AddRange(AllSonDirectorys(item)); } return(sons.ToArray()); }
/// <summary> /// 将对象转换为日期时间类型 /// </summary> /// <param name="obj">要转换的对象</param> /// <param name="defValue">缺省值</param> /// <returns></returns> public static DateTime ToDateTime(object obj, DateTime defValue) { if (CheckData.IsObjectNull(obj)) { return(defValue); } if (CheckData.IsTypeEqual(obj.GetType(), typeof(DateTime))) { return((DateTime)obj); } string s = obj.ToString(); if (CheckData.IsStringNull(s)) { return(defValue); } DateTime time; return(DateTime.TryParse(s, out time) ? time : defValue); }
/// <summary> /// 比较两个类型是否是一样的 /// </summary> /// <param name="t1">类型: 1</param> /// <param name="t2">类型: 2</param> /// <returns>是否相同</returns> public static bool IsTypeEqual(Type t1, Type t2) { if (CheckData.IsObjectNull(t1) && CheckData.IsObjectNull(t2)) { // 都为空 return(true); } if (CheckData.IsObjectNull(t1) && !CheckData.IsObjectNull(t2)) { // t1为空 t2不为空 return(false); } if (!CheckData.IsObjectNull(t1) && CheckData.IsObjectNull(t2)) { // t1不为空 t2为空 return(false); } // 都不为空 return(t1.Equals(t2) && t1.FullName == t2.FullName); }
/// <summary> /// 将相对路径转换为绝对路径 /// </summary> /// <param name="relative">一个'相对路径'</param> /// <returns>肯定是绝对路径的路径</returns> public static string ToAbsolute(string relative) { if (CheckData.IsStringNull(relative)) { return(string.Empty); } if (IsAbsolute(relative)) { return(relative); } if (!CheckData.IsObjectNull(HttpContext.Current)) { return(HttpContext.Current.Server.MapPath(relative)); } relative = relative.TrimStart('/'); relative = FilterDisablePathChar(relative); relative = Regex.Replace(relative, @"/{2,}", @"/"); relative = relative.Replace(@"/", @"\"); return(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, relative)); }
/// <summary> /// 比较两个类型是否是一样的 深入查询类型的继承链 (递归) /// </summary> /// <param name="depth_find_type">需要递归查询的类型</param> /// <param name="type">用于比较的类型</param> /// <param name="is_depth">是否深入查询</param> /// <returns>是否相同</returns> public static bool IsTypeEqualDepth(Type depth_find_type, Type type, bool is_depth) { if (IsTypeEqual(typeof(object), type)) { return(true); } if (!is_depth) { return(IsTypeEqual(depth_find_type, type)); } if (IsTypeEqual(depth_find_type, type)) { return(true); } if (CheckData.IsObjectNull(depth_find_type) || CheckData.IsObjectNull(type)) { return(false); } return(IsTypeEqualDepth(depth_find_type.BaseType, type, true)); }
/// <summary> /// 获取匹配文件名正则表达式的文件选项 /// </summary> /// <param name="info">文件夹目录信息</param> /// <param name="pattern">匹配文件名正则表达式</param> /// <returns>结果文件信息列表</returns> public static FileInfo[] PatternFileInfo(DirectoryInfo info, string pattern) { if (CheckData.IsObjectNull(info)) { return(new FileInfo[] { }); } List <FileInfo> sondir = new List <FileInfo>(info.GetFiles()); sondir.Sort((d1, d2) => d1.CreationTime == d2.CreationTime ? 0 : d1.CreationTime > d2.CreationTime ? 1 : -1); if (CheckData.IsStringNull(pattern)) { return(sondir.ToArray()); } for (int i = sondir.Count - 1; i >= 0; i--) { if (!Regex.IsMatch(sondir[i].Name, pattern, RegexOptions.IgnoreCase)) { sondir.RemoveAt(i); } } return(sondir.ToArray()); }