This week we continue with iterators to get the functionality of
IEnumerable without the nasty garbage creation. This week the little iterator library gets support for sorting and binary searching. Read on for the details!
Posts Tagged iterator
Back from a brief break, we pick up this week by finishing up the “modifying sequence operations” with some gems like
RandomShuffle and go through the “partitions” category with functions like
IsPartitioned. These are all solid algorithms with a lot of potential uses, so read on to see how to use them with iterators and for the source code that implements them!
Last week’s article introduced the concept of iterators as an alternative to the GC-heavy
IEnumerable. Today’s article expands the iterator library to include a bunch of more functions to make it useful. Think of these like the extension functions in
IndexOf, etc. These have all been tailored to iterators and none of them will create any garbage whatsoever.
In C#, just about everything is an
IEnumerable. Since LINQ syntax,
foreach loops, and the
System.Linq namespace are all designed to work with
IEnumerable, you’ve got lots of tools to use. Unfortunately, the core of
IEnumerable is the
GetEnumerator function which usually creates garbage and eventually causes memory fragmentation and GC framerate spikes. Do we simply stop using all of these nice tools? Normally the answer is “yes”, but today’s article shows you another way.
Coroutines are a fundamental building block of Unity scripting. In 5.3, we got a new class to make them more powerful:
CustomYieldInstruction. Today we’ll look at it and see if we can make an arbitrarily-interruptible
YieldInstruction so our coroutines can abort the things they
yield. Read on to see how and to compare against the old 5.2 way!
Unity’s coroutine support is great. So great that it’s easy to go overboard and end up with too many of them. That could be for any number of reasons. Perhaps the coroutines are using too much memory or have too many files open at once. In any case, you’ll need to find a way to limit how many are running at a single time. Today’s article introduces a solution to the problem that queues coroutines so you never have too many running. Read on to learn about the solution and for the class that implements it.
Iterators (functions that
yield) are great for representing asynchronous processes such as web calls, updating state over time, and multi-step operations. One unfortunate downside is that it’s tough to return a result from them. Today’s article explores several workarounds to this problem before ultimately arriving at a clean, easy-to-use solution to the problem. Read on to learn how to make iterators more useful!
As you use iterator functions (and
yield) more and more, you’ll start to run into some limitations in the C# language. For instance, you can’t
yield inside a
try block that has a
catch block. And the
foreach loop doesn’t provide a very good way to catch exceptions when looping over an iterator function, either. Today’s article goes into detail to find solutions to these issues and make iterator functions usable in even the trickiest scenarios!
Continuing the series on C# syntax, today we’ll look at the differences an AS3 programmer can expect to encounter when using conditionals (
switch/case/break/goto) and exceptions (
try/catch/finally/throw). We’ll also look at iterators, an all-new category for AS3 programmers that empowers us to both iterate however we want and to write coroutines, a kind of lightweight pseudo-thread.