MeloongCore/Extensions/StringExtensions.cs

using System;
using System.Runtime.CompilerServices;

namespace MeloongCore.Extensions {
    public static class StringExtensions {

        #region 区域性 / 大小写 简化

        /// <summary>
        /// 高速的 StartsWith。
        /// </summary>
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static bool StartsWithF(this string value, string prefix, bool ignoreCase = false) {
            if (value == null) return false;
            return value.StartsWith(prefix, ignoreCase ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal);
        }
        /// <summary>
        /// 高速的 EndsWith。
        /// </summary>
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static bool EndsWithF(this string value, string suffix, bool ignoreCase = false) {
            if (value == null) return false;
            return value.EndsWith(suffix, ignoreCase ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal);
        }

        /// <summary>
        /// 忽略大小写的 Contains。
        /// </summary>
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static bool ContainsIgnoreCase(this string value, string subString) {
            return value.IndexOf(subString, StringComparison.OrdinalIgnoreCase) >= 0;
        }

        /// <summary>
        /// 高速的 IndexOf。
        /// </summary>
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static int IndexOfF(this string value, string subString, bool ignoreCase = false) {
            return value.IndexOf(subString, ignoreCase ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal);
        }
        /// <summary>
        /// 高速的 IndexOf。
        /// </summary>
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static int IndexOfF(this string value, string subString, int startIndex, bool ignoreCase = false) {
            return value.IndexOf(subString, startIndex, ignoreCase ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal);
        }

        /// <summary>
        /// 高速的 LastIndexOf。
        /// </summary>
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static int LastIndexOfF(this string value, string subString, bool ignoreCase = false) {
            return value.LastIndexOf(subString, ignoreCase ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal);
        }
        /// <summary>
        /// 高速的 LastIndexOf。
        /// </summary>
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static int LastIndexOfF(this string value, string subString, int startIndex, bool ignoreCase = false) {
            return value.LastIndexOf(subString, startIndex, ignoreCase ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal);
        }

        /// <summary>
        /// ToLowerInvariant 的简略写法。
        /// </summary>
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static string Lower(this string str) => str.ToLowerInvariant();
        /// <summary>
        /// ToUpperInvariant 的简略写法。
        /// </summary>
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static string Upper(this string str) => str.ToUpperInvariant();

        #endregion

        #region 分割与裁切

        /// <summary>
        /// 分割字符串。
        /// 若原始字符串为空，则返回 {""}。
        /// </summary>
        public static string[] Split(this string fullStr, string splitStr) {
            if (splitStr.IsSingle())
                return fullStr.Split(splitStr[0]);
            else
                return fullStr.Split(new[] {splitStr}, StringSplitOptions.None);
        }

        /// <summary>
        /// 获取在子字符串第一次出现之前的部分，例如对 2024/11/08 拆切 / 会得到 2024。
        /// 如果未找到子字符串则不裁切。
        /// </summary>
        public static string BeforeFirst(this string str, string text, bool ignoreCase = false) {
            int pos = string.IsNullOrEmpty(text) ? -1 : str.IndexOfF(text, ignoreCase);
            if (pos >= 0)
                return str.Substring(0, pos);
            else
                return str;
        }
        /// <summary>
        /// 获取在子字符串最后一次出现之前的部分，例如对 2024/11/08 拆切 / 会得到 2024/11。
        /// 如果未找到子字符串则不裁切。
        /// </summary>
        public static string BeforeLast(this string str, string text, bool ignoreCase = false) {
            int pos = string.IsNullOrEmpty(text) ? -1 : str.LastIndexOfF(text, ignoreCase);
            if (pos >= 0)
                return str.Substring(0, pos);
            else
                return str;
        }

        /// <summary>
        /// 获取在子字符串第一次出现之后的部分，例如对 2024/11/08 拆切 / 会得到 11/08。
        /// 如果未找到子字符串则不裁切。
        /// </summary>
        public static string AfterFirst(this string str, string text, bool ignoreCase = false) {
            int pos = string.IsNullOrEmpty(text) ? -1 : str.IndexOfF(text, ignoreCase);
            if (pos >= 0)
                return str.Substring(pos + text.Length);
            else
                return str;
        }
        /// <summary>
        /// 获取在子字符串最后一次出现之后的部分，例如对 2024/11/08 拆切 / 会得到 08。
        /// 如果未找到子字符串则不裁切。
        /// </summary>
        public static string AfterLast(this string str, string text, bool ignoreCase = false) {
            int pos = string.IsNullOrEmpty(text) ? -1 : str.LastIndexOfF(text, ignoreCase);
            if (pos >= 0)
                return str.Substring(pos + text.Length);
            else
                return str;
        }

        /// <summary>
        /// 获取处于两个子字符串之间的部分，裁切尽可能多的内容。
        /// 等效于 AfterLast 后接 BeforeFirst。
        /// 如果未找到子字符串则不裁切。
        /// </summary>
        public static string Between(this string str, string after, string before, bool ignoreCase = false) {
            int startPos = string.IsNullOrEmpty(after) ? -1 : str.LastIndexOfF(after, ignoreCase);
            if (startPos >= 0)
                startPos += after.Length;
            else
                startPos = 0;

            int endPos = string.IsNullOrEmpty(before) ? -1 : str.IndexOfF(before, startPos, ignoreCase);
            if (endPos >= 0)
                return str.Substring(startPos, endPos - startPos);
            else if (startPos > 0)
                return str.Substring(startPos);
            else
                return str;
        }

        #endregion

        /// <summary>
        /// 将第一个字符转换为大写，其余字符转换为小写。
        /// </summary>
        public static string Capitalize(this string word) {
            if (string.IsNullOrEmpty(word)) return word;
            return word.Substring(0, 1).Upper() + word.Substring(1).Lower();
        }

    }
}