612 lines
17 KiB
C#
612 lines
17 KiB
C#
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Net;
|
|
using System.Reflection;
|
|
using System.Security.Cryptography;
|
|
using System.Text;
|
|
using System.Text.RegularExpressions;
|
|
using System.Xml;
|
|
using Newtonsoft.Json;
|
|
using NPinyin;
|
|
namespace Common.Utils
|
|
{
|
|
public static class ConvertExtension
|
|
{
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <param name="thisValue"></param>
|
|
/// <returns></returns>
|
|
public static int ObjToInt(this object thisValue)
|
|
{
|
|
int reval = 0;
|
|
if (thisValue == null) return 0;
|
|
if (thisValue != null && thisValue != DBNull.Value && int.TryParse(thisValue.ToString(), out reval))
|
|
{
|
|
return reval;
|
|
}
|
|
return reval;
|
|
}
|
|
public static bool ContainsAll<T>(this IEnumerable<T> source, IEnumerable<T> items)
|
|
{
|
|
if (source == null || items == null)
|
|
return false;
|
|
|
|
var sourceCounts = source.GroupBy(x => x).ToDictionary(g => g.Key, g => g.Count());
|
|
var itemsCounts = items.GroupBy(x => x).ToDictionary(g => g.Key, g => g.Count());
|
|
|
|
foreach (var item in itemsCounts)
|
|
{
|
|
if (!sourceCounts.TryGetValue(item.Key, out int count) || count < item.Value)
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public static IEnumerable<T> RemoveRange<T>(this IEnumerable<T> source, IEnumerable<T> items)
|
|
{
|
|
if (source == null)
|
|
return Enumerable.Empty<T>();
|
|
|
|
if (items == null || !items.Any())
|
|
return source;
|
|
|
|
var list = new List<T>(source);
|
|
|
|
foreach (var item in items)
|
|
{
|
|
int index = list.IndexOf(item);
|
|
if (index >= 0)
|
|
{
|
|
list.RemoveAt(index);
|
|
}
|
|
}
|
|
|
|
return list;
|
|
}
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <param name="thisValue"></param>
|
|
/// <param name="errorValue"></param>
|
|
/// <returns></returns>
|
|
public static int ObjToInt(this object thisValue, int errorValue)
|
|
{
|
|
int reval = 0;
|
|
if (thisValue != null && thisValue != DBNull.Value && int.TryParse(thisValue.ToString(), out reval))
|
|
{
|
|
return reval;
|
|
}
|
|
return errorValue;
|
|
}
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <param name="thisValue"></param>
|
|
/// <returns></returns>
|
|
public static long ObjToLong(this object thisValue)
|
|
{
|
|
long reval = 0;
|
|
if (thisValue == null) return 0;
|
|
if (thisValue != null && thisValue != DBNull.Value && long.TryParse(thisValue.ToString(), out reval))
|
|
{
|
|
return reval;
|
|
}
|
|
return reval;
|
|
}
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <param name="thisValue"></param>
|
|
/// <returns></returns>
|
|
public static double ObjToMoney(this object thisValue)
|
|
{
|
|
double reval = 0;
|
|
if (thisValue != null && thisValue != DBNull.Value && double.TryParse(thisValue.ToString(), out reval))
|
|
{
|
|
return reval;
|
|
}
|
|
return 0;
|
|
}
|
|
public static T GetRandomItem<T>(this IEnumerable<T> thisValue)
|
|
{
|
|
if (thisValue != null && thisValue.Count() > 0)
|
|
{
|
|
int index = Random.Shared.Next(thisValue.Count());
|
|
return thisValue.ToList()[index];
|
|
}
|
|
else if (thisValue.Count() == 1)
|
|
{
|
|
return thisValue.ToList()[0];
|
|
}
|
|
else
|
|
return default(T);
|
|
|
|
}
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <param name="thisValue"></param>
|
|
/// <param name="errorValue"></param>
|
|
/// <returns></returns>
|
|
public static double ObjToMoney(this object thisValue, double errorValue)
|
|
{
|
|
double reval = 0;
|
|
if (thisValue != null && thisValue != DBNull.Value && double.TryParse(thisValue.ToString(), out reval))
|
|
{
|
|
return reval;
|
|
}
|
|
return errorValue;
|
|
}
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <param name="thisValue"></param>
|
|
/// <returns></returns>
|
|
public static string ObjToString(this object thisValue)
|
|
{
|
|
if (thisValue != null) return thisValue.ToString().Trim();
|
|
return "";
|
|
}
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <param name="thisValue"></param>
|
|
/// <returns></returns>
|
|
public static bool IsNotEmptyOrNull(this IEnumerable<object> thisValue)
|
|
{
|
|
return thisValue != null && thisValue.Count() > 0; ;
|
|
}
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <param name="thisValue"></param>
|
|
/// <param name="errorValue"></param>
|
|
/// <returns></returns>
|
|
public static string ObjToString(this object thisValue, string errorValue)
|
|
{
|
|
if (thisValue != null) return thisValue.ToString().Trim();
|
|
return errorValue;
|
|
}
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <param name="thisValue"></param>
|
|
/// <returns></returns>
|
|
public static Decimal ObjToDecimal(this object thisValue)
|
|
{
|
|
Decimal reval = 0;
|
|
if (thisValue != null && thisValue != DBNull.Value && decimal.TryParse(thisValue.ToString(), out reval))
|
|
{
|
|
return reval;
|
|
}
|
|
return 0;
|
|
}
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <param name="thisValue"></param>
|
|
/// <returns></returns>
|
|
public static double ObjToDouble(this object thisValue)
|
|
{
|
|
double reval = 0;
|
|
if (thisValue != null && thisValue != DBNull.Value && double.TryParse(thisValue.ToString(), out reval))
|
|
{
|
|
return reval;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <param name="thisValue"></param>
|
|
/// <param name="errorValue"></param>
|
|
/// <returns></returns>
|
|
public static Decimal ObjToDecimal(this object thisValue, decimal errorValue)
|
|
{
|
|
Decimal reval = 0;
|
|
if (thisValue != null && thisValue != DBNull.Value && decimal.TryParse(thisValue.ToString(), out reval))
|
|
{
|
|
return reval;
|
|
}
|
|
return errorValue;
|
|
}
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <param name="thisValue"></param>
|
|
/// <returns></returns>
|
|
public static DateTime ObjToDate(this object thisValue)
|
|
{
|
|
DateTime reval = DateTime.MinValue;
|
|
if (thisValue != null && thisValue != DBNull.Value && DateTime.TryParse(thisValue.ToString(), out reval))
|
|
{
|
|
reval = Convert.ToDateTime(thisValue);
|
|
}
|
|
return reval;
|
|
}
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <param name="thisValue"></param>
|
|
/// <param name="errorValue"></param>
|
|
/// <returns></returns>
|
|
public static DateTime ObjToDate(this object thisValue, DateTime errorValue)
|
|
{
|
|
DateTime reval = DateTime.MinValue;
|
|
if (thisValue != null && thisValue != DBNull.Value && DateTime.TryParse(thisValue.ToString(), out reval))
|
|
{
|
|
return reval;
|
|
}
|
|
return errorValue;
|
|
}
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <param name="thisValue"></param>
|
|
/// <returns></returns>
|
|
public static bool ObjToBool(this object thisValue)
|
|
{
|
|
bool reval = false;
|
|
if (thisValue != null && thisValue != DBNull.Value && bool.TryParse(thisValue.ToString(), out reval))
|
|
{
|
|
return reval;
|
|
}
|
|
return reval;
|
|
}
|
|
|
|
public static DateTime ConvertToDateTime(this long timeStamp)
|
|
{
|
|
var dto = DateTimeOffset.FromUnixTimeSeconds(timeStamp);
|
|
return dto.ToLocalTime().DateTime;
|
|
}
|
|
public static DateTime ConvertToDateTime(this string timeStamp)
|
|
{
|
|
try
|
|
{
|
|
var dto = DateTimeOffset.FromUnixTimeSeconds(Convert.ToInt64(timeStamp));
|
|
return dto.ToLocalTime().DateTime;
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
throw new FormatException($"无效的Unix时间戳: {timeStamp}", e);
|
|
}
|
|
}
|
|
|
|
public static string DateToTimeStamp(this DateTime thisValue)
|
|
{
|
|
DateTimeOffset dto = new DateTimeOffset(thisValue);
|
|
return dto.ToUnixTimeSeconds().ToString();
|
|
}
|
|
public static decimal ToCeilingFixed2(this decimal value)
|
|
{
|
|
try
|
|
{
|
|
return Convert.ToInt32(Math.Ceiling(Math.Round(value * 100, 2))) / (decimal)100.0;
|
|
}
|
|
catch
|
|
{
|
|
return (decimal)0.0;
|
|
}
|
|
}
|
|
public static decimal ToFloorFixed2(this decimal value)
|
|
{
|
|
try
|
|
{
|
|
return Convert.ToInt32(Math.Floor(Math.Round(value * 100, 2))) / (decimal)100.0;
|
|
}
|
|
catch
|
|
{
|
|
return (decimal)0.0;
|
|
}
|
|
}
|
|
public static double ToCeilingFixed2(this double value)
|
|
{
|
|
try
|
|
{
|
|
return Convert.ToInt32(Math.Ceiling(Math.Round(value * 100, 2))) / 100.0;
|
|
}
|
|
catch
|
|
{
|
|
return 0.0;
|
|
}
|
|
}
|
|
|
|
public static double ToFloorFixed2(this double value)
|
|
{
|
|
try
|
|
{
|
|
return Convert.ToInt32(Math.Floor(Math.Round(value * 100, 2))) / 100.0;
|
|
}
|
|
catch
|
|
{
|
|
return 0.0;
|
|
}
|
|
}
|
|
public static string ConvertToPinyin(this string chinese)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(chinese))
|
|
return "*";
|
|
return Pinyin.GetPinyin(chinese).Trim().Replace(" ", "").ToUpper();
|
|
}
|
|
|
|
public static int ToCeilingInt(this double value)
|
|
{
|
|
try
|
|
{
|
|
return Convert.ToInt32(Math.Ceiling(Math.Round(value, 1)));
|
|
}
|
|
catch
|
|
{
|
|
return Convert.ToInt32(value);
|
|
}
|
|
}
|
|
public static int ToCeilingInt(this decimal value)
|
|
{
|
|
try
|
|
{
|
|
return Convert.ToInt32(Math.Ceiling(Math.Round(value, 1)));
|
|
}
|
|
catch
|
|
{
|
|
return Convert.ToInt32(value);
|
|
}
|
|
}
|
|
|
|
public static string[] Remove(this string[] value, string str)
|
|
{
|
|
List<string> valueList = value.ToList();
|
|
if (!valueList.Contains(str))
|
|
return value;
|
|
valueList.Remove(str);
|
|
return valueList.ToArray();
|
|
}
|
|
public static int[] Remove(this int[] value, int str)
|
|
{
|
|
List<int> valueList = value.ToList();
|
|
if (!valueList.Contains(str))
|
|
return value;
|
|
valueList.Remove(str);
|
|
return valueList.ToArray();
|
|
}
|
|
|
|
|
|
//
|
|
//
|
|
// time:
|
|
public static long ToTimeStamp(this DateTime time)
|
|
{
|
|
return new DateTimeOffset(time).ToUnixTimeSeconds();
|
|
}
|
|
|
|
//
|
|
//
|
|
// timeStamp:
|
|
public static DateTime ToDateTime(this long timeStamp)
|
|
{
|
|
return DateTimeOffset.FromUnixTimeSeconds(timeStamp).ToLocalTime().DateTime;
|
|
}
|
|
|
|
//
|
|
//
|
|
// obj:
|
|
public static string ToJson(this object obj)
|
|
{
|
|
return JsonConvert.SerializeObject(obj);
|
|
}
|
|
|
|
//
|
|
//
|
|
// str:
|
|
public static T ToObject<T>(this string str)
|
|
{
|
|
return JsonConvert.DeserializeObject<T>(str);
|
|
}
|
|
|
|
//
|
|
//
|
|
// str:
|
|
//
|
|
// IgnoreCapitalized:
|
|
public static string ToUrlEncode(this string str, bool IgnoreCapitalized = true)
|
|
{
|
|
return WebUtility.UrlEncode(IgnoreCapitalized ? str.ToLowerInvariant() : str);
|
|
}
|
|
|
|
//
|
|
//
|
|
// source:
|
|
//
|
|
// T:
|
|
//
|
|
// T:System.ArgumentException:
|
|
public static T Clone<T>(T source)
|
|
{
|
|
return JsonConvert.DeserializeObject<T>(source.ToJson());
|
|
}
|
|
|
|
|
|
//
|
|
//
|
|
// str:
|
|
public static string ToUrlDecode(this string str)
|
|
{
|
|
return WebUtility.UrlDecode(str);
|
|
}
|
|
|
|
//
|
|
//
|
|
// str:
|
|
public static string ToBase64String(this string str)
|
|
{
|
|
return Convert.ToBase64String(Encoding.Default.GetBytes(str));
|
|
}
|
|
|
|
//
|
|
//
|
|
// str:
|
|
public static string ToParseBase64(this string str)
|
|
{
|
|
try
|
|
{
|
|
byte[] bytes = Convert.FromBase64String(str);
|
|
return Encoding.Default.GetString(bytes);
|
|
}
|
|
catch
|
|
{
|
|
return "";
|
|
}
|
|
}
|
|
|
|
//
|
|
//
|
|
// value:
|
|
public static double ToDoubleFixed2(this double value)
|
|
{
|
|
try
|
|
{
|
|
return (double)Convert.ToInt32(Math.Ceiling(Math.Round(value * 100.0, 2))) / 100.0;
|
|
}
|
|
catch
|
|
{
|
|
return 0.0;
|
|
}
|
|
}
|
|
|
|
//
|
|
//
|
|
// value:
|
|
public static decimal ToDecimalFixed2(this decimal value)
|
|
{
|
|
try
|
|
{
|
|
return (decimal)Convert.ToInt32(Math.Ceiling(Math.Round(value * 100m, 2))) / 100m;
|
|
}
|
|
catch
|
|
{
|
|
return 0m;
|
|
}
|
|
}
|
|
|
|
//
|
|
//
|
|
// value:
|
|
public static double ToDoubleFloor2(this double value)
|
|
{
|
|
try
|
|
{
|
|
return (double)Convert.ToInt32(Math.Floor(Math.Round(value * 100.0, 2))) / 100.0;
|
|
}
|
|
catch
|
|
{
|
|
return 0.0;
|
|
}
|
|
}
|
|
|
|
//
|
|
//
|
|
// str:
|
|
//
|
|
public static string ToReverse(this string str)
|
|
{
|
|
return new string(str.ToCharArray().AsEnumerable().Reverse().ToArray());
|
|
}
|
|
|
|
//
|
|
//
|
|
// value:
|
|
public static decimal ToDecimalFloor2(this decimal value)
|
|
{
|
|
try
|
|
{
|
|
return (decimal)Convert.ToInt32(Math.Floor(Math.Round(value * 100m, 2))) / 100m;
|
|
}
|
|
catch
|
|
{
|
|
return 0m;
|
|
}
|
|
}
|
|
|
|
//
|
|
//
|
|
// content:
|
|
public static string ToDecodeBase64(this string content)
|
|
{
|
|
byte[] bytes = Convert.FromBase64String(content);
|
|
return Encoding.UTF8.GetString(bytes);
|
|
}
|
|
|
|
//
|
|
//
|
|
// mobile:
|
|
public static string ToHidMobile(this string mobile)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(mobile))
|
|
{
|
|
return "";
|
|
}
|
|
|
|
if (IsHandset(mobile))
|
|
{
|
|
return mobile.Substring(0, 3) + "****" + mobile.Substring(mobile.Length - 4, 4);
|
|
}
|
|
|
|
return mobile;
|
|
}
|
|
|
|
//
|
|
//
|
|
// str_handset:
|
|
public static bool IsHandset(string str_handset)
|
|
{
|
|
return Regex.IsMatch(str_handset, "^1[3456789]\\d{9}$");
|
|
}
|
|
|
|
//
|
|
//
|
|
// list:
|
|
//
|
|
// T:
|
|
public static bool IsNull<T>(this List<T> list)
|
|
{
|
|
if (list != null)
|
|
{
|
|
return !list.Any();
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
//
|
|
//
|
|
// source:
|
|
//
|
|
// isReplace:
|
|
//
|
|
// isToLower:
|
|
public static string ToSHA1Encrypt(this string source, bool isReplace = true, bool isToLower = false)
|
|
{
|
|
string text = BitConverter.ToString(SHA1.Create().ComputeHash(Encoding.UTF8.GetBytes(source)));
|
|
if (isReplace)
|
|
{
|
|
text = text.Replace("-", "");
|
|
}
|
|
|
|
if (isToLower)
|
|
{
|
|
text = text.ToLower();
|
|
}
|
|
|
|
return text;
|
|
}
|
|
|
|
}
|
|
}
|