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