DEMOMySql/MicroServices/Business/Business.Core/Utilities/StringExtensions.cs

using System;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;

namespace Business.Core.Utilities
{
    public static class StringExtensions
    {
        /// <summary>
        /// 去掉字符串所有空格
        /// </summary>
        /// <param name="str">字符串</param>
        /// <returns></returns>
        public static string TrimAll(this string? str)
        {
            return string.IsNullOrWhiteSpace(str) ? string.Empty : Regex.Replace(str, @"\s", "");
        }

        /// <summary>
        /// 去掉空格，如果为null或Empty则返回string.Empty
        /// </summary>
        /// <param name="str"></param>
        /// <returns></returns>
        public static string TrimNullOrEmpty(this string? str)
        {
            return string.IsNullOrEmpty(str) ? string.Empty : str.Trim();
        }

        /// <summary>
        /// 转换为不为空的字符串
        /// </summary>
        /// <param name="str">字符串</param>
        /// <returns>如果字符串为null返回string.Empty，否则返回字符串本身。</returns>
        public static string ToEmptyString(this string? str)
        {
            return string.IsNullOrEmpty(str) ? string.Empty : str;
        }

        /// <summary>
        /// 将字符串分割为数组
        /// </summary>
        /// <param name="str">要分割的字符串</param>
        /// <param name="separator">分隔符</param>
        /// <param name="options">分割选项</param>
        /// <returns>字符串数组</returns>
        public static string[] SplitToArray(this string? str, string separator = ",", StringSplitOptions options = StringSplitOptions.RemoveEmptyEntries)
        {
            return string.IsNullOrWhiteSpace(str) ? Array.Empty<string>() : str.Split(separator, options);
        }

        /// <summary>
        /// 将字符串分割为long数组
        /// </summary>
        /// <param name="str">要分割的字符串</param>
        /// <param name="separator">分隔符</param>
        /// <param name="options">分割选项</param>
        /// <returns>long List</returns>
        public static List<long> SplitToLongList(this string? str, string separator = ",", StringSplitOptions options = StringSplitOptions.RemoveEmptyEntries)
        {
            string[] array = str.SplitToArray(separator, options);
            var list = new List<long>();
            foreach (string a in array)
            {
                if (a.IsLong(out long l))
                {
                    list.Add(l);
                }
            }
            return list;
        }

        /// <summary>
        /// 将字符串分割为int数组
        /// </summary>
        /// <param name="str">要分割的字符串</param>
        /// <param name="separator">分隔符</param>
        /// <param name="options">分割选项</param>
        /// <returns>int List</returns>
        public static List<int> SplitToIntList(this string? str, string separator = ",", StringSplitOptions options = StringSplitOptions.RemoveEmptyEntries)
        {
            string[] array = str.SplitToArray(separator, options);
            var list = new List<int>();
            foreach (string a in array)
            {
                if (a.IsInt(out int i))
                {
                    list.Add(i);
                }
            }
            return list;
        }


        /// <summary>
        /// 判断字符串是否是int类型数字
        /// </summary>
        /// <param name="str">字符串</param>
        /// <returns></returns>
        public static bool IsInt(this string? str)
        {
            return int.TryParse(str, out _);
        }

        /// <summary>
        /// 判断字符串是否是int类型数字
        /// </summary>
        /// <param name="str">字符串</param>
        /// <param name="i">如果是数字返回int</param>
        /// <returns></returns>
        public static bool IsInt(this string? str, out int i)
        {
            return int.TryParse(str, out i);
        }

        /// <summary>
        /// 将字符串转换为int
        /// </summary>
        /// <param name="str">字符串</param>
        /// <param name="defaultValue">转换失败时的默认值</param>
        /// <returns></returns>
        public static int ToInt(this string? str, int defaultValue = 0)
        {
            return str.IsInt(out int i) ? i : defaultValue;
        }

        /// <summary>
        /// 判断字符串是否是long类型数字
        /// </summary>
        /// <param name="str">字符串</param>
        /// <returns></returns>
        public static bool IsLong(this string? str)
        {
            return long.TryParse(str, out _);
        }

        /// <summary>
        /// 判断字符串是否是long类型数字
        /// </summary>
        /// <param name="str">字符串</param>
        /// <param name="i">如果是数字返回long</param>
        /// <returns></returns>
        public static bool IsLong(this string? str, out long l)
        {
            return long.TryParse(str, out l);
        }

        /// <summary>
        /// 将字符串转换为long
        /// </summary>
        /// <param name="str">字符串</param>
        /// <param name="defaultValue">转换失败时的默认值</param>
        /// <returns></returns>
        public static long ToLong(this string? str, long defaultValue = 0)
        {
            return str.IsLong(out long l) ? l : defaultValue;
        }

        /// <summary>
        /// 判断字符串是否是decimal类型数字
        /// </summary>
        /// <param name="str">字符串</param>
        /// <returns></returns>
        public static bool IsDecimal(this string? str)
        {
            return decimal.TryParse(str, out _);
        }

        /// <summary>
        /// 判断字符串是否是decimal类型数字
        /// </summary>
        /// <param name="str">字符串</param>
        /// <returns></returns>
        public static bool IsDecimal(this string? str, out decimal d)
        {
            return decimal.TryParse(str, out d);
        }

        /// <summary>
        /// 字符串转换为decimal类型数字
        /// </summary>
        /// <param name="str">字符串</param>
        /// <param name="defaultValue">转换失败时的默认值</param>
        /// <returns></returns>
        public static decimal ToDecimal(this string? str, decimal defaultValue = 0)
        {
            return str.IsDecimal(out decimal d) ? d : defaultValue;
        }

        /// <summary>
        /// 判断字符串是否是float类型数字
        /// </summary>
        /// <param name="str">字符串</param>
        /// <returns></returns>
        public static bool IsFloat(this string? str, out float f)
        {
            return float.TryParse(str, out f);
        }

        /// <summary>
        /// 字符串转换为float类型数字
        /// </summary>
        /// <param name="str">字符串</param>
        /// <param name="defaultValue">转换失败时的默认值</param>
        /// <returns></returns>
        public static float ToFloat(this string? str, float defaultValue = 0)
        {
            return str.IsFloat(out float f) ? f : defaultValue;
        }

        /// <summary>
        /// 判断字符串是否是double类型数字
        /// </summary>
        /// <param name="str">字符串</param>
        /// <returns></returns>
        public static bool IsDouble(this string? str, out double d)
        {
            return double.TryParse(str, out d);
        }

        /// <summary>
        /// 字符串转换为double类型数字
        /// </summary>
        /// <param name="str">字符串</param>
        /// <param name="defaultValue">转换失败时的默认值</param>
        /// <returns></returns>
        public static double ToDouble(this string? str, double defaultValue = 0)
        {
            return str.IsDouble(out double d) ? d : defaultValue;
        }

        /// <summary>
        /// 判断字符串是否为bool类型
        /// </summary>
        /// <param name="str">字符串</param>
        /// <param name="b"></param>
        /// <returns>如果字符串为"1"或"true"（不区分大小写，去掉所有空格）时返回true否则返回false</returns>
        public static bool IsBool(this string? str)
        {
            if (string.IsNullOrEmpty(str))
            {
                return false;
            }
            string str1 = str.TrimAll();
            return "true".EqualsIgnoreCase(str1) || "1".Equals(str1);
        }

        /// <summary>
        /// 将字符串转换为bool
        /// </summary>
        /// <param name="str">字符串</param>
        /// <returns>如果字符串为1或true（不区分大小写），则返回true，否则返回false</returns>
        public static bool ToBool(this string? str)
        {
            return str.IsBool();
        }

        /// <summary>
        /// 判断一个字符串是否是日期时间类型
        /// </summary>
        /// <param name="str">字符串</param>
        /// <param name="dt">输出转换后的日期时间</param>
        /// <returns></returns>
        public static bool IsDateTime(this string? str, out DateTime dt)
        {
            return DateTime.TryParse(str, out dt);
        }

        /// <summary>
        /// 判断一个字符串是否是日期时间类型
        /// </summary>
        /// <param name="str">字符串</param>
        /// <returns></returns>
        public static bool IsDateTime(this string? str)
        {
            return str.IsDateTime(out _);
        }

        /// <summary>
        /// 将字符串转换为时间时间
        /// </summary>
        /// <param name="str">要转换的字符串</param>
        /// <param name="defaultValue">转换失败时返回的默认值</param>
        /// <returns></returns>
        public static DateTime ToDateTime(this string? str, DateTime defaultValue)
        {
            return str.IsDateTime(out DateTime dt) ? dt : defaultValue;
        }

        /// <summary>
        /// 将字符串转换为时间时间
        /// </summary>
        /// <param name="str">要转换的字符串</param>
        /// <param name="defaultValue">转换失败时返回的默认值</param>
        /// <returns>如果转换失败则返回null</returns>
        public static DateTime? ToDateTime(this string? str)
        {
            return str.IsDateTime(out DateTime dt) ? dt : new DateTime?();
        }

        /// <summary>
        /// 比较字符串区分大小写
        /// </summary>
        /// <param name="str">字符串</param>
        /// <param name="str1">要比较的字符串</param>
        /// <returns>是否相同</returns>
        public static bool EqualsCase(this string? str, string? str1)
        {
            return string.Equals(str, str1);
        }

        /// <summary>
        /// 比较字符串是否与参数中任意一个字符串相等
        /// </summary>
        /// <param name="str">字符串</param>
        /// <param name="strs">要比较的字符串</param>
        /// <returns>是否与参数中任意一个字符串相等</returns>
        public static bool EqualsAny(this string? str, params string[] strs)
        {
            if (string.IsNullOrEmpty(str))
            {
                return false;
            }
            foreach (string s in strs)
            {
                if (s.Equals(str))
                {
                    return true;
                }
            }
            return false;
        }

        /// <summary>
        /// 判断字符串与参数中的字符串都不相等
        /// </summary>
        /// <param name="str">字符串</param>
        /// <param name="strs">要比较的字符串</param>
        /// <returns></returns>
        public static bool NotEqualsAny(this string? str, params string[] strs)
        {
            if (string.IsNullOrEmpty(str))
            {
                return false;
            }
            foreach (string s in strs)
            {
                if (s.Equals(str))
                {
                    return false;
                }
            }
            return true;
        }

        /// <summary>
        /// 比较字符串不区分大小写
        /// </summary>
        /// <param name="str">字符串</param>
        /// <param name="str1">要比较的字符串</param>
        /// <returns>是否相同</returns>
        public static bool EqualsIgnoreCase(this string? str, string? str1)
        {
            return string.Equals(str, str1, StringComparison.CurrentCultureIgnoreCase);
        }

        /// <summary>
        /// 比较字符串是否与参数中任意一个字符串相等（不区分大小写）
        /// </summary>
        /// <param name="str">字符串</param>
        /// <param name="strs">要比较的字符串</param>
        /// <returns>是否与参数中任意一个字符串相等</returns>
        public static bool EqualsAnyIgnoreCase(this string? str, params string[] strs)
        {
            if (string.IsNullOrEmpty(str))
            {
                return false;
            }
            foreach (string s in strs)
            {
                if (s.Equals(str, StringComparison.CurrentCultureIgnoreCase))
                {
                    return true;
                }
            }
            return false;
        }

        /// <summary>
        /// 判断字符串与参数中的字符串都不相等（不区分大小写）
        /// </summary>
        /// <param name="str">字符串</param>
        /// <param name="strs">要比较的字符串</param>
        /// <returns>是否与参数中任意一个字符串相等</returns>
        public static bool NotEqualsAnyIgnoreCase(this string? str, params string[] strs)
        {
            if (string.IsNullOrEmpty(str))
            {
                return false;
            }
            foreach (string s in strs)
            {
                if (s.Equals(str, StringComparison.CurrentCultureIgnoreCase))
                {
                    return false;
                }
            }
            return true;
        }

        /// <summary>
        /// 判断字符串中是否包含str1字符串（区分大小写）
        /// </summary>
        /// <param name="str">字符串</param>
        /// <param name="str1">被包含的字符串</param>
        /// <param name="stringComparison">StringComparison</param>
        /// <returns></returns>
        public static bool ContainsCase(this string? str, string? str1)
        {
            return str != null && str1 != null && str.Contains(str1);
        }

        /// <summary>
        /// 判断字符串中是否包含str1字符串（不区分大小写）
        /// </summary>
        /// <param name="str">字符串</param>
        /// <param name="str1">被包含的字符串</param>
        /// <returns></returns>
        public static bool ContainsIgnoreCase(this string? str, string? str1)
        {
            return str != null && str1 != null && str.Contains(str1, StringComparison.CurrentCultureIgnoreCase);
        }

        /// <summary>
        /// 判断字符串出现的位置（为区分大小写）
        /// </summary>
        /// <param name="str">字符串</param>
        /// <param name="str1">子字符串</param>
        /// <returns></returns>
        public static int IndexOfIgnoreCase(this string? str, string str1)
        {
            return str == null ? -1 : str.IndexOf(str1, StringComparison.CurrentCultureIgnoreCase);
        }

        /// <summary>
        /// 去掉开头的字符串
        /// </summary>
        /// <param name="str">要去掉的字符串</param>
        /// <param name="trimString">开头的字符串</param>
        /// <returns></returns>
        public static string TrimStartString(this string? str, string trimString)
        {
            return string.IsNullOrWhiteSpace(str) ? string.Empty : !str.StartsWith(trimString) ? str : str.Substring(trimString.Length);
        }

        /// <summary>
        /// 去掉开头的字符串（不区分大小写）
        /// </summary>
        /// <param name="str">要去掉的字符串</param>
        /// <param name="trimString">开头的字符串</param>
        /// <returns></returns>
        public static string TrimStartStringIgnoreCase(this string? str, string trimString)
        {
            return string.IsNullOrWhiteSpace(str) ? string.Empty : !str.StartsWithIgnoreCase(trimString) ? str : str.Substring(trimString.Length);
        }

        /// <summary>
        /// 去掉结尾的字符串
        /// </summary>
        /// <param name="str">要去掉的字符串</param>
        /// <param name="trimString">结尾的字符串</param>
        /// <returns></returns>
        public static string TrimEndString(this string? str, string trimString)
        {
            return string.IsNullOrWhiteSpace(str) ? string.Empty : !str.EndsWith(trimString) ? str : str.Substring(0, str.Length - trimString.Length);
        }

        /// <summary>
        /// 去掉结尾的字符串（不区分大小写）
        /// </summary>
        /// <param name="str">要去掉的字符串</param>
        /// <param name="trimString">结尾的字符串</param>
        /// <returns></returns>
        public static string TrimEndStringIgnoreCase(this string? str, string trimString)
        {
            return string.IsNullOrWhiteSpace(str) ? string.Empty : !str.EndsWithIgnoreCase(trimString) ? str : str.Substring(0, str.Length - trimString.Length);
        }

        /// <summary>
        /// 是否是以字符串数组参数中任意一个字符串开头的字符串
        /// </summary>
        /// <param name="str">字符串</param>
        /// <param name="values">开头的字符串数组</param>
        /// <returns></returns>
        public static bool StartsWithAny(this string? str, params string[] values)
        {
            if (string.IsNullOrEmpty(str))
            {
                return false;
            }
            foreach (string value in values)
            {
                if (str.StartsWith(value))
                {
                    return true;
                }
            }
            return false;
        }

        /// <summary>
        /// 是否是以字符串数组参数中任意一个字符串开头的字符串
        /// </summary>
        /// <param name="str">字符串</param>
        /// <param name="stringComparison">StringComparison, 可设置是否区分大小写</param>
        /// <param name="values">开头的字符串数组</param>
        /// <returns></returns>
        public static bool StartsWithAny(this string? str, StringComparison stringComparison, params string[] values)
        {
            if (string.IsNullOrEmpty(str))
            {
                return false;
            }
            foreach (string value in values)
            {
                if (str.StartsWith(value, stringComparison))
                {
                    return true;
                }
            }
            return false;
        }

        /// <summary>
        /// 判断字符串是否以某个字符串开头（不区分大小写）
        /// </summary>
        /// <param name="str">要判断的字符串</param>
        /// <param name="startString">开头的字符串</param>
        /// <returns></returns>
        public static bool StartsWithIgnoreCase(this string? str, string startString)
        {
            return !string.IsNullOrEmpty(str) && str.StartsWith(startString, StringComparison.CurrentCultureIgnoreCase);
        }

        /// <summary>
        /// 判断字符串是否以某个字符串结尾（不区分大小写）
        /// </summary>
        /// <param name="str">要判断的字符串</param>
        /// <param name="startString">结尾的字符串</param>
        /// <returns></returns>
        public static bool EndsWithIgnoreCase(this string? str, string startString)
        {
            return !string.IsNullOrEmpty(str) && str.EndsWith(startString, StringComparison.CurrentCultureIgnoreCase);
        }

        /// <summary>
        /// 替换字符串，不区分大不写
        /// </summary>
        /// <param name="str">字符串</param>
        /// <param name="oldValue">要替换的字符串</param>
        /// <param name="newValue">新字符串</param>
        /// <returns></returns>
        public static string ReplaceIgnoreCase(this string? str, string oldValue, string? newValue)
        {
            return string.IsNullOrEmpty(str) ? string.Empty : str.Replace(oldValue, newValue, StringComparison.CurrentCultureIgnoreCase);
        }

        /// <summary>
        /// 将字符串转换为对应类型的对象
        /// </summary>
        /// <param name="str">字符串</param>
        /// <returns></returns>
        public static object ToTypeObject(this string? str, out Type type)
        {
            if (string.IsNullOrEmpty(str) || str.EqualsIgnoreCase("null"))
            {
                type = typeof(string);
                return string.Empty;
            }
            else if (str.IsInt(out int objInt))
            {
                type = typeof(int);
                return objInt;
            }
            else if (str.IsLong(out long objLong))
            {
                type = typeof(long);
                return objLong;
            }
            else if (Guid.TryParse(str, out Guid objGuid))
            {
                type = typeof(Guid);
                return objGuid;
            }
            else if (str.IsFloat(out float objFloat))
            {
                type = typeof(float);
                return objFloat;
            }
            else if (str.IsDouble(out double objDouble))
            {
                type = typeof(double);
                return objDouble;
            }
            else if (str.IsDecimal(out decimal objDecimal))
            {
                type = typeof(decimal);
                return objDecimal;
            }
            else if (str.IsDateTime(out DateTime objDateTime))
            {
                type = typeof(DateTime);
                return objDateTime;
            }
            else if ("true".EqualsIgnoreCase(str) || "false".EqualsIgnoreCase(str))
            {
                type = typeof(bool);
                return "true".EqualsIgnoreCase(str);
            }
            type = typeof(string);
            return str;
        }

        /// <summary>
        /// url编码
        /// </summary>
        /// <param name="str">要编码的url</param>
        /// <returns></returns>
        public static string UrlEncode(this string? url)
        {
            return string.IsNullOrWhiteSpace(url) ? string.Empty : Uri.EscapeDataString(url).Replace("'", "%27");
        }

        /// <summary>
        /// url解码
        /// </summary>
        /// <param name="str">要解码的url</param>
        /// <returns></returns>
        public static string UrlDecode(this string? url)
        {
            return string.IsNullOrWhiteSpace(url) ? string.Empty : Uri.UnescapeDataString(url).Replace("%27", "'");
        }

        /// <summary>
        /// 检测对象是否为null,为null则抛出<see cref="ArgumentNullException"/>异常
        /// </summary>
        /// <param name="obj">对象</param>
        /// <param name="parameterName">参数名</param>
        public static void CheckNull(this object obj, string parameterName)
        {
            if (obj == null)
                throw new ArgumentNullException(parameterName);
        }

        /// <summary>
        /// 是否为空
        /// </summary>
        /// <param name="value">值</param>
        public static bool IsEmpty([NotNullWhen(false)] this string? value)
        {
            return string.IsNullOrWhiteSpace(value);
        }

        /// <summary>
        /// 是否为空
        /// </summary>
        /// <param name="value">值</param>
        public static bool IsEmpty(this Guid value)
        {
            return value == Guid.Empty;
        }

        /// <summary>
        /// 是否为空
        /// </summary>
        /// <param name="value">值</param>
        public static bool IsEmpty([NotNullWhen(false)] this Guid? value)
        {
            if (value == null)
                return true;
            return value == Guid.Empty;
        }

        /// <summary>
        /// 是否为空
        /// </summary>
        /// <param name="value">值</param>
        public static bool IsEmpty<T>(this IEnumerable<T> value)
        {
            if (value == null)
                return true;
            return !value.Any();
        }

        /// <summary>
        /// 安全转换为字符串，去除两端空格，当值为null时返回""
        /// </summary>
        /// <param name="input">输入值</param>
        public static string SafeString(this object input)
        {
            return input?.ToString()?.Trim() ?? string.Empty;
        }

        /// <summary>
        /// 安全获取值，当值为null时，不会抛出异常
        /// </summary>
        /// <param name="value">可空值</param>
        public static T SafeValue<T>(this T? value) where T : struct
        {
            return value ?? default;
        }
    }
}