Software Dev/15 - Iterator.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Iterator\n",
    "\n",
    "## General idea\n",
    "The Iterator pattern is a behavioral design pattern that provides a way to access the elements of an aggregate object sequentially without exposing its underlying representation. It allows you to iterate over the elements of a collection in a consistent manner, regardless of the collection's specific implementation.\n",
    "\n",
    "## Benefits\n",
    "The Iterator pattern provides several benefits:\n",
    "\n",
    "- Simplified Access to Collection Elements: The Iterator pattern encapsulates the iteration logic within the iterator objects, providing a consistent interface for accessing and traversing the elements of a collection. It abstracts away the details of the collection's internal structure, making it easier and more convenient to iterate over the elements.\n",
    "\n",
    "- Independence between Clients and Collections: The Iterator pattern decouples the client code from the specific implementation of the collection. Clients only need to work with the Iterator interface, which provides a consistent way to access elements regardless of the collection type. This allows for flexible code that can work with different collections without modifications.\n",
    "\n",
    "- Supports Multiple Iterations: The Iterator pattern allows multiple iterators to coexist and iterate over the same collection independently. Each iterator maintains its own iteration state, enabling multiple concurrent iterations over the collection.\n",
    "\n",
    "- Encourages Single Responsibility Principle: The Iterator pattern promotes the single responsibility principle by separating the iteration logic from the collection itself. The collection is responsible for managing the elements, while the iterator is responsible for traversing them.\n",
    "\n",
    "- Easy Addition of New Collection Types: The Iterator pattern makes it easier to add new collection types without affecting the client code. By implementing the Iterator interface, new collection types can be seamlessly integrated with existing code that relies on iterators.\n",
    "\n",
    "- Enhanced Readability and Maintainability: The Iterator pattern improves the readability and maintainability of code by providing a clear and consistent way to iterate over collections. It reduces the need for repetitive and error-prone iteration code in the client codebase.\n",
    "\n",
    "> The Iterator pattern is commonly used in scenarios where there is a need to traverse and access the elements of a collection in a standardized way. It promotes code reuse, decouples the client from the collection implementation, and simplifies the process of iterating over collections.\n",
    "\n",
    "## How it works\n",
    "- Iterator: It defines the interface for accessing and traversing the elements of a collection. It typically includes methods like `Next()`, `HasNext()`, `CurrentItem()`, etc., that allow the client to iterate over the collection.\n",
    "\n",
    "- Concrete Iterator: It implements the Iterator interface and provides the actual implementation for traversing the collection. It keeps track of the current position and provides the necessary operations for moving to the next element, checking if there are more elements, and returning the current element.\n",
    "\n",
    "- Aggregate: It represents the collection of objects that the iterator will traverse. It defines a method, often called `CreateIterator()`, that returns an iterator object for the collection.\n",
    "\n",
    "- Concrete Aggregate: It implements the Aggregate interface and provides the implementation for creating the corresponding Concrete Iterator."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    },
    "polyglot_notebook": {
     "kernelName": "csharp"
    },
    "vscode": {
     "languageId": "polyglot-notebook"
    }
   },
   "outputs": [],
   "source": [
    "// Example of implementation of iterator pattern in C#\n",
    "\n",
    "// Iterator interface\n",
    "public interface IIterator<T>\n",
    "{\n",
    "    bool HasNext();\n",
    "    T Next();\n",
    "}\n",
    "\n",
    "// Aggregate interface\n",
    "public interface IAggregate<T>\n",
    "{\n",
    "    IIterator<T> CreateIterator();\n",
    "}\n",
    "\n",
    "// Concrete iterator\n",
    "public class ConcreteIterator<T> : IIterator<T>\n",
    "{\n",
    "    private readonly T[] items;\n",
    "    private int position = 0;\n",
    "\n",
    "    public ConcreteIterator(T[] items)\n",
    "    {\n",
    "        this.items = items;\n",
    "    }\n",
    "\n",
    "    public bool HasNext()\n",
    "    {\n",
    "        return position < items.Length;\n",
    "    }\n",
    "\n",
    "    public T Next()\n",
    "    {\n",
    "        T currentItem = items[position];\n",
    "        position++;\n",
    "        return currentItem;\n",
    "    }\n",
    "}\n",
    "\n",
    "// Concrete aggregate\n",
    "public class ConcreteAggregate<T> : IAggregate<T>\n",
    "{\n",
    "    private readonly T[] items;\n",
    "\n",
    "    public ConcreteAggregate(T[] items)\n",
    "    {\n",
    "        this.items = items;\n",
    "    }\n",
    "\n",
    "    public IIterator<T> CreateIterator()\n",
    "    {\n",
    "        return new ConcreteIterator<T>(items);\n",
    "    }\n",
    "}\n",
    "\n",
    "// Client\n",
    "public class Client\n",
    "{\n",
    "    public void Code()\n",
    "    {\n",
    "        // Create aggregate\n",
    "        int[] numbers = { 1, 2, 3, 4, 5 };\n",
    "        IAggregate<int> aggregate = new ConcreteAggregate<int>(numbers);\n",
    "\n",
    "        // Create iterator\n",
    "        IIterator<int> iterator = aggregate.CreateIterator();\n",
    "\n",
    "        // Iterate over the elements\n",
    "        while (iterator.HasNext())\n",
    "        {\n",
    "            int item = iterator.Next();\n",
    "            Console.WriteLine(item);\n",
    "        }\n",
    "    }\n",
    "}"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## In this example:\n",
    "\n",
    "- The `IIterator<T>` interface declares the methods `HasNext()` and `Next()`, which are used for iterating over the elements of a collection.\n",
    "\n",
    "- The `IAggregate<T>` interface declares the `CreateIterator()` method, which is responsible for creating an iterator object that can iterate over the collection.\n",
    "\n",
    "- The `ConcreteIterator<T>` class implements the `IIterator<T>` interface and provides the concrete implementation for iterating over an array of items.\n",
    "\n",
    "- The `ConcreteAggregate<T>` class implements the `IAggregate<T>` interface and creates a `ConcreteIterator<T>` object in its `CreateIterator()` method.\n",
    "\n",
    "- The `Client` class demonstrates how the Iterator pattern is used. It creates an instance of `ConcreteAggregate<T>` (in this case, an array of integers) and obtains an iterator by calling `CreateIterator()`. It then iterates over the elements using the iterator's `HasNext()` and `Next()` methods.\n",
    "\n",
    "> By utilizing the Iterator pattern, you can separate the iteration logic from the collection, making it easier to iterate over different types of collections using a common interface. The pattern promotes code reusability, decouples the client from the specific collection implementation, and provides a consistent way to traverse and access the elements of a collection."
   ]
  }
 ],
 "metadata": {
  "language_info": {
   "name": "python"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}