What is the equilivant syntax in vb.net for "yield return"?

Question

Using the c# code below, how would you write it in vb? What is it trying to say?

using System;
using System.Collections.Generic;
using System.IO;
using System.Windows;
using System.Windows.Media;
using System.Windows.Media.Imaging;

namespace Microsoft.LiveLabs.Pivot
{
    /// <summary>
    /// Tile Builder class
    /// </summary>
    public static class TileBuilder
    {
        /// <summary>
        /// Specifies which images are required in the images array used in CreateTile according to the morton fractal pattern used by Seadragon.
        /// </summary>
        /// <remarks>
        /// Usage of this and CreateTile are kind of tricky. Here's an example:
        /// Say you have a results set that is a collection of items like so: { item1, item2, ..., item100 }
        /// Since Seadragon expects the tiles to be laid out in a Morton pattern, level 6 will look like the following:
        /// --------------------------
        /// |0   1   4   5  | 16  17...
        /// |2   3   6   7  | 18  19
        /// |8   9   12  13 | 24  25
        /// |10  11  14  15 | 26  27
        /// |-----------------------
        /// |32  33  36  37 | 48  49
        /// |34  35  38  39 | 50  51...
        /// |.          .
        /// |.          .
        ///  .          .
        ///  Each tile at level 6 is 4x4, so the dashes represent tile boundaries. Now, say you want to build 0,0.
        ///  You need the images on that tile. The ids 0, 1, 4, 5... represent the ids in your result set, { item1, item2, ..., item100 }.
        ///  Calling this method tells you the ids to use for a given tile. You then must retrieve the necessary images out the result set,
        ///  and supply them in the order this method gave you to CreateTile. This will result in a correctly built tile that Seadragon can use.
        /// </remarks>
        /// <param name="imageCount">Number of images in the full set.</param>
        /// <param name="level">The level to which each image will be downsampled.</param>
        /// <param name="row">The row number which specifies what images to render.</param>
        /// <param name="column">The row number which specifies what images to render.</param>
        /// <param name="tileSize">The size of the tile to return.</param>
        public static IEnumerable<int> GetTileIds(
          int imageCount,
          int level,
          int row,
          int column,
          int tileSize)
        {
            // calculate upper-left hand corner of tile in image space (1 unit = 1 image)
            int levelSize = (int)Math.Pow(2, level);
            int imagePerSide = tileSize / levelSize;
            int xOffset = row * imagePerSide;
            int yOffset = column * imagePerSide;

            if (imagePerSide <= 0)
            {
                throw new ArgumentOutOfRangeException("Level is greater than the maximum depth allowed by the tile size, or the tile size is 0.");
            }

            // loop through x and y in image space, starting at the upper-left hand corner of the tile
            // find all ids on the given tile
            for (int x = 0; x < imagePerSide; x++)
            {
                for (int y = 0; y < imagePerSide; y++)
                {
                    int n = XYToMorton(x + xOffset, y + yOffset);
                    if (n < imageCount)
                    {
                        yield return n;
                    }
                }
            }
        }

        /// <summary>
        /// Create a tile for a collection according to the morton fractal pattern used by Seadragon.
        /// </summary>
        /// <remarks>
        /// See GetTileIds for more information.
        /// </remarks>
        /// <param name="imageCount">The total number of images in the collection.</param>
        /// <param name="images">Jpeg images to render on this tile.
        /// If this is null, a blank tile will be returned.
        /// See GetTileIds remarks for more information.</param>
        /// <param name="level">The level to which each image will be downsampled.</param>
        /// <param name="row">The row number which specifies what images to render.</param>
        /// <param name="column">The row number which specifies what images to render.</param>
        /// <param name="tileSize">The size of the tile to return.</param>
        /// <param name="output">The stream to use to output the result.</param>
        public static void CreateTile(
          int imageCount,
          IEnumerable<ImageBag> images,
          int level,
          int row,
          int column,
          int tileSize,
          string fileType,
          Stream output)
        {
            // calculate upper-left hand corner of tile in image space (1 unit = 1 image)
            int levelSize = (int)Math.Pow(2, level);
            int imagePerSide = tileSize / levelSize;
            int xOffset = row * imagePerSide;
            int yOffset = column * imagePerSide;

            if (imagePerSide <= 0)
            {
                throw new ArgumentOutOfRangeException("Level is greater than the maximum depth allowed by the tile size, or the tile size is 0.");
            }

            if (output == null)
            {
                throw new ArgumentNullException("The given output stream is null.");
            }

            // create the tile
            WriteableBitmap outputBitmap = new WriteableBitmap(
              tileSize,
              tileSize,
              96,
              96,
              PixelFormats.Bgr24,
              null);

            // if images is null, return a blank tile
            if (images != null)
            {
                // loop through the tile in relative x and y image-space
                IEnumerator<ImageBag> imageEnumerator = images.GetEnumerator();
                for (int x = 0; x < imagePerSide; x++)
                {
                    for (int y = 0; y < imagePerSide; y++)
                    {
                        // convert to morton id-space from the absolute image-space (to get absolute, add offsets)
                        int n = XYToMorton(x + xOffset, y + yOffset);
                        if (n < imageCount)
                        {
                            if (imageEnumerator.MoveNext())
                            {
                                if (imageEnumerator.Current == null)
                                {
                                    continue;
                                }

                                // compute the pixel location
                                int locX = levelSize * x;
                                int locY = levelSize * y;

                                int width = 0;
                                int height = 0;
                                imageEnumerator.Current.ImageSize(out width, out height);
                                MemoryStream imageStream = new MemoryStream(imageEnumerator.Current.ImageData);

                                // determine the largest tile size to the nearest power of two for this image: 2^ceil(lg max(width, height))
                                double maxTileSize = Math.Pow(2, Math.Ceiling(Math.Log(Math.Max(width, height), 2)));

                                // downsample to the correct size and decompress the image
                                // the correct size is total dimenion of the image * level size / max tile size required for total width
                                // think of this as dividing the dimensions by two foreach level, starting at the max tile size, 
                                // and going up to the current tile size
                                TransformedBitmap downsampledImage = JpegDecoder.DownsampleJpeg(
                                  imageStream,
                                  Math.Ceiling(width * levelSize / maxTileSize),
                                  Math.Ceiling(height * levelSize / maxTileSize));

                                // copy the pixels to a buffer and then write them to the appropriate region on the output image
                                int stride = (downsampledImage.PixelWidth * downsampledImage.Format.BitsPerPixel + 7) / 8;
                                byte[] buffer = new byte[stride * downsampledImage.PixelHeight];
                                downsampledImage.CopyPixels(buffer, stride, 0);

                                Int32Rect outputRect = new Int32Rect(locX, locY, downsampledImage.PixelWidth, downsampledImage.PixelHeight);
                                outputBitmap.WritePixels(outputRect, buffer, stride, 0);
                            }
                            else
                            {
                                // we should render the image, but we're done with our list
                                // so, exit both loops
                                x = imagePerSide;
                                y = imagePerSide;
                            }
                        }
                        else
                        {
                            // since n is monotonic wrt y, we know y has gone too far down, so we can reset it
                            y = imagePerSide;
                        }
                    }
                }
            }

            // write the output
            BitmapFrame outputFrame = BitmapFrame.Create(outputBitmap);
            BitmapEncoder encoder = new JpegBitmapEncoder();
            encoder.Frames.Add(outputFrame);
            encoder.Save(output);
        }

        /// <summary>
        /// Converts an x and y to a Morton number
        /// </summary>
        /// <param name="x">x location to convert.</param>
        /// <param name="y">y location to convert.</param>
        /// <returns>Returns the morton number which corresponds to the given x and y coordinates.</returns>
        private static int XYToMorton(int x, int y)
        {
            const uint BITS_PER_BYTE = 8;
            const uint BIT_PAIRS = sizeof(int) * BITS_PER_BYTE / 2;

            int morton = 0;
            for (int i = 0; i < BIT_PAIRS; i++)
            {
                morton |= (x & 1) << (i * 2);
                morton |= (y & 1) << ((i * 2) + 1);
                x >>= 1;
                y >>= 1;
            }

            return morton;
        }
    }
}

Answer 1

There is none. Period.

Unless you are going to write your own state machine there is no quick fix for this.

http://weblogs.asp.net/jgaylord/archive/2007/10/17/vb-net-s-quot-yield-return-quot.aspx

For those who care about what is actually generated (yes I love the C# precompiler and compiler :)

Try compiling this and take a look at the generated code with Reflector or something:

class Program
{
    static void Main(string[] args)
    {
        var foo = new Foo();

        foreach(var result in foo.Bar())
        {
            Console.WriteLine(result);
        }

        Console.ReadLine();
    }
}

class Foo
{
    public IEnumerable<char> Bar()
    {
        const char start = 'a';

        for(int x = 0;x < 26;x++)
        {
            yield return (char)(start + x);
        }
    }
}

I'm not going to copy the result, it's huge. But do take a look, you'll see that it isn't simple to solve.

Answer 2

There is no equivalent to yield return in VB.NET, but it can be emulated.

See this SO question and answers (Yield In VB.NET).

Perhaps this article in Visual Studio magazine will help (Use Iterators in VB Now).

Answer 3

There is no exact duplicate of yield in VB. Your best bet would be to create the collection that is being yielded and return it whole for the calling code to iterate over. This isn't quite exactly the same as the code you've given, but it should have the same overall effect. yield is essentially just syntactic sugar for returning parts of a collection to an foreach loop one at a time to optimize run time and allow for early breakout (if you decide you don't need to enumerate over everything after all).

Answer 4

There isn't. You can however, create one.
Create an iterator class.
A few steps to doing this:

1. Create a function that is basically a step in the iteration. The function should take whatever arguments each computation needs, and return the arguments for the next computation. (to implement yield break aswell as yield return this function would need to also be able to return some boolean marking the end)
2. Create a class that implements IEnumerator. The Current property should return the latest computed value, the Reset should reset all the values to their initial ones, and the MoveNext function should compute the next value, and if the computing function returns a false, return a false itself.

For extra credit, make the class generic and capable to work with any function given to it by a delegate.
You can simplify this a bit and make MoveNext be the calculating function itself, but this way it's easy to create different iterators out of the same class implementation.

Answer 5

A block of code with yield return/yield break statements is called an iterator. This feature doesn't exist in VB. Of course, it is possible to "translate" that code, but it's not very straightforward... you need to create a custom class implementing IEnumerator(Of Integer) to reproduce exactly the same behavior :

• Initialize it with the parameters of the original function
• Implement the "loop" logic in the MoveNext method, by storing the loop variables in private fields. This method should also set a field to hold the current value (n in the original function)
• Return the current value from the Current property
• Reset the loop variables in the Reset method
• Do nothing in the Dispose method

It's doable, but honestly, it's a pain...

Another, easier option would be to fill a List(Of Integer) with the results and return that list : just replace yield return n with list.Add(n)