Iterator pattern in C#

 Hello, C# lovers! 😍

Today I want to talk about one of the most useful and elegant design patterns in C#: the Iterator pattern. 🙌

The Iterator pattern allows you to access the elements of a collection in a sequential manner without exposing its internal representation. 🤫

This way, you can abstract away the details of how the collection is stored and manipulated, and focus on what you want to do with the elements. 😎

The Iterator pattern is very common in C#, as it is used by the foreach loop and LINQ queries. 💯

Let’s see how it works with a simple example. Suppose you have a collection of stocks that you want to iterate over. You can define an interface for an iterator that provides methods to get the current element and move to the next one:


// The iterator interface
public interface IIterator<T>
{
    // Returns the current element
    T Current { get; }

    // Moves to the next element and returns true if successful
    bool MoveNext();
}


Then, you can define an interface for a collection that provides a method to create an iterator:


// The collection interface
public interface ICollection<T>
{
    // Returns an iterator for the collection
    IIterator<T> CreateIterator();
}


Now, you can implement these interfaces for your stock collection and iterator classes:


// A class that represents a stock
public class Stock
{
    public string Symbol { get; set; }
    public decimal Price { get; set; }
}

// A class that represents a stock collection
public class StockCollection : ICollection<Stock>
{
    // An list of stocks as the internal representation
    private readonly List<Stock> _stocks = new List<Stock>();


    // A method to add a stock to the collection
    public void Add(Stock stock)

    {
        _stocks.Add(stock);

    }

    // A method to create an iterator for the collection
    public IIterator<Stock> CreateIterator()
    {
        return new StockIterator(this);
    }

    // A nested class that implements the iterator interface
    private class StockIterator : IIterator<Stock>
    {
        // A reference to the outer collection
        private StockCollection collection;

        // An index to keep track of the current position
        private int index = -1;

        // A constructor that takes the collection as a parameter
        public StockIterator(StockCollection collection)
        {
            this.collection = collection;
        }

        // A property that returns the current element
        public Stock Current
        {
            get
            {
                // Check if the index is valid
                if (index < 0 || index >= collection.stocks.Count)
                {
                    throw new InvalidOperationException();
                }

                // Return the stock at the current index
                return collection.stocks[index];
            }
        }

        // A method that moves to the next element and returns true if successful
        public bool MoveNext()
        {
            // Increment the index and check if it is within bounds
            index++;
            return index < collection.stocks.Count;
        }
    }
}


With this implementation, you can use your stock collection and iterator like this:


// Create a stock collection
StockCollection stockCollection = new StockCollection();

// Add an array of stocks
stockCollection.Add(new Stock { Symbol = "MSFT", Price = 300.25m });
stockCollection.Add(new Stock { Symbol = "AAPL", Price = 150.50m });
stockCollection.Add(new Stock { Symbol = "AMZN", Price = 3500.00m });

// Create an iterator for the collection
IIterator<Stock> iterator = stockCollection.CreateIterator();

// Iterate over the stocks using the iterator
while (iterator.MoveNext())
{
    // Get the current stock and print its details
    Stock stock = iterator.Current;
    Console.WriteLine($"{stock.Symbol}: {stock.Price}");
}


The output of this code is:


MSFT: 300.25
AAPL: 150.50
AMZN: 3500.00


As you can see, the iterator pattern makes it easy to iterate over any kind of collection without knowing how it is implemented internally. 🙌

You can also use different kinds of iterators for different purposes, such as filtering, sorting, or reversing the order of elements. 🚀

The iterator pattern is so useful that C# provides a standard way to implement it using IEnumerable and IEnumerator interfaces. These interfaces are similar to our custom ones, but they also support generics and IDisposable. 🌟

You can also use yield return statements to create iterators in a more concise and elegant way. 😍

For more information on how to use these features, check out these links:

That’s all for today, folks! I hope you enjoyed this article and learned something new about the iterator pattern in C#. 😊

If you have any questions or feedback, feel free to leave a comment below. 👇

And don’t forget to subscribe to my blog for more awesome C# content! 🔥

You can find the code examples here: source code

Happy coding! 😄

Comments

Post a Comment

Popular posts from this blog

Which GOF patterns are good for C#?

Hello, C# fans! 😊 In this article, I will answer a common question that many C# developers have: which GOF patterns are good for C#? 🤔 GOF patterns are the 23 design patterns that were described in the book “ Design Patterns: Elements of Reusable Object-Oriented Software ” by Erich Gamma, Richard Helm, Ralph Johnson, and John Vlissides. They are also known as the Gang of Four (GoF) patterns. They are divided into three categories: creational, structural, and behavioral. 📚 These patterns provide solutions to common software design problems that you may encounter in your projects. They help you write code that is more reusable, flexible, maintainable, and elegant. 😍 But not all GOF patterns are equally useful or applicable in C#. Some of them are more relevant and popular than others. Some are already supported by the language features or the .NET framework. Some of them may be outdated or replaced by newer patterns. 😮 So, which GOF patterns are good for C#?  Creational patterns...
Read more

Angular on a regular SharePoint page (part 2)

Image
In my  previous article , we have added an empty angular element to the SharePoint page.  And now we are ready to move forward and add some functionality to our elements. Before we begin      First of all, let's create in SharePoint Announcements list with the name "Announcements" and add a couple of items with some text. We will access data in our list via the SharePoint REST API, calling "/_api/web/lists/getbytitle('Announcements')/Items" endpoint. Angular project      Now, open the angular elements project which we have created in the previous article in VS Code.      For convenience let's create an interface to work with our data model. Create the "data" folder wonder the "src/app" and create a new file named Announcement.ts.      Add this code to it: export interface Announcement { ID : number ; Title : string ; Body : string ; }      We will use the service to get the data from our list. ...
Read more

Chain of Responsibility pattern in C#

Hello, C# lovers! 😍 Today I want to talk about a very useful design pattern called Chain of Responsibility. This pattern allows you to pass a request along a chain of handlers until one of them can handle it. This way, you can avoid coupling the sender of the request with the receiver, and you can dynamically compose the chain at runtime. Sounds cool, right? 😎 Let’s see an example of how to implement this pattern in C#. Suppose you have a simple ATM machine that can dispense bills of 10, 20, and 50 dollars. You want to write a program that can handle any amount of money requested by the user, using the least number of bills possible. To do this, you can create an abstract class called Handler that defines an interface for handling the requests. It also has a reference to the next handler in the chain, and a method to set it. // The 'Handler' abstract class public abstract class Handler { protected Handler successor; public void SetSuccessor ( Handler successo...
Read more