When to use Yield?

When should I u开发者_如何学编程se return yield and when should I use return only?

Use yield when you are returning an enumerable, and you don't have all the results at that point.

Practically, I've used yield when I want to iterate through a large block of information (database, flat file, etc.), and I don't want to load everything in memory first. Yield is a nice way to iterate through the block without loading everything at once.

The yield keyword is incredibly powerful. It basically allows you to quickly return IEnumerable and IEnumerator objects without explicitly coding them.

Consider a scenario where you want to return the intersection of two IEnumerable objects. Here is how you would do it using the yield keyword.

public static class Program
{
  public static void Main()
  {
    IEnumerable<object> lhs = new List<int> { 1, 2, 3, 4, 5 };
    IEnumerable<object> rhs = new List<int> { 3, 4, 5, 6, 7 };
    foreach (object item in IntersectExample.Intersect(lhs, rhs))
    {
      Console.WriteLine(item);
      break;
    }
  }
}

public static class IntersectExample
{
  public static IEnumerable<object> Intersect(IEnumerable<object> lhs, IEnumerable<object> rhs)
  {
    var hashset = new HashSet<object>();
    foreach (object item in lhs)
    {
      if (!hashset.Contains(item))
      {
        hashset.Add(item);
      }
    }
    foreach (object item in rhs)
    {
      if (hashset.Contains(item))
      {
        yield return item;
      }
    }
  }
}

It is hard to appreciate this until you fully realize what is going on. Normally when you intersect two sets you complete the entire operation before returning the result to the caller. The means the runtime complexity of the operation is O(m + n), where m and n are the sizes of the collections being intersected, regardless of what you do with the result afterwards. But, in my example I just wanted to pick off the first item from the result. Using an IEnumerable that was created by the yield keyword makes it super easy to delay part of the processing until it is actually required. My example runs in O(m). The alternative is to code the IEnumerable and maintain the state in it manually. The power of the yield keyword is that it creates that state machine for you.

Yield is for iterators.

It lets you process a list in small swallows, which is nice for big lists.

The magical thing about Yield is that it remembers where you're up to between invocations.

If you're not iterating you don't need Yield.

The yield construct is used to create an iterator that can produce multiple values in succession:

IEnumerable<int> three_numbers() {
    yield return 1;
    yield return 2;
    yield return 3;
}
...
foreach (var i in three_numbers()) {
    // i becomes 1, 2 and 3, in turn.
}

Yield Return will continue the method from that point. For example, you want to loop over an array or list and return each element at the time for the caller to process. So you will use yield return. If you want to return everything and then done, you don't need to do that

It is explained here:

C# Language Reference
yield (C# Reference)

The method called will return every single value so that they can be enumerated by the caller.

This means that you will need to use yield when you want every possible result returned by an iteration.