查看: 2099|回复: 0

[ASP.NET教程] .NET实用扩展方法详解

发表于 2018-1-14 11:38:15

持续更新的.NET实用扩展方法,具体内容如下

1. 字符串转换为可空数值类型(int, long, float...类似)

  1. /// <summary>
  2. /// 将字符串转换成32位整数,转换失败返回null
  3. /// </summary>
  4. /// <param name="str">转换的字符串</param>
  5. /// <returns>转换之后的整数,或null</returns>
  6. public static int? TryParseToInt32(this string str)
  7. {
  8. if (string.IsNullOrWhiteSpace(str))
  9. return null;
  10. var result = 0;
  11. if (int.TryParse(str, out result))
  12. return result;
  13. else
  14. return null;
  15. }
复制代码

2. 去除子字符串

  1. /// <summary>
  2. /// 去除子字符串
  3. /// </summary>
  4. /// <param name="str">原字符串</param>
  5. /// <param name="substring">要去除的字符串</param>
  6. /// <returns>去除子字符串之后的结果</returns>
  7. public static string DeSubstring(this string str, string substring)
  8. {
  9. if (string.IsNullOrEmpty(str) || string.IsNullOrEmpty(substring) || !str.Contains(substring))
  10. {
  11. return str;
  12. }
  13. return Regex.Replace(str, Regex.Escape(substring), string.Empty);
  14. }
  15. /// <summary>
  16. /// 去除子字符串
  17. /// </summary>
  18. /// <param name="str">原字符串</param>
  19. /// <param name="substrings">要去除的子字符串</param>
  20. /// <returns>去除子字符串之后的结果</returns>
  21. public static string DeSubstring(this string str, params string[] substrings)
  22. {
  23. if (string.IsNullOrEmpty(str))
  24. return str;
  25. if (substrings == null)
  26. return str;
  27. var newStr = str;
  28. foreach (var item in substrings)
  29. {
  30. newStr = newStr.DeSubstring(item);
  31. }
  32. return newStr;
  33. }
复制代码

3. 获取子序列

  1. /// <summary>
  2. /// 获取子序列
  3. /// </summary>
  4. /// <typeparam name="T">序列中元素类型</typeparam>
  5. /// <param name="source">源数据</param>
  6. /// <param name="startIndex">开始索引(返回时包括)</param>
  7. /// <param name="endIndex">结束索引(返回时包括)</param>
  8. /// <returns>子序列</returns>
  9. public static IEnumerable<T> SubEnumerable<T>(this IEnumerable<T> source, int startIndex, int endIndex)
  10. {
  11. if (source == null)
  12. yield return default(T);
  13. var length = source.Count();
  14. if (startIndex < 0 || endIndex < startIndex || startIndex >= length || endIndex >= length)
  15. throw new ArgumentOutOfRangeException();
  16. var index = -1;
  17. foreach (var item in source)
  18. {
  19. index++;
  20. if (index < startIndex)
  21. continue;
  22. if (index > endIndex)
  23. yield break;
  24. yield return item;
  25. }
  26. }
复制代码

4. 通过指定键对序列去重, 不必实现IEqualityComparer接口

  1. /// <summary>
  2. /// 通过对指定的值进行比较返回序列中的非重复元素。
  3. /// </summary>
  4. /// <typeparam name="T">序列中元素类型</typeparam>
  5. /// <typeparam name="TResult">指定的比较属性类型</typeparam>
  6. /// <param name="source">源数据</param>
  7. /// <param name="selector">应用于每个元素的转换函数</param>
  8. /// <returns>一个包含源序列中的按指定属性非重复元素</returns>
  9. public static IEnumerable<T> Distinct<T, TResult>(this IEnumerable<T> source, Func<T, TResult> selector)
  10. {
  11. if (source == null)
  12. throw new ArgumentNullException(nameof(source));
  13. if (selector == null)
  14. throw new ArgumentNullException(nameof(selector));
  15. var set = new HashSet<TResult>();
  16. foreach (var item in source)
  17. {
  18. var result = selector(item);
  19. if (set.Add(result))
  20. {
  21. yield return item;
  22. }
  23. }
  24. }
复制代码

5. 获取序列中重复的元素序列, 原理和去重类似

  1. /// <summary>
  2. /// 通过对指定的值进行比较返回序列中重复的元素
  3. /// </summary>
  4. /// <typeparam name="T">序列中的数据类型</typeparam>
  5. /// <typeparam name="TResult">指定的比较属性类型</typeparam>
  6. /// <param name="source">源数据</param>
  7. /// <param name="selector">应用于每个元素的转换函数</param>
  8. /// <returns>一个包含源序列中的按指定元素的重复元素</returns>
  9. public static IEnumerable<T> Identical<T>(this IEnumerable<T> source)
  10. {
  11. if (source == null)
  12. throw new ArgumentNullException(nameof(source));
  13. var setT = new HashSet<T>();
  14. foreach (var item in source)
  15. {
  16. if (!setT.Add(item))
  17. {
  18. yield return item;
  19. }
  20. }
  21. }
  22. /// <summary>
  23. /// 通过对指定的值进行比较返回序列中重复的元素
  24. /// </summary>
  25. /// <typeparam name="T">序列中的数据类型</typeparam>
  26. /// <typeparam name="TResult">指定的比较属性类型</typeparam>
  27. /// <param name="source">源数据</param>
  28. /// <param name="selector">应用于每个元素的转换函数</param>
  29. /// <returns>一个包含源序列中的按指定元素的重复元素</returns>
  30. public static IEnumerable<T> Identical<T, TResult>(this IEnumerable<T> source, Func<T, TResult> selector)
  31. {
  32. if (source == null)
  33. throw new ArgumentNullException(nameof(source));
  34. if (selector == null)
  35. throw new ArgumentNullException(nameof(selector));
  36. var setTResult = new HashSet<TResult>();
  37. foreach (var item in source)
  38. {
  39. var result = selector(item);
  40. if (!setTResult.Add(result))
  41. {
  42. yield return item;
  43. }
  44. }
  45. }
复制代码

以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持程序员之家。



回复

使用道具 举报