为什么这个字符串扩展方法不抛出异常?

内容来源于 Stack Overflow,并遵循CC BY-SA 3.0许可协议进行翻译与使用

  • 回答 (2)
  • 关注 (0)
  • 查看 (13)

我有一个C#字符串扩展方法,它应该返回IEnumerable<int>字符串中的子字符串的所有索引。但是另一个单元测试发现了它的一个问题:它不能处理空参数。

下面是我正在测试的扩展方法:

public static IEnumerable<int> AllIndexesOf(this string str, string searchText)
{
    if (searchText == null)
    {
        throw new ArgumentNullException("searchText");
    }
    for (int index = 0; ; index += searchText.Length)
    {
        index = str.IndexOf(searchText, index);
        if (index == -1)
            break;
        yield return index;
    }
}

下面是标记问题的测试:

[TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public void Extensions_AllIndexesOf_HandlesNullArguments()
{
    string test = "a.b.c.d.e";
    test.AllIndexesOf(null);
}

当测试针对我的扩展方法运行时,它会失败,并带有标准的错误消息,即该方法“没有抛出异常”。

这很让人困惑:我显然通过了null进入功能,但出于某种原因的比较null == null正在回归false。因此,不会引发任何异常,代码将继续运行。

我已经确认这不是测试中的错误:当我在主项目中运行方法时,调用Console.WriteLine在空比较中if块时,控制台上没有显示任何异常,也没有任何异常被任何catch我加了块。此外,使用string.IsNullOrEmpty而不是== null也有同样的问题。

为什么这个简单的比较失败了?

提问于
用户回答回答于

你在用yield return,在这样做时,编译器将将你的方法重写为返回实现状态机的生成类的函数。

广义地说,它将局部变量重写到该类的字段以及算法的每个部分。yield return指令变成一种状态。可以使用反编译程序检查编译后此方法会变成什么(请确保关闭智能反编译,这将产生yield return)。

在开始迭代之前,不会执行方法的代码。

检查先决条件的通常方法是将方法分成两部分:

public static IEnumerable<int> AllIndexesOf(this string str, string searchText)
{
    if (str == null)
        throw new ArgumentNullException("str");
    if (searchText == null)
        throw new ArgumentNullException("searchText");

    return AllIndexesOfCore(str, searchText);
}

private static IEnumerable<int> AllIndexesOfCore(string str, string searchText)
{
    for (int index = 0; ; index += searchText.Length)
    {
        index = str.IndexOf(searchText, index);
        if (index == -1)
            break;
        yield return index;
    }
}

这是因为第一个方法的行为与预期的如出一辙,并且将返回由第二个方法实现的状态机。

注意,还应该检查str参数null,因为扩展方法被召唤null价值观。

如果想知道编译器对代码做了什么,使用dotPeek使用显示编译器生成的代码选择。

public static IEnumerable<int> AllIndexesOf(this string str, string searchText)
{
  Test.<AllIndexesOf>d__0 allIndexesOfD0 = new Test.<AllIndexesOf>d__0(-2);
  allIndexesOfD0.<>3__str = str;
  allIndexesOfD0.<>3__searchText = searchText;
  return (IEnumerable<int>) allIndexesOfD0;
}

[CompilerGenerated]
private sealed class <AllIndexesOf>d__0 : IEnumerable<int>, IEnumerable, IEnumerator<int>, IEnumerator, IDisposable
{
  private int <>2__current;
  private int <>1__state;
  private int <>l__initialThreadId;
  public string str;
  public string <>3__str;
  public string searchText;
  public string <>3__searchText;
  public int <index>5__1;

  int IEnumerator<int>.Current
  {
    [DebuggerHidden] get
    {
      return this.<>2__current;
    }
  }

  object IEnumerator.Current
  {
    [DebuggerHidden] get
    {
      return (object) this.<>2__current;
    }
  }

  [DebuggerHidden]
  public <AllIndexesOf>d__0(int <>1__state)
  {
    base..ctor();
    this.<>1__state = param0;
    this.<>l__initialThreadId = Environment.CurrentManagedThreadId;
  }

  [DebuggerHidden]
  IEnumerator<int> IEnumerable<int>.GetEnumerator()
  {
    Test.<AllIndexesOf>d__0 allIndexesOfD0;
    if (Environment.CurrentManagedThreadId == this.<>l__initialThreadId && this.<>1__state == -2)
    {
      this.<>1__state = 0;
      allIndexesOfD0 = this;
    }
    else
      allIndexesOfD0 = new Test.<AllIndexesOf>d__0(0);
    allIndexesOfD0.str = this.<>3__str;
    allIndexesOfD0.searchText = this.<>3__searchText;
    return (IEnumerator<int>) allIndexesOfD0;
  }

  [DebuggerHidden]
  IEnumerator IEnumerable.GetEnumerator()
  {
    return (IEnumerator) this.System.Collections.Generic.IEnumerable<System.Int32>.GetEnumerator();
  }

  bool IEnumerator.MoveNext()
  {
    switch (this.<>1__state)
    {
      case 0:
        this.<>1__state = -1;
        if (this.searchText == null)
          throw new ArgumentNullException("searchText");
        this.<index>5__1 = 0;
        break;
      case 1:
        this.<>1__state = -1;
        this.<index>5__1 += this.searchText.Length;
        break;
      default:
        return false;
    }
    this.<index>5__1 = this.str.IndexOf(this.searchText, this.<index>5__1);
    if (this.<index>5__1 != -1)
    {
      this.<>2__current = this.<index>5__1;
      this.<>1__state = 1;
      return true;
    }
    goto default;
  }

  [DebuggerHidden]
  void IEnumerator.Reset()
  {
    throw new NotSupportedException();
  }

  void IDisposable.Dispose()
  {
  }
}

这是无效的C#代码,因为编译器可以做语言不允许的事情,但在IL中是合法的--例如,以一种无法避免名称冲突的方式命名变量。

但正如你所看到的,AllIndexesOf只构造和返回一个对象,其构造函数只初始化某种状态。GetEnumerator只复制对象。真正的工作是在开始枚举时完成的(通过调用MoveNext方法)。

用户回答回答于

你有一个迭代器块。该方法中的任何代码都不会在调用MoveNext在返回的迭代器上。调用该方法时只需创建状态机,就不会失败(除了内存不足、堆栈溢出或线程异常等极端情况外)。

当实际尝试迭代序列时,将得到异常。

这就是为什么LINQ方法实际上需要两种方法来获得他们想要的错误处理语义。它们有一个私有方法,即迭代器块,然后是一个非迭代器块方法,它只做参数验证(这样就可以急切地完成它,而不是推迟),同时仍然推迟所有其他功能。

所以这就是一般的模式:

public static IEnumerable<T> Foo<T>(
    this IEnumerable<T> souce, Func<T, bool> anotherArgument)
{
    //note, not an iterator block
    if(anotherArgument == null)
    {
        //TODO make a fuss
    }
    return FooImpl(source, anotherArgument);
}

private static IEnumerable<T> FooImpl<T>(
    IEnumerable<T> souce, Func<T, bool> anotherArgument)
{
    //TODO actual implementation as an iterator block
    yield break;
}

扫码关注云+社区