In other words, when using the "yield return" statement inside an iterator, you need not create a temporary collection to store data before it returned. You can take advantage of the yield return statement to return each element in the collection one at a time, and you can use the "yield return" statement with iterators in a method or a get accessor. Note that the control is returned to the caller each time the "yield return" statement is encountered and executed.
Most importantly, with each such call, the callee's state information is preserved so that execution can continue immediately after the yield statement when the control returns.
The following code snippet illustrates how the yield keyword can be used to return a Fibonacci number. The method accepts an integer as argument that represents the count of the Fibonacci numbers to generate. In other words, the state information is preserved. Here's how the GenerateFibonacciNumbers method can be called.
As you can notice, there is no need of creating an intermediate list or array to hold the fibonacci numbers that need to be generated and returned to the caller. Note that under the covers the yield keyword creates a state machine to maintain state information. The MSDN states : "When a yield return statement is reached in the iterator method, expression is returned, and the current location in code is retained.
Execution is restarted from that location the next time that the iterator function is called. Another advantage of using the yield keyword is that the items that are returned are created only on demand. As an example, the following get accessor returns the even numbers between 1 and You can now access the list to get all elements of the enumerable without the iterator block executing again. There is a trade-off between using CPU to produce the elements of the enumerable multiple times and memory to store the elements of the enumeration to access them multiple times when using methods like ToList.
One major point about Yield keyword is Lazy Execution. Now what I mean by Lazy Execution is to execute when needed. A better way to put it is by giving an example.
Whereas yieldItems will just have a reference to the method and not the items. That means it has not executed the process of getting items inside the method. A very efficient way of getting data only when needed. The C yield keyword, to put it simply, allows many calls to a body of code, referred to as an iterator, that knows how to return before it's done and, when called again, continues where it left off - i. It is a very simple and easy way to create an enumerable for your object.
It's producing enumerable sequence. What it does is actually creating local IEnumerable sequence and returning it as a method result.
This link has a simple example. Notice that yield return won't return from the method. You can even put a WriteLine after the yield return. Here with a WriteLine. Will add 4 to the list, print abc, then add 4 to the list, then complete the method and so really return from the method once the method has completed, as would happen with a procedure without a return. But this would have a value, an IEnumerable list of int s, that it returns on completion.
Notice also that when you use yield, what you are returning is not of the same type as the function. It's of the type of an element within the IEnumerable list. You use yield with the method's return type as IEnumerable. You can use IEnumerable method return type without yield but it seems maybe you can't use yield without IEnumerable method return type. Data streams often retrieve or generate elements asynchronously. Async streams rely on new interfaces introduced in.
NET Standard 2. These interfaces are supported in. NET Core 3. They provide a natural programming model for asynchronous streaming data sources. Source: Microsoft docs. It's trying to bring in some Ruby Goodness : Concept: This is some sample Ruby Code that prints out each element of the array. The Array's each method implementation yields control over to the caller the 'puts x' with each element of the array neatly presented as x. The caller can then do whatever it needs to do with x.
Net doesn't go all the way here.. C seems to have coupled yield with IEnumerable, in a way forcing you to write a foreach loop in the caller as seen in Mendelt's response. Little less elegant. Stack Overflow for Teams — Collaborate and share knowledge with a private group. Create a free Team What is Teams? Collectives on Stack Overflow. Learn more. What is the yield keyword used for in C?
Ask Question. Asked 13 years, 2 months ago. Active 8 days ago. Viewed k times. Improve this question. Tvde1 1, 2 2 gold badges 19 19 silver badges 35 35 bronze badges. Herms Herms Just MSDN link about it is here msdn. This is not surprising. The confusion comes from the fact that we are conditioned to see "return" as a function output while preceded by a "yield" it is not.
Add a comment. Active Oldest Votes. The yield contextual keyword actually does quite a lot here. WriteLine i. Improve this answer. David Klempfner 7, 15 15 gold badges 53 53 silver badges bronze badges.
Mendelt Mendelt In this case that would be easier, i'm just using the integer here to show how yield return works. The nice things about using yield return is that it's a very quick way of implementing the iterator pattern, so things are evaluated lazly. Also worth noting you can use yield break; when you don't want to return any more items.
Brandin that's because all programming languages support two types of keywords namely reserved and contextual. More details here: ericlippert. For e. More details here: stackoverflow. I always thought of the c yield keyword in the context of "the crop yields a bountiful harvest", instead of "the car yields to the pedestrian". Show 3 more comments. Joel Coehoorn Joel Coehoorn k gold badges silver badges bronze badges.
Yield has two great uses, It helps to provide custom iteration without creating temp collections. Shivprasad Koirala Shivprasad Koirala The video help me to clearly understand the yield.
ShivprasadKoirala's code project article What is the use of C Yield? I would also add as a third point that yield is "fast" way to create a custom IEnumerator rather having a class implement the IEnumerator interface. I watched your video Shivprasad and it explaired clearly the usage of the yield keyword. The state field stores the '-2' startState value passed to the generator at the initialization.
The initialThreadId field stores the ID of the thread where the object was created. I'll explain the purpose of these fields later. Now let's take a look at the GetEnumerator implementation:. See how when certain conditions are met, the method returns the same object instead of a new one? This peculiarity might seem quite unexpected. The following code fragment confirms it:. At the GetEnumerator method call, the returned object's state field is assigned to '0'.
This is an important step. Take another look at the GetFibonacci method or, to be exact, at what the compiler transformed it into. I'll clarify the mechanics of this further on in this article. Right now, let's take a look at the MoveNext method:. This method implements all logic we programmed into the GetFibonacci method. This is the value we get when we access the sequence generator's Current property.
When the generator's state field value is '-1', the generator exits - MoveNext does not do anything and returns false. Previously we discussed that when you create a new generator, the '-2' value is recorded to the state field. But take a look at the code. Essentially, the generator does not work. Luckily, the GetEnumerator method call replaces the -2 state with 0. What about calling MoveNext without calling GetEnumerator? Is this possible?
Nevertheless, the returned object implements both IEnumerable and IEnumerator - so you can use type casting. In this case the developer does not need GetEnumerator and can call the generator's MoveNext. However, all calls will return false. Thus, though you may be able to 'cheat' the system, this hardly benefits you in any way. Casting this object to IEnumerator produces a generator that is useless until the GetEnumerator method is called. At the same time, if a generator seems 'dead', it may suddenly start working after the GetEnumerator method call.
The code below demonstrates this behavior:. What do you think the console will display after the code above is executed? Hint: The code produces the Fibonacci sequence's first five elements - 1, 1, 2, 3, 5. We have just reviewed a case of casting to IEnumerator.
Is it possible to play around with casting to IEnumerable? Obviously, an object returned by GetEnumerator 's first call can be cast to IEnumerable and will work as expected.
Take a look at this example:. This code above prints three 'True' entries in the console window, because all three references point to the same object. Here, casting does not bring any surprises, and will produce a link to an existing and, therefore, correctly working object. What about a different scenario? For example, GetEnumerator is called for the second time or in a different thread - and the value it returns is cast to IEnumerable.
Take a look at this sample yield method:. At a first glance the RepeatLowerString method receives a string as a parameter, converts it to lowercase and returns it indefinitely. Have you noticed something odd in the code above? The RepeatLowerString method, opposite to what you may expect, generates a sequence of references to the unchanged someString string.
This happens because the ToLower method creates a new string and does not modify the original string. It is not too important in our case, but in real software such mistakes lead to sad consequences and they are worth fighting against.
An incorrect ToLower method call may not seem significant. However, sometimes a function is called incorrectly somewhere in a large pile of code - and that error is almost impossible to track down. If the project is large, its developers often use a static code analyzer. A static code analyzer is an application that can quickly detect many code bugs.
For example, a static code analyzer could scan the RepeatLowerString method and find that error I described earlier. However, the analyzer is definitely not limited to detecting "meaningless calls" - it covers an extensive list of problems. I recommend that you use a static analyzer on your projects. The PVS-Studio tool is a good choice. You can read more about PVS-Studio on its official website and get the analyzer's free trial version. All this masterful formation will crash with NullReferenceException.
Didn't expect this? Maybe not. Buy now we already have enough information to explain this behavior. Let's walk through the example step-by-step.
The exception was thrown when magicEnumerator. MoveNext called the ToLower method. ToLower is called for the someString parameter. But where did this value come from? Is that where null came from? Yes it is. But how did null end up in this field?
Let's take one more look at the code snippet:. Sadly, no. So this field gets the default value - that is, that very null. If GetEnumerator returns something other than this , the resulting object cannot fulfill the role of IEnumerable. This peculiarity does not affect yield methods that do not require any parameters. The GetPositive method returns an ascending sequence of positive numbers, starting with 1. Now take a look at the GetPositive method use example:.
This code works correctly and displays numbers 1 through 5 on the screen. But don't do this. No, really :. When reviewing the generated class, you may have an inevitable question: why this class has two fields to store the parameter value - instead of one.
By this time, you may have guessed what is happening here, but just in case, let's take a closer look. This is a simple method that produces an ascending sequence of integers, starting with i that is passed as a parameter.
The created generator's MoveNext method looks something like this:. Look closely. This field's initial value was set at the GetEnumerator method's call. The GetInts yield method we listed earlier returns IEnumerable type objects.
For this type of objects you can call GetEnumerator several times. As we know, at the first call the generator returns itself. Keeping this thought in mind, let's take a look at the following code:. In the first line, GetInts is called, and it returns the enumerable generator. Then we get firstEnumerator. This will be practically the same object as enumerable. At the GetEnumerator method's call, an IEnumerator type object is returned.
Then the MoveNext method is called a couple of times. At the end of the code snippet, the second IEnumerator is acquired. Obviously, the value is the same as the one passed to the GetInts yield method initially. Objects the GetEnumerator method returns, are to an extent independent of each other. To start generating sequences, they use parameters passed at the yield method's call. This is possible thanks to storing the original parameter in an additional field.
Above we reviewed a few features of generators, whose classes are based on yield methods that return IEnumerable. All of them are in some way connected to the fact that the generator class implements both IEnumerator and IEnumerable. Everything is much simpler with classes generated based on methods that return IEnumerator , because such generator classes do not implement IEnumerable. Consequently, type casting tricks we discussed earlier will not work anymore.
Below I listed the main features of classes generated for the yield method that returns IEnumerator and the yield method that returns IEnumerable :.
Aside from this, there is a slight difference in how the generator classes are created. You may remember when a generator class is created for the yield method that returns IEnumerable , a '-2' value is recorded to the state field and the value is changed only when GetEnumerator is called.
When state is '-2', the MoveNext method does not do anything and returns false. If a generator is created for a method that returns IEnumerator , it does not have any GetEnumerator methods.
Which is why '0' is recorded to the state field right after an item is instantiated. In most cases the generator's Dispose method is empty. However, sometimes Dispose contains code. These cases involve the using operator.
0コメント