What's the defference between "yield break" and "break" in iterator blocks?

Question

I've seen something in Enumerable.cs like this:

private static IEnumerable<TSource> TakeWhileIterator<TSource>(
  IEnumerable<TSource> source,
  Func<TSource, bool> predicate)
{
  foreach (TSource source1 in source)
  {
    if (predicate(source1))
      yield return source1;
    else
      break; // break
  }
}

So I write something like this:

private static IEnumerable<TSource> TakeWhileIteratorWithYield<TSource>(
  IEnumerable<TSource> source,
  Func<TSource, bool> predicate)
{
  foreach (TSource source1 in source)
  {
    if (predicate(source1))
      yield return source1;
    else
      yield break; // yield break
  }
}

I've tried these two methods and it seems like they have quite the same function. So I go to SharpLab and decomplie these codes. The main differences are in MoveNext() I think, like this:
No Yield

private bool MoveNext()
{
    try
    {
        switch (_state)
        {
            default:
                return false;
            case 0:
                _state = -1;
                _s__1 = source.GetEnumerator();
                _state = -3;
                break;
            case 1:
                _state = -3;
                _source5__2 = default(TSource);
                break;
        }

        // From Here
        if (_s__1.MoveNext())
        {
            _source5__2 = _s__1.Current;
            if (predicate(_source5__2))
            {
                _current = _source5__2;
                _state = 1;
                return true;
            }
        }

        Finally1();
        _s__1 = null;
        return false;
        // To Here
    }
    catch
    {
        //try-fault
        ((IDisposable) this).Dispose();
        throw;
    }
}

Have Yield

private bool MoveNext()
{
    try
    {
        switch (_state)
        {
            default:
                return false;
            case 0:
                _state = -1;
                _s__1 = source.GetEnumerator();
                _state = -3;
                break;
            case 1:
                _state = -3;
                _source5__2 = default(TSource);
                break;
        }

        // From Here
        if (!_s__1.MoveNext())
        {
            Finally1();
            _s__1 = null;
            return false;
        }

        _source5__2 = _s__1.Current;
        if (predicate(_source5__2))
        {
            _current = _source5__2;
            _state = 1;
            return true;
        }

        bool result = false;
        Finally1();
        return result;
        // To Here
    }
    catch
    {
        //try-fault
        ((IDisposable) this).Dispose();
        throw;
    }
}

I can't see the functional differences between them.
Could someone tell me the differences between break and yield break in iterator blocks?

and the comment on this answer of the dupe target may help https://stackoverflow.com/a/231945/6560478 — Drag and Drop, Aug 31 '20 at 08:25
Does this answer your question? [What does "yield break;" do in C#?](https://stackoverflow.com/questions/231893/what-does-yield-break-do-in-c) — Drag and Drop, Aug 31 '20 at 08:25
`yield break` ends the iteration, `break` ends the loop ect. You can imagine how this is different — TheGeneral, Aug 31 '20 at 08:25
@DragandDrop Thank you very much. I do seen that question but not the comment in the first answer. Good Day! — NoGTNoHappy, Aug 31 '20 at 08:27

What's the defference between "yield break" and "break" in iterator blocks?

0 Answers0