.NET 實用擴展方法

.NET 實用擴展方法(持續更新...)

1. 字元串轉換為可空數值類型(int, long, float...類似)

    /// <summary>
    /// 將字元串轉換成32位整數,轉換失敗返回null
    /// </summary>
    /// <param name="str">轉換的字元串</param>
    /// <returns>轉換之後的整數,或null</returns>
    public static int? TryParseToInt32(this string str)
    {
        if (string.IsNullOrWhiteSpace(str))
            return null;
        var result = 0;
        if (int.TryParse(str, out result))
            return result;
        else
            return null;
    }

2. 去除子字元串

    /// <summary>
    /// 去除子字元串
    /// </summary>
    /// <param name="str">原字元串</param>
    /// <param name="substring">要去除的字元串</param>
    /// <returns>去除子字元串之後的結果</returns>
    public static string DeSubstring(this string str, string substring)
    {
        if (string.IsNullOrEmpty(str) || string.IsNullOrEmpty(substring) || !str.Contains(substring))
        {
            return str;
        }

        return Regex.Replace(str, Regex.Escape(substring), string.Empty);
    }

    /// <summary>
    /// 去除子字元串
    /// </summary>
    /// <param name="str">原字元串</param>
    /// <param name="substrings">要去除的子字元串</param>
    /// <returns>去除子字元串之後的結果</returns>
    public static string DeSubstring(this string str, params string[] substrings)
    {
        if (string.IsNullOrEmpty(str))
            return str;
        if (substrings == null)
            return str;
        var newStr = str;
        foreach (var item in substrings)
        {
            newStr = newStr.DeSubstring(item);
        }
        return newStr;
    }

3. 獲取子序列

    /// <summary>
    /// 獲取子序列
    /// </summary>
    /// <typeparam name="T">序列中元素類型</typeparam>
    /// <param name="source">源數據</param>
    /// <param name="startIndex">開始索引(返回時包括)</param>
    /// <param name="endIndex">結束索引(返回時包括)</param>
    /// <returns>子序列</returns>
    public static IEnumerable<T> SubEnumerable<T>(this IEnumerable<T> source, int startIndex, int endIndex)
    {
        if (source == null)
            yield return default(T);
        var length = source.Count();
        if (startIndex < 0 || endIndex < startIndex || startIndex >= length || endIndex >= length)
            throw new ArgumentOutOfRangeException();

        var index = -1;
        foreach (var item in source)
        {
            index++;
            if (index < startIndex)
                continue;
            if (index > endIndex)
                yield break;
            yield return item;
        }
    }

4. 通過指定鍵對序列去重, 不必實現IEqualityComparer介面

    /// <summary>
    /// 通過對指定的值進行比較返回序列中的非重覆元素。
    /// </summary>
    /// <typeparam name="T">序列中元素類型</typeparam>
    /// <typeparam name="TResult">指定的比較屬性類型</typeparam>
    /// <param name="source">源數據</param>
    /// <param name="selector">應用於每個元素的轉換函數</param>
    /// <returns>一個包含源序列中的按指定屬性非重覆元素</returns>
    public static IEnumerable<T> Distinct<T, TResult>(this IEnumerable<T> source, Func<T, TResult> selector)
    {
        if (source == null)
            throw new ArgumentNullException(nameof(source));
        if (selector == null)
            throw new ArgumentNullException(nameof(selector));
        var set = new HashSet<TResult>();
        foreach (var item in source)
        {
            var result = selector(item);
            if (set.Add(result))
            {
                yield return item;
            }
        }
    }

5. 獲取序列中重覆的元素序列, 原理和去重類似

    /// <summary>
    /// 通過對指定的值進行比較返回序列中重覆的元素
    /// </summary>
    /// <typeparam name="T">序列中的數據類型</typeparam>
    /// <typeparam name="TResult">指定的比較屬性類型</typeparam>
    /// <param name="source">源數據</param>
    /// <param name="selector">應用於每個元素的轉換函數</param>
    /// <returns>一個包含源序列中的按指定元素的重覆元素</returns>
    public static IEnumerable<T> Identical<T>(this IEnumerable<T> source)
    {
        if (source == null)
            throw new ArgumentNullException(nameof(source));
        var setT = new HashSet<T>();
        foreach (var item in source)
        {
            if (!setT.Add(item))
            {
                yield return item;
            }
        }
    }

    /// <summary>
    /// 通過對指定的值進行比較返回序列中重覆的元素
    /// </summary>
    /// <typeparam name="T">序列中的數據類型</typeparam>
    /// <typeparam name="TResult">指定的比較屬性類型</typeparam>
    /// <param name="source">源數據</param>
    /// <param name="selector">應用於每個元素的轉換函數</param>
    /// <returns>一個包含源序列中的按指定元素的重覆元素</returns>
    public static IEnumerable<T> Identical<T, TResult>(this IEnumerable<T> source, Func<T, TResult> selector)
    {
        if (source == null)
            throw new ArgumentNullException(nameof(source));
        if (selector == null)
            throw new ArgumentNullException(nameof(selector));
        var setTResult = new HashSet<TResult>();
        foreach (var item in source)
        {
            var result = selector(item);
            if (!setTResult.Add(result))
            {
                yield return item;
            }
        }
    }