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