WEP_V2.1.3/SourceCode/WeApp.3D.Test/WeApp.3D/Assets/Plugins/CommonTool/StringHelper.cs

using System;
using System.Collections;
using System.Collections.Generic;
using System.Text;
using System.Text.RegularExpressions;

namespace Assets.Plugins.CommonTool
{
    public static class StringHelper
    {
        #region STRING

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

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

        /// <summary>
        /// 大写并移除空白字符串
        /// </summary>
        /// <param name="str"></param>
        /// <returns></returns>
        public static string UAndT(this string str)
        {
            if (str == null)
                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);
        }



        /// <summary>
        /// 截取字符串中开始和结束字符串中间的字符串
        /// </summary>
        /// <param name="source">源字符串</param>
        /// <param name="startStr">开始字符串</param>
        /// <param name="endStr">结束字符串</param>
        /// <returns>中间字符串</returns>
        public static string SubstringSingle(this string source, string startStr, string endStr)
        {
            Regex rg = new Regex("(?<=(" + startStr + "))[.\\s\\S]*?(?=(" + endStr + "))", RegexOptions.Multiline | RegexOptions.Singleline);
            return rg.Match(source).Value;
        }

        /// <summary>
        /// （批量）截取字符串中开始和结束字符串中间的字符串
        /// </summary>
        /// <param name="source">源字符串</param>
        /// <param name="startStr">开始字符串</param>
        /// <param name="endStr">结束字符串</param>
        /// <returns>中间字符串</returns>
        public static List<string> SubstringMultiple(this string source, string startStr, string endStr)
        {
            Regex rg = new Regex("(?<=(" + startStr + "))[.\\s\\S]*?(?=(" + endStr + "))", RegexOptions.Multiline | RegexOptions.Singleline);

            MatchCollection matches = rg.Matches(source);

            List<string> resList = new List<string>();

            foreach (Match item in matches)
                resList.Add(item.Value);

            return resList;
        }

        private static Random _random;
        public static string GetRandom()
        {
            if (_random == null)
            {
                _random = new Random(0x989680);
            }
            return "R" + _random.Next(0x989680, 0x5f5e0ff);
        }

        public static int GetRandomSeed()
        {
            byte[] bytes = new byte[4];
            var rng = new System.Security.Cryptography.RNGCryptoServiceProvider();
            rng.GetBytes(bytes);
            return BitConverter.ToInt32(bytes, 0);
        }



        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[source.Length - 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

        #region BASE64

        /// <summary>
        /// Base64 编码
        /// </summary>
        /// <param name="encode">编码方式</param>
        /// <param name="source">要编码的字符串</param>
        /// <returns>返回编码后的字符串</returns>
        public static string EncodeBase64(this string source, Encoding encode = null)
        {
            string result;
            try
            {
                encode ??= Encoding.UTF8;
                byte[] bytes = encode.GetBytes(source);
                result = Convert.ToBase64String(bytes);
            }
            catch
            {
                result = source;
            }
            return result;
        }

        /// <summary>
        /// Base64 解码
        /// </summary>
        /// <param name="encode">解码方式</param>
        /// <param name="source">要解码的字符串</param>
        /// <returns>返回解码后的字符串</returns>
        public static string DecodeBase64(this string source, Encoding encode = null)
        {
            string result;
            try
            {
                byte[] bytes = Convert.FromBase64String(source);
                encode ??= Encoding.UTF8;
                result = encode.GetString(bytes);
            }
            catch
            {
                result = source;
            }
            return result;
        }

        #endregion
    }
}