/// <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="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>
/// 将对象转换为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>
/// 将对象转换为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>
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="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>
/// <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="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="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="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="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());
}
/// <summary>
/// 检查模型可以使用 单例
/// </summary>
/// <typeparam name="M">数据模型类型</typeparam>
/// <param name="item">数据来源</param>
/// <param name="errorMethod">不能使用的判断条件</param>
/// <returns>True: 可以使用, 反之亦然</returns>
public static bool IsCanUse <M>(M item, Func <M, bool> errorMethod) where M : AbsBasicDataModel
{
return(!(CheckData.IsObjectNull(item) || errorMethod(item)));
}
