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