721 lines
16 KiB
C#
721 lines
16 KiB
C#
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.ComponentModel;
|
|
using System.ComponentModel.DataAnnotations;
|
|
using System.Globalization;
|
|
using System.Linq;
|
|
using System.Linq.Expressions;
|
|
using System.Reflection;
|
|
using System.Text;
|
|
using System.Text.RegularExpressions;
|
|
|
|
namespace Hua.DotNet.Code.Extension;
|
|
|
|
public static class Ex
|
|
{
|
|
private class ParameterRebinder : ExpressionVisitor
|
|
{
|
|
private readonly Dictionary<ParameterExpression, ParameterExpression> map;
|
|
|
|
private ParameterRebinder(Dictionary<ParameterExpression, ParameterExpression> map)
|
|
{
|
|
this.map = map ?? new Dictionary<ParameterExpression, ParameterExpression>();
|
|
}
|
|
|
|
public static Expression ReplaceParameters(Dictionary<ParameterExpression, ParameterExpression> map, Expression exp)
|
|
{
|
|
return new ParameterRebinder(map).Visit(exp);
|
|
}
|
|
|
|
protected override Expression VisitParameter(ParameterExpression p)
|
|
{
|
|
if (map.TryGetValue(p, out ParameterExpression value))
|
|
{
|
|
p = value;
|
|
}
|
|
return base.VisitParameter(p);
|
|
}
|
|
}
|
|
|
|
public static long ToLong(this object obj)
|
|
{
|
|
try
|
|
{
|
|
return long.Parse(obj.ToString());
|
|
}
|
|
catch
|
|
{
|
|
return 0L;
|
|
}
|
|
}
|
|
|
|
public static long ToLong(this string str, long defaultValue)
|
|
{
|
|
try
|
|
{
|
|
return long.Parse(str);
|
|
}
|
|
catch
|
|
{
|
|
return defaultValue;
|
|
}
|
|
}
|
|
|
|
public static int ToInt(this object str)
|
|
{
|
|
try
|
|
{
|
|
return Convert.ToInt32(str);
|
|
}
|
|
catch
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
public static int ToInt(this object? str, int defaultValue)
|
|
{
|
|
if (str == null)
|
|
{
|
|
return defaultValue;
|
|
}
|
|
try
|
|
{
|
|
return Convert.ToInt32(str);
|
|
}
|
|
catch
|
|
{
|
|
return defaultValue;
|
|
}
|
|
}
|
|
|
|
public static short ToShort(this object obj)
|
|
{
|
|
try
|
|
{
|
|
return short.Parse(obj.ToString());
|
|
}
|
|
catch
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
public static short ToShort(this object str, short defaultValue)
|
|
{
|
|
try
|
|
{
|
|
return short.Parse(str.ToString());
|
|
}
|
|
catch
|
|
{
|
|
return defaultValue;
|
|
}
|
|
}
|
|
|
|
public static decimal ToDecimal(this object str, decimal defaultValue)
|
|
{
|
|
try
|
|
{
|
|
return decimal.Parse(str.ToString());
|
|
}
|
|
catch
|
|
{
|
|
return defaultValue;
|
|
}
|
|
}
|
|
|
|
public static decimal ToDecimal(this object str)
|
|
{
|
|
try
|
|
{
|
|
return decimal.Parse(str.ToString());
|
|
}
|
|
catch
|
|
{
|
|
return 0m;
|
|
}
|
|
}
|
|
|
|
public static bool ToBool(this object str)
|
|
{
|
|
try
|
|
{
|
|
return bool.Parse(str.ToString());
|
|
}
|
|
catch
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public static bool ToBool(this object str, bool result)
|
|
{
|
|
try
|
|
{
|
|
return bool.Parse(str.ToString());
|
|
}
|
|
catch
|
|
{
|
|
return result;
|
|
}
|
|
}
|
|
|
|
public static float ToFloat(this object str)
|
|
{
|
|
try
|
|
{
|
|
return float.Parse(str.ToString());
|
|
}
|
|
catch
|
|
{
|
|
return 0f;
|
|
}
|
|
}
|
|
|
|
public static float ToFloat(this object str, float result)
|
|
{
|
|
try
|
|
{
|
|
return float.Parse(str.ToString());
|
|
}
|
|
catch
|
|
{
|
|
return result;
|
|
}
|
|
}
|
|
|
|
public static Guid ToGuid(this string str)
|
|
{
|
|
try
|
|
{
|
|
return new Guid(str);
|
|
}
|
|
catch
|
|
{
|
|
return Guid.Empty;
|
|
}
|
|
}
|
|
|
|
public static DateTime ToDateTime(this string str)
|
|
{
|
|
try
|
|
{
|
|
if (string.IsNullOrWhiteSpace(str))
|
|
{
|
|
return DateTime.MinValue;
|
|
}
|
|
if (str.Contains("-") || str.Contains("/"))
|
|
{
|
|
return DateTime.Parse(str);
|
|
}
|
|
return str.Length switch
|
|
{
|
|
4 => DateTime.ParseExact(str, "yyyy", CultureInfo.CurrentCulture),
|
|
6 => DateTime.ParseExact(str, "yyyyMM", CultureInfo.CurrentCulture),
|
|
8 => DateTime.ParseExact(str, "yyyyMMdd", CultureInfo.CurrentCulture),
|
|
10 => DateTime.ParseExact(str, "yyyyMMddHH", CultureInfo.CurrentCulture),
|
|
12 => DateTime.ParseExact(str, "yyyyMMddHHmm", CultureInfo.CurrentCulture),
|
|
14 => DateTime.ParseExact(str, "yyyyMMddHHmmss", CultureInfo.CurrentCulture),
|
|
_ => DateTime.ParseExact(str, "yyyyMMddHHmmss", CultureInfo.CurrentCulture),
|
|
};
|
|
}
|
|
catch
|
|
{
|
|
return DateTime.MinValue;
|
|
}
|
|
}
|
|
|
|
public static DateTime ToDateTime(this string str, DateTime? defaultValue)
|
|
{
|
|
try
|
|
{
|
|
if (string.IsNullOrWhiteSpace(str))
|
|
{
|
|
return defaultValue.GetValueOrDefault();
|
|
}
|
|
if (str.Contains("-") || str.Contains("/"))
|
|
{
|
|
return DateTime.Parse(str);
|
|
}
|
|
return str.Length switch
|
|
{
|
|
4 => DateTime.ParseExact(str, "yyyy", CultureInfo.CurrentCulture),
|
|
6 => DateTime.ParseExact(str, "yyyyMM", CultureInfo.CurrentCulture),
|
|
8 => DateTime.ParseExact(str, "yyyyMMdd", CultureInfo.CurrentCulture),
|
|
10 => DateTime.ParseExact(str, "yyyyMMddHH", CultureInfo.CurrentCulture),
|
|
12 => DateTime.ParseExact(str, "yyyyMMddHHmm", CultureInfo.CurrentCulture),
|
|
14 => DateTime.ParseExact(str, "yyyyMMddHHmmss", CultureInfo.CurrentCulture),
|
|
_ => DateTime.ParseExact(str, "yyyyMMddHHmmss", CultureInfo.CurrentCulture),
|
|
};
|
|
}
|
|
catch
|
|
{
|
|
return defaultValue.GetValueOrDefault();
|
|
}
|
|
}
|
|
|
|
public static string ToString(this object? obj)
|
|
{
|
|
try
|
|
{
|
|
return (obj == null) ? string.Empty : obj.ToString();
|
|
}
|
|
catch
|
|
{
|
|
return string.Empty;
|
|
}
|
|
}
|
|
|
|
public static string ToStrings<T>(this object obj)
|
|
{
|
|
try
|
|
{
|
|
if (obj is IEnumerable<T> values)
|
|
{
|
|
return string.Join(",", values);
|
|
}
|
|
return obj.ToString();
|
|
}
|
|
catch
|
|
{
|
|
return string.Empty;
|
|
}
|
|
}
|
|
|
|
public static double ToDouble(this object obj)
|
|
{
|
|
try
|
|
{
|
|
return double.Parse(obj.ToString());
|
|
}
|
|
catch
|
|
{
|
|
return 0.0;
|
|
}
|
|
}
|
|
|
|
public static double ToDouble(this object str, double defaultValue)
|
|
{
|
|
try
|
|
{
|
|
return double.Parse(str.ToString());
|
|
}
|
|
catch
|
|
{
|
|
return defaultValue;
|
|
}
|
|
}
|
|
|
|
public static IEnumerable<TResult> CastSuper<TResult>(this IEnumerable source)
|
|
{
|
|
return from object item in source
|
|
select (TResult)Convert.ChangeType(item, typeof(TResult));
|
|
}
|
|
|
|
public static string Description(this object obj)
|
|
{
|
|
object obj2 = obj;
|
|
Type type = obj2.GetType();
|
|
if (!type.IsEnum)
|
|
{
|
|
return type.GetCustomAttribute<DescriptionAttribute>()?.Description ?? type.Name;
|
|
}
|
|
return type.GetFields().First((FieldInfo m) => m.Name == Enum.GetName(type, obj2)).GetCustomAttribute<DescriptionAttribute>()?.Description ?? type.Name;
|
|
}
|
|
|
|
public static string Description(this PropertyInfo value)
|
|
{
|
|
return value.GetCustomAttribute<DescriptionAttribute>()?.Description ?? value.Name;
|
|
}
|
|
|
|
public static string? DisplayName(this Enum enumValue)
|
|
{
|
|
string name = enumValue.ToString();
|
|
return enumValue.GetType().GetField(name)?.GetCustomAttribute<DisplayAttribute>()?.Name;
|
|
}
|
|
|
|
public static string DisplayName(this object obj)
|
|
{
|
|
object obj2 = obj;
|
|
Type type = obj2.GetType();
|
|
if (!type.IsEnum)
|
|
{
|
|
return type.GetCustomAttribute<DisplayAttribute>()?.Name ?? type.GetCustomAttribute<DisplayNameAttribute>()?.DisplayName ?? type.Name;
|
|
}
|
|
return type.GetFields().First((FieldInfo m) => m.Name == Enum.GetName(type, obj2)).GetCustomAttribute<DisplayAttribute>()?.Name ?? type.Name;
|
|
}
|
|
|
|
public static string DisplayName(this PropertyInfo value)
|
|
{
|
|
return value.GetCustomAttribute<DisplayAttribute>()?.Name ?? value.GetCustomAttribute<DisplayNameAttribute>()?.DisplayName ?? value.Name;
|
|
}
|
|
|
|
public static Dictionary<int, string> Dictionary(this Type enumType)
|
|
{
|
|
Dictionary<int, string> dictionary = new Dictionary<int, string>();
|
|
Type typeFromHandle = typeof(DescriptionAttribute);
|
|
FieldInfo[] fields = enumType.GetFields();
|
|
foreach (FieldInfo fieldInfo in fields)
|
|
{
|
|
if (fieldInfo.FieldType.IsEnum)
|
|
{
|
|
int key = (int)enumType.InvokeMember(fieldInfo.Name, BindingFlags.GetField, null, null, null);
|
|
object[] customAttributes = fieldInfo.GetCustomAttributes(typeFromHandle, inherit: true);
|
|
string value = ((customAttributes.Length == 0) ? fieldInfo.Name : ((DescriptionAttribute)customAttributes[0]).Description);
|
|
dictionary.Add(key, value);
|
|
}
|
|
}
|
|
return dictionary;
|
|
}
|
|
|
|
public static Expression Property(this Expression expression, string propertyName)
|
|
{
|
|
return Expression.Property(expression, propertyName);
|
|
}
|
|
|
|
public static Expression AndAlso(this Expression left, Expression right)
|
|
{
|
|
return Expression.AndAlso(left, right);
|
|
}
|
|
|
|
public static Expression Call(this Expression instance, string methodName, params Expression[] arguments)
|
|
{
|
|
return Expression.Call(instance, instance.Type.GetMethod(methodName), arguments);
|
|
}
|
|
|
|
public static Expression GreaterThan(this Expression left, Expression right)
|
|
{
|
|
return Expression.GreaterThan(left, right);
|
|
}
|
|
|
|
public static Expression<T> ToLambda<T>(this Expression body, params ParameterExpression[] parameters)
|
|
{
|
|
return Expression.Lambda<T>(body, parameters);
|
|
}
|
|
|
|
public static Expression<Func<T, bool>> True<T>()
|
|
{
|
|
return (T param) => true;
|
|
}
|
|
|
|
public static Expression<Func<T, bool>> False<T>()
|
|
{
|
|
return (T param) => false;
|
|
}
|
|
|
|
public static Expression<Func<T, bool>> And<T>(this Expression<Func<T, bool>> first, Expression<Func<T, bool>> second)
|
|
{
|
|
return first.Compose(second, Expression.AndAlso);
|
|
}
|
|
|
|
public static Expression<Func<T, bool>> Or<T>(this Expression<Func<T, bool>> first, Expression<Func<T, bool>> second)
|
|
{
|
|
return first.Compose(second, Expression.OrElse);
|
|
}
|
|
|
|
private static Expression<T> Compose<T>(this Expression<T> first, Expression<T> second, Func<Expression, Expression, Expression> merge)
|
|
{
|
|
Expression<T> second2 = second;
|
|
Expression arg = ParameterRebinder.ReplaceParameters(first.Parameters.Select((ParameterExpression f, int i) => new
|
|
{
|
|
f = f,
|
|
s = second2.Parameters[i]
|
|
}).ToDictionary(p => p.s, p => p.f), second2.Body);
|
|
return Expression.Lambda<T>(merge(first.Body, arg), first.Parameters);
|
|
}
|
|
|
|
public static string ToSmallCamelCase(string name)
|
|
{
|
|
StringBuilder stringBuilder = new StringBuilder();
|
|
stringBuilder.Append(name.Substring(0, 1).ToLower());
|
|
for (int i = 0; i < name.Length; i++)
|
|
{
|
|
if (i == 0)
|
|
{
|
|
stringBuilder.Append(name.Substring(0, 1).ToLower());
|
|
}
|
|
else if (name[i] >= 'A' && name[i] <= 'Z')
|
|
{
|
|
stringBuilder.Append("_" + name.Substring(i, 1).ToLower());
|
|
}
|
|
else
|
|
{
|
|
stringBuilder.Append(name[i]);
|
|
}
|
|
}
|
|
return stringBuilder.ToString();
|
|
}
|
|
|
|
public static string UnderScoreToCamelCase(this string underscore)
|
|
{
|
|
string[] array = underscore.Split('_');
|
|
if (array.Length == 1)
|
|
{
|
|
return underscore;
|
|
}
|
|
StringBuilder stringBuilder = new StringBuilder();
|
|
stringBuilder.Append(array[0]);
|
|
for (int i = 1; i < array.Length; i++)
|
|
{
|
|
stringBuilder.Append(array[i].FirstCharToUp());
|
|
}
|
|
return stringBuilder.ToString();
|
|
}
|
|
|
|
public static string FirstCharToUp(this string str)
|
|
{
|
|
if (!string.IsNullOrEmpty(str))
|
|
{
|
|
return str.Substring(0, 1).ToUpper() + str.Substring(1, str.Length - 1);
|
|
}
|
|
return str;
|
|
}
|
|
|
|
public static string FirstCharToLower(this string str)
|
|
{
|
|
if (!string.IsNullOrEmpty(str))
|
|
{
|
|
return str.Substring(0, 1).ToLower() + str.Substring(1, str.Length - 1);
|
|
}
|
|
return str;
|
|
}
|
|
|
|
public static string ConvertToPascal(this string fieldName, string fieldDelimiter)
|
|
{
|
|
string empty = string.Empty;
|
|
if (fieldName.Contains(fieldDelimiter))
|
|
{
|
|
return fieldName.ToLower().Split(fieldDelimiter.ToCharArray()).Aggregate(empty, (string current, string t) => current + t.Substring(0, 1).ToUpper() + t.Substring(1, t.Length - 1));
|
|
}
|
|
if (string.IsNullOrWhiteSpace(fieldName))
|
|
{
|
|
return fieldName;
|
|
}
|
|
if (fieldName.Length == 1)
|
|
{
|
|
return fieldName.ToUpper();
|
|
}
|
|
if (fieldName.Length == fieldName.CountUpper())
|
|
{
|
|
return fieldName.Substring(0, 1).ToUpper() + fieldName.Substring(1, fieldName.Length - 1).ToLower();
|
|
}
|
|
return fieldName.Substring(0, 1).ToUpper() + fieldName.Substring(1, fieldName.Length - 1);
|
|
}
|
|
|
|
public static string ConvertToCamel(this string fieldName, string fieldDelimiter)
|
|
{
|
|
string text = fieldName.ConvertToPascal(fieldDelimiter);
|
|
if (text.Length == 1)
|
|
{
|
|
return text.ToLower();
|
|
}
|
|
return text.Substring(0, 1).ToLower() + text.Substring(1, text.Length - 1);
|
|
}
|
|
|
|
public static string ToSbc(this string input)
|
|
{
|
|
char[] array = input.ToCharArray();
|
|
for (int i = 0; i < array.Length; i++)
|
|
{
|
|
if (array[i] == ' ')
|
|
{
|
|
array[i] = '\u3000';
|
|
}
|
|
else if (array[i] < '\u007f')
|
|
{
|
|
array[i] = (char)(array[i] + 65248);
|
|
}
|
|
}
|
|
return new string(array);
|
|
}
|
|
|
|
public static string ToDbc(this string input)
|
|
{
|
|
char[] array = input.ToCharArray();
|
|
for (int i = 0; i < array.Length; i++)
|
|
{
|
|
if (array[i] == '\u3000')
|
|
{
|
|
array[i] = ' ';
|
|
}
|
|
else if (array[i] > '\uff00' && array[i] < '｟')
|
|
{
|
|
array[i] = (char)(array[i] - 65248);
|
|
}
|
|
}
|
|
return new string(array);
|
|
}
|
|
|
|
public static string HtmlToTxt(this string strHtml)
|
|
{
|
|
string[] obj = new string[15]
|
|
{
|
|
"<script[^>]*?>.*?</script>", "<(\\/\\srcStr*)?!?((\\w+:)?\\w+)(\\w+(\\srcStr*=?\\srcStr*(([\"'])(\\\\[\"'tbnr]|[^\\7])*?\\7|\\w+)|.{0})|\\srcStr)*?(\\/\\srcStr*)?>", "([\\r\\n])[\\srcStr]+", "&(quot|#34);", "&(amp|#38);", "&(lt|#60);", "&(gt|#62);", "&(nbsp|#160);", "&(iexcl|#161);", "&(cent|#162);",
|
|
"&(pound|#163);", "&(copy|#169);", "&#(\\d+);", "-->", "<!--.*\\n"
|
|
};
|
|
_ = obj[0];
|
|
return obj.Select((string t) => new Regex(t, RegexOptions.IgnoreCase)).Aggregate(strHtml, (string current, Regex regex) => regex.Replace(current, string.Empty)).Replace("<", "")
|
|
.Replace(">", "")
|
|
.Replace("\r\n", "");
|
|
}
|
|
|
|
public static string Base64Encode(this string src)
|
|
{
|
|
return Convert.ToBase64String(Encoding.UTF8.GetBytes(src));
|
|
}
|
|
|
|
public static string Base64DeCode(this string src)
|
|
{
|
|
byte[] bytes = Convert.FromBase64String(src);
|
|
return Encoding.UTF8.GetString(bytes);
|
|
}
|
|
|
|
public static bool HasChinese(this string str)
|
|
{
|
|
return Regex.IsMatch(str, "[\\u4e00-\\u9fa5]");
|
|
}
|
|
|
|
public static string TrimStartStr(this string s, string searchStr)
|
|
{
|
|
string text = s;
|
|
try
|
|
{
|
|
if (string.IsNullOrEmpty(text))
|
|
{
|
|
return text;
|
|
}
|
|
if (s.Length < searchStr.Length)
|
|
{
|
|
return text;
|
|
}
|
|
if (s.IndexOf(searchStr, 0, searchStr.Length, StringComparison.Ordinal) > -1)
|
|
{
|
|
text = s.Substring(searchStr.Length, s.Length - searchStr.Length);
|
|
}
|
|
return text;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
return text;
|
|
}
|
|
}
|
|
|
|
public static string TrimEndStr(this string srcStr, string desStr)
|
|
{
|
|
return srcStr.Substring(0, srcStr.Length - desStr.Length);
|
|
}
|
|
|
|
public static string ReplaceFirstStr(this string input, string oldValue, string? newValue)
|
|
{
|
|
return new Regex(oldValue, RegexOptions.Multiline).Replace(input, newValue ?? "", 1);
|
|
}
|
|
|
|
public static List<string> GetSubStringList(this string oStr, char split)
|
|
{
|
|
return (from s in oStr.Split(split)
|
|
where !string.IsNullOrEmpty(s) && s != split.ToString()
|
|
select s).ToList();
|
|
}
|
|
|
|
public static string[]? SplitMulti(this string str, string splitStr)
|
|
{
|
|
string[] result = null;
|
|
if (!string.IsNullOrEmpty(str))
|
|
{
|
|
result = new Regex(splitStr).Split(str);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
public static string SubstringBetween(this string src, string startStr, string endStr)
|
|
{
|
|
string result = string.Empty;
|
|
try
|
|
{
|
|
int num = src.IndexOf(startStr, StringComparison.Ordinal);
|
|
if (num == -1)
|
|
{
|
|
return result;
|
|
}
|
|
string text = src.Substring(num + startStr.Length);
|
|
int num2 = text.IndexOf(endStr, StringComparison.Ordinal);
|
|
if (num2 == -1)
|
|
{
|
|
return result;
|
|
}
|
|
result = text.Remove(num2);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Console.WriteLine("MidStrEx Err:" + ex.Message);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
public static bool IsMatch(this string str, string express)
|
|
{
|
|
if (string.IsNullOrEmpty(str))
|
|
{
|
|
return false;
|
|
}
|
|
Regex regex = new Regex(express);
|
|
if (str.Length != 0)
|
|
{
|
|
return regex.IsMatch(str);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public static bool IsNullOrEmpty(this string str)
|
|
{
|
|
return string.IsNullOrEmpty(str);
|
|
}
|
|
|
|
public static bool IsNullOrEmpty(object? data)
|
|
{
|
|
if (data == null || (data is string && string.IsNullOrEmpty(data.ToString().Trim())))
|
|
{
|
|
return true;
|
|
}
|
|
return data is DBNull;
|
|
}
|
|
|
|
public static int CountUpper(this string str)
|
|
{
|
|
int num = 0;
|
|
char[] array = str.ToCharArray();
|
|
foreach (char c in array)
|
|
{
|
|
if (c >= 'A' && c <= 'Z')
|
|
{
|
|
num++;
|
|
}
|
|
}
|
|
return num;
|
|
}
|
|
|
|
public static bool IsNullOrEmpty<T>(T t)
|
|
{
|
|
if (t == null)
|
|
{
|
|
return true;
|
|
}
|
|
if (!(t is string))
|
|
{
|
|
return t is DBNull;
|
|
}
|
|
if (string.IsNullOrEmpty(t.ToString().Trim()))
|
|
{
|
|
return true;
|
|
}
|
|
return t is DBNull;
|
|
}
|
|
|
|
public static List<PropertyInfo>? GetProperties<T>(this T t)
|
|
{
|
|
return t?.GetType().GetProperties(BindingFlags.Instance | BindingFlags.Public).ToList();
|
|
}
|
|
}
|