/// <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> /// <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> /// <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> /// <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> /// 汉字转换为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> /// <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> /// 只写文件内容 /// </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> /// 将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="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="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="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()); }
/// <summary> /// 创建使用文件路径 /// </summary> /// <param name="directory">使用文件的文件夹路径</param> /// <param name="filename">文件名称</param> /// <returns>绝对路径的文件路径</returns> public static string CreateUseFilePath(string directory, string filename) { directory = ConvertTool.ToString(directory); if (CheckData.IsStringNull(directory)) { directory = @"/"; } filename = ConvertTool.ToString(filename); if (CheckData.IsStringNull(filename)) { return(string.Empty); } string abs_directory = ToAbsolute(directory).TrimEnd('\\'); if (!Directory.Exists(abs_directory)) { Directory.CreateDirectory(abs_directory); } string abs_filename = FilterDisableFileNameChar(filename); return(string.Format("{0}\\{1}", abs_directory, abs_filename)); }
/// <summary> /// 十六进制值转为Unicode格式字符串 /// </summary> /// <param name="hexadecimal_string">十六进制字符串</param> /// <returns></returns> public static string UnicodeFormatString(string hexadecimal_string) { string result_str = hexadecimal_string; // string 引用地址的问题 result_str = StringToHexadecimal(result_str); if (CheckData.IsStringNull(result_str)) { return(string.Empty); } if (result_str.Length < 4) { int cha = 4 - result_str.Length; for (int i = 0; i < cha; i++) { result_str = @"0" + result_str; } } else if (result_str.Length > 4) { result_str = result_str.Substring(result_str.Length - 4, 4); } return(string.Format("\\u{0}", result_str)); }
/// <summary> /// 转为程序可用不报错字符串 /// </summary> /// <param name="sv">字符串类型值</param> /// <returns>可用不报错字符串</returns> public static string ToString(string sv) { return(CheckData.IsStringNull(sv) ? string.Empty : sv.ToString()); }