.NET實用擴展方法詳解

 /// <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;
 }

 /// <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;
 }

 /// <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;
 }
 }

 /// <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;
 }
 }
 }

 /// <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;
 }
 }
 }