VberAdmin_V4/SourceCode/Zero/VberYue.Zero/Tools/StringModel/StringHelper.cs

using System.Collections;
using System.Security.Cryptography;

namespace VberZero.Tools.StringModel;

public static class StringHelper
{
    #region STRING

    /// <summary>
    /// 检查空字符串
    /// </summary>
    /// <param name="str"></param>
    /// <returns></returns>
    public static bool NotEmpty(this string str)
    {
        return !Empty(str);
    }

    /// <summary>
    /// 检查空字符串
    /// </summary>
    /// <param name="str"></param>
    /// <returns></returns>
    public static bool Empty(this string str)
    {
        return string.IsNullOrEmpty(str);
    }

    /// <summary>
    /// 大写并移除空白字符串
    /// </summary>
    /// <param name="str"></param>
    /// <returns></returns>
    public static string UAndT(this string? str)
    {
        str ??= "";
        return str.ToUpper().Trim();
    }

    /// <summary>
    /// 大写并移除空白字符串
    /// </summary>
    /// <param name="obj"></param>
    /// <returns></returns>
    public static string UAndT(this object obj)
    {
        return UAndT(obj.ToString());
    }

    /// <summary>
    /// 检查是否以某字符串开头，不是加上此字符串
    /// </summary>
    /// <param name="str"></param>
    /// <param name="startStr"></param>
    /// <returns></returns>
    public static string Sw(this string str, string startStr)
    {
        return str.StartsWith(startStr) ? str : $"{startStr}{str}";
    }

    /// <summary>
    /// 检查是否以某字符串结尾，不是加上此字符串
    /// </summary>
    /// <param name="str"></param>
    /// <param name="endStr"></param>
    /// <returns></returns>
    public static string Ew(this string str, string endStr)
    {
        return str!.EndsWith(endStr) ? str : $"{str}{endStr}";
    }

    /// <summary>
    /// 前补全
    /// </summary>
    /// <param name="i"></param>
    /// <param name="num"></param>
    /// <param name="charStr"></param>
    /// <returns></returns>
    public static string LeftPad(this int i, int num, string charStr = "0")
    {
        return i.ToString().PadLeft(num, Convert.ToChar(charStr));
    }

    /// <summary>
    /// 后补全
    /// </summary>
    /// <param name="i"></param>
    /// <param name="num"></param>
    /// <param name="charStr"></param>
    /// <returns></returns>
    public static string RightPad(this int i, int num, string charStr = "0")
    {
        return i.ToString().PadRight(num, Convert.ToChar(charStr));
    }

    /// <summary>
    /// 前补全
    /// </summary>
    /// <param name="s"></param>
    /// <param name="num"></param>
    /// <param name="charStr"></param>
    /// <returns></returns>
    public static string LeftPad(this string s, int num, string charStr = "0")
    {
        return s.PadLeft(num, Convert.ToChar(charStr));
    }

    /// <summary>
    /// 后补全
    /// </summary>
    /// <param name="s"></param>
    /// <param name="num"></param>
    /// <param name="charStr"></param>
    /// <returns></returns>
    public static string RightPad(this string s, int num, string charStr = "0")
    {
        return s.PadRight(num, Convert.ToChar(charStr));
    }

    /// <summary>
    /// 复制
    /// </summary>
    /// <param name="str"></param>
    /// <param name="count">复制次数</param>
    /// <returns></returns>
    public static string Replicate(this string str, int count)
    {
        string str2 = "";
        for (int index = 0; index < count; ++index)
            str2 += str;
        return str2;
    }

    /// <summary>
    /// 末尾移除匹配
    /// </summary>
    /// <param name="source"></param>
    /// <param name="removeStr"></param>
    /// <returns></returns>
    public static string TrimEnd(string source, string removeStr)
    {
        char[] charArray = removeStr.ToCharArray();
        return source.TrimEnd(charArray);
    }

    public static string GetRandom(int min = 0, int max = 9999)
    {
        var random = RandomNumberGenerator.GetInt32(min, max);
        return "R" + random;
    }

    public static string FormatXml2Code(this string str)
    {
        return str.Replace(";amp;", "&").Replace(";lt;", "<").Replace(";gt;", ">");
    }

    public static string FormatCode2Xml(this string str)
    {
        return str.Replace("&", ";amp;").Replace("<", ";lt;").Replace(">", ";gt;");
    }

    public static string AddStr(this string source, object toBeAppended)
    {
        source = source.Trim();
        if (source == "")
        {
            return GetDelimitedStr(toBeAppended);
        }
        if ((source[0] == '[') && (source[^1] == ']'))
        {
            return (source + $",[{toBeAppended.ToString()?.Trim()}]");
        }
        return JoinString(source, toBeAppended);
    }

    public static string JoinString(this object first, object second)
    {
        return $"[{first.ToString()?.Trim()}],[{second.ToString()?.Trim()}]";
    }

    public static string JoinString(this object first, object[] second)
    {
        var str = "";
        foreach (var o in second)
        {
            str += $",[{o.ToString()?.Trim()}]";
        }

        return $"[{first.ToString()?.Trim()}]{str}";
    }

    public static string JoinString(this object[] second)
    {
        var str = "";
        foreach (var o in second)
        {
            str += (str == "" ? "" : ",") + $"[{o.ToString()?.Trim()}]";
        }
        return str;
    }

    public static string JoinString(this object first, object second, object poThird)
    {
        return $"[{first.ToString()?.Trim()}],[{second.ToString()?.Trim()}], [{poThird.ToString()?.Trim()}]";
    }

    public static string JoinString(this object first, object second, object poThird, object poFourth)
    {
        return
            $"[{first.ToString()?.Trim()}],[{second.ToString()?.Trim()}], [{poThird.ToString()?.Trim()}], [{poFourth.ToString()?.Trim()}]";
    }

    public static string AppendToStr(this string source, object toBeAppended)
    {
        string delimitedStr = GetDelimitedStr(toBeAppended);
        source = source.Trim();
        if (source != "")
        {
            delimitedStr = source + "," + delimitedStr;
        }
        return delimitedStr;
    }

    #endregion STRING

    #region INT,DECIMAL,BOOL

    /// <summary>
    /// 验证int,并返回
    /// </summary>
    /// <param name="str"></param>
    /// <returns></returns>
    public static int ValI(this string str)
    {
        return (int)ValD(str);
    }

    /// <summary>
    /// 验证decimal,并返回
    /// </summary>
    /// <param name="str"></param>
    /// <returns></returns>
    public static decimal ValD(this string str)
    {
        string str1 = "";
        foreach (var ch in str)
        {
            if (ch != ' ' && ch != ',')
            {
                if (ch >= '0' && ch <= '9')
                    str1 += ch.ToString();
                else if ((ch == '+' || ch == '-') && str1 == "")
                    str1 += ch.ToString();
                else if (ch == '.' && str1.IndexOf(ch) < 0)
                    str1 += ch.ToString();
                else
                    break;
            }
        }
        if (str1 == "")
            str1 = "0";
        else if (str1 == "-")
            str1 = "-0";
        return Convert.ToDecimal(str1);
    }

    /// <summary>
    /// int转bool (true,yes,y,>1)
    /// </summary>
    /// <param name="i"></param>
    /// <returns></returns>
    public static bool ValB(this int i)
    {
        var str = i > 0 ? "1" : "0";
        return StrToBool(str);
    }

    /// <summary>
    /// 字符串转bool (true,yes,y,1)
    /// </summary>
    /// <param name="str"></param>
    /// <returns></returns>
    public static bool ValB(this string? str)
    {
        return StrToBool(str);
    }

    /// <summary>
    /// 字符串转bool (true,yes,y,1)
    /// </summary>
    /// <param name="str"></param>
    /// <returns></returns>
    public static bool StrToBool(this string? str)
    {
        bool flag = false;
        str = UAndT(str);
        if (str == "TRUE" || str == "YES" || str == "Y" || str == "1")
            flag = true;
        return flag;
    }

    #endregion INT,DECIMAL,BOOL

    #region Array

    /// <summary>
    /// 字符转数组
    /// </summary>
    /// <param name="str"></param>
    /// <param name="separator">分隔符默认：,</param>
    /// <returns></returns>
    public static string?[] StrToArray(this string str, string separator = ",")
    {
        return (string?[])StrToArrayEx(str, separator);
    }

    /// <summary>
    /// 字符转数组
    /// </summary>
    /// <param name="str"></param>
    /// <param name="separator">分隔符默认：,</param>
    /// <returns></returns>
    public static Array StrToArrayEx(this string? str, string separator = ",")
    {
        ArrayList arrayList = new ArrayList();
        str = str == null ? "" : str.Trim();
        int length1 = separator.Length;
        int length2;
        for (; str.Length > 0; str = length2 + length1 <= str.Length ? str.Substring(length2 + length1).Trim() : "")
        {
            length2 = str.IndexOf(separator, StringComparison.Ordinal);
            int num1 = str.IndexOf("[", StringComparison.Ordinal);
            if (num1 >= 0 && num1 < length2)
            {
                int num2 = 1;
                int length3 = str.Length;
                int startIndex;
                for (startIndex = num1 + 1; startIndex < length3; ++startIndex)
                {
                    switch (str[startIndex])
                    {
                        case '[':
                            ++num2;
                            break;

                        case ']':
                            --num2;
                            break;
                    }
                    if (num2 == 0)
                        break;
                }
                length2 = str.IndexOf(separator, startIndex, StringComparison.Ordinal);
            }
            if (length2 < 0)
                length2 = str.Length;
            string str1 = str.Substring(0, length2);
            int length4 = str1.Length;
            if (length4 > 0 && str1[0] == '[' && str1[length4 - 1] == ']')
                str1 = str1.Substring(1, length4 - 2);
            arrayList.Add(str1.Trim());
        }
        Array instance = new string[arrayList.Count];
        arrayList.CopyTo(instance);
        return instance;
    }

    /// <summary>
    /// 数组转字符串 (分隔符：,)
    /// </summary>
    /// <param name="paStr"></param>
    /// <param name="delimited"></param>
    /// <returns></returns>
    public static string ArrayToStr(this Array paStr, bool delimited = false)
    {
        return ArrayToStr(paStr, ",", delimited);
    }

    /// <summary>
    /// 数组转字符串
    /// </summary>
    /// <param name="paStr"></param>
    /// <param name="separator"></param>
    /// <param name="delimited">是否加界定符“[]”</param>
    /// <returns></returns>
    public static string ArrayToStr(this Array paStr, string separator, bool delimited = false)
    {
        string str1 = "";
        foreach (string str2 in paStr)
            str1 = str1 + (str1 == "" ? "" : separator) + (delimited ? GetDelimitedStr(str2) : str2);
        return str1;
    }

    /// <summary>
    /// 加上界定符
    /// </summary>
    /// <param name="obj"></param>
    /// <returns></returns>
    public static string GetDelimitedStr(object obj)
    {
        return "[" + obj + "]";
    }

    /// <summary>
    /// 改编
    /// </summary>
    /// <param name="arr"></param>
    /// <param name="from"></param>
    /// <param name="to"></param>
    /// <returns></returns>
    public static Array RearrangeArray(this Array arr, int from, int to)
    {
        Array instance = new object[arr.Length];
        arr.CopyTo(instance, 0);
        object? obj = instance.GetValue(from);
        if (from > to)
        {
            for (int index = from - 1; index >= to; --index)
                instance.SetValue(instance.GetValue(index), index + 1);
        }
        else
        {
            for (int index = from + 1; index <= to; ++index)
                instance.SetValue(instance.GetValue(index), index - 1);
        }
        instance.SetValue(obj, to);
        return instance;
    }

    /// <summary>
    /// 数组转数组List
    /// </summary>
    /// <param name="arr"></param>
    /// <returns></returns>
    public static ArrayList ArrayToArrayList(this Array arr)
    {
        ArrayList arrayList = new ArrayList();
        foreach (object obj in arr)
            arrayList.Add(obj);
        return arrayList;
    }

    /// <summary>
    /// 移除
    /// </summary>
    /// <param name="arr"></param>
    /// <param name="obj"></param>
    /// <returns></returns>
    public static Array RemoveFromArray(this Array arr, object obj)
    {
        ArrayList arrayList = ArrayToArrayList(arr);
        arrayList.Remove(obj);
        Array instance = new object[arrayList.Count];
        arrayList.CopyTo(instance);
        return instance;
    }

    /// <summary>
    /// 数组list 插入（按字符串长度排序）
    /// </summary>
    /// <param name="poArrayList"></param>
    /// <param name="pcName"></param>
    public static void InsertIdentifier(this ArrayList poArrayList, string pcName)
    {
        int index = 0;
        while (index < poArrayList.Count)
        {
            string? str = poArrayList[index]?.ToString();
            if (str == pcName)
            {
                index = -1;
                break;
            }
            if (str?.Length < pcName.Length)
            {
                break;
            }
            index++;
        }
        if (index >= 0)
        {
            poArrayList.Insert(index, pcName);
        }
    }

    #endregion Array

    #region DateTime

    /// <summary>
    /// 时间转字符串
    /// </summary>
    /// <param name="dateTime"></param>
    /// <returns></returns>
    public static string DtToStr(this DateTime dateTime)
    {
        return dateTime.ToString("s").Replace("T", " ");
    }

    /// <summary>
    /// 字符串转时间
    /// </summary>
    /// <param name="str"></param>
    /// <returns></returns>
    public static DateTime StrToDt(this string str)
    {
        DateTime dateTime = new DateTime(1900, 1, 1);
        try
        {
            dateTime = DateTime.Parse(str);
        }
        catch (Exception)
        {
            // ignored
        }

        return dateTime;
    }

    /// <summary>
    /// 日期转指定格式日期（默认yyyyMMddHHmmss）
    /// </summary>
    /// <param name="dateTime"></param>
    /// <param name="formatter"></param>
    /// <returns></returns>
    public static string DtToStrFormatter(this DateTime dateTime, string formatter = "yyyyMMddHHmmss")
    {
        return dateTime.ToString(formatter);
    }

    /// <summary>
    /// 日期转时间字符串
    /// </summary>
    /// <param name="dateTime"></param>
    /// <returns></returns>
    public static string DtToTimeStr(this DateTime dateTime)
    {
        return dateTime.ToString("T");
    }

    /// <summary>
    /// 日期转日期字符串
    /// </summary>
    /// <param name="dateTime"></param>
    /// <returns></returns>
    public static string DtToDateStr(this DateTime dateTime)
    {
        return dateTime.ToString("d");
    }

    /// <summary>
    /// 获取秒
    /// </summary>
    /// <param name="dateTime"></param>
    /// <returns></returns>
    public static int DtToSeconds(this DateTime dateTime)
    {
        return dateTime.TimeOfDay.Seconds;
    }

    /// <summary>
    /// 今天之后多少秒
    /// </summary>
    /// <param name="seconds"></param>
    /// <returns></returns>
    public static DateTime DtFromSeconds(int seconds)
    {
        return DateTime.Today + new TimeSpan(0, 0, seconds);
    }

    /// <summary>
    /// 时间差（分）
    /// </summary>
    /// <param name="start"></param>
    /// <param name="end"></param>
    /// <returns></returns>
    public static int GetTimeSpanMinute(this DateTime start, DateTime end)
    {
        return Convert.ToInt32(GetTimeSpan(start, end).TotalMinutes);
    }

    /// <summary>
    /// 时间差
    /// </summary>
    /// <param name="start"></param>
    /// <param name="end"></param>
    /// <returns></returns>
    public static TimeSpan GetTimeSpan(this DateTime start, DateTime end)
    {
        TimeSpan timeSpan = end - start;
        return timeSpan;
    }

    #endregion DateTime
}