# Collections\_IEnumerator

***

**1. Iterating through a List**

```csharp
using System.Collections;

List<int> numbers = new List<int> { 1, 2, 3, 4, 5 };
IEnumerator enumerator = numbers.GetEnumerator();
while (enumerator.MoveNext())
{
    Console.WriteLine(enumerator.Current);
}
```

**2. Iterating through a Dictionary**

```csharp
using System.Collections;

Dictionary<string, int> dictionary = new Dictionary<string, int> { { "One", 1 }, { "Two", 2 }, { "Three", 3 } };
IEnumerator enumerator = dictionary.GetEnumerator();
while (enumerator.MoveNext())
{
    KeyValuePair<string, int> pair = (KeyValuePair<string, int>)enumerator.Current;
    Console.WriteLine($"{pair.Key}: {pair.Value}");
}
```

**3. Iterating through a Stack**

```csharp
using System.Collections;

Stack<int> stack = new Stack<int>();
stack.Push(1);
stack.Push(2);
stack.Push(3);
IEnumerator enumerator = stack.GetEnumerator();
while (enumerator.MoveNext())
{
    Console.WriteLine(enumerator.Current);
}
```

**4. Iterating through a Queue**

```csharp
using System.Collections;

Queue<int> queue = new Queue<int>();
queue.Enqueue(1);
queue.Enqueue(2);
queue.Enqueue(3);
IEnumerator enumerator = queue.GetEnumerator();
while (enumerator.MoveNext())
{
    Console.WriteLine(enumerator.Current);
}
```

**5. Iterating through an Array**

```csharp
using System.Collections;

int[] array = { 1, 2, 3, 4, 5 };
IEnumerator enumerator = array.GetEnumerator();
while (enumerator.MoveNext())
{
    Console.WriteLine(enumerator.Current);
}
```

**6. Iterating through a String**

```csharp
using System.Collections;

string str = "Hello World";
IEnumerator enumerator = str.GetEnumerator();
while (enumerator.MoveNext())
{
    Console.WriteLine(enumerator.Current);
}
```

**7. Iterating through a File**

```csharp
using System;
using System.Collections;

string filePath = @"C:\path\to\file.txt";
using (StreamReader reader = new StreamReader(filePath))
{
    IEnumerator enumerator = reader.GetEnumerator();
    while (enumerator.MoveNext())
    {
        Console.WriteLine(enumerator.Current);
    }
}
```

**8. Iterating through a Web Request**

```csharp
using System;
using System.Collections;

string url = "https://example.com";
using (WebClient client = new WebClient())
{
    IEnumerator enumerator = client.GetWebRequest(url).GetEnumerator();
    while (enumerator.MoveNext())
    {
        Console.WriteLine(enumerator.Current);
    }
}
```

**9. Iterating through a SQL Query Result**

```csharp
using System;
using System.Collections;

string connectionString = @"Data Source=.\SQLEXPRESS;Initial Catalog=MyDatabase;Integrated Security=True";
using (SqlConnection connection = new SqlConnection(connectionString))
{
    connection.Open();
    using (SqlCommand command = new SqlCommand("SELECT * FROM MyTable", connection))
    {
        IEnumerator enumerator = command.ExecuteReader().GetEnumerator();
        while (enumerator.MoveNext())
        {
            Console.WriteLine(enumerator.Current);
        }
    }
}
```

**10. Iterating through a Form Collection**

```csharp
using System;
using System.Collections;

string formCollectionKey = "myKey";
IEnumerator enumerator = this.Request.Form.GetEnumerator();
while (enumerator.MoveNext())
{
    DictionaryEntry entry = (DictionaryEntry)enumerator.Current;
    if (entry.Key.ToString() == formCollectionKey)
    {
        Console.WriteLine(entry.Value);
    }
}
```

**11. Iterating through a Query String Collection**

```csharp
using System;
using System.Collections;

string queryStringKey = "myKey";
IEnumerator enumerator = this.Request.QueryString.GetEnumerator();
while (enumerator.MoveNext())
{
    DictionaryEntry entry = (DictionaryEntry)enumerator.Current;
    if (entry.Key.ToString() == queryStringKey)
    {
        Console.WriteLine(entry.Value);
    }
}
```

**12. Iterating through a Session Collection**

```csharp
using System;
using System.Collections;

string sessionKey = "myKey";
IEnumerator enumerator = this.Session.GetEnumerator();
while (enumerator.MoveNext())
{
    DictionaryEntry entry = (DictionaryEntry)enumerator.Current;
    if (entry.Key.ToString() == sessionKey)
    {
        Console.WriteLine(entry.Value);
    }
}
```

**13. Iterating through a Application Collection**

```csharp
using System;
using System.Collections;

string applicationKey = "myKey";
IEnumerator enumerator = this.Application.GetEnumerator();
while (enumerator.MoveNext())
{
    DictionaryEntry entry = (DictionaryEntry)enumerator.Current;
    if (entry.Key.ToString() == applicationKey)
    {
        Console.WriteLine(entry.Value);
    }
}
```

**14. Iterating through a Control Collection**

```csharp
using System;
using System.Collections;

foreach (Control control in this.Controls)
{
    Console.WriteLine(control.ID);
}
```

**15. Iterating through a Collection of Controls**

```csharp
using System;
using System.Collections;

ArrayList controls = new ArrayList();
controls.Add(this.Label1);
controls.Add(this.TextBox1);
controls.Add(this.Button1);
foreach (Control control in controls)
{
    Console.WriteLine(control.ID);
}
```

**16. Iterating through a Collection of Objects**

```csharp
using System;
using System.Collections;

ArrayList objects = new ArrayList();
objects.Add(new object());
objects.Add(new object());
objects.Add(new object());
foreach (object obj in objects)
{
    Console.WriteLine(obj);
}
```

**17. Iterating through a Collection of Strings**

```csharp
using System;
using System.Collections;

ArrayList strings = new ArrayList();
strings.Add("Hello");
strings.Add("World");
foreach (string str in strings)
{
    Console.WriteLine(str);
}
```

**18. Iterating through a Collection of Integers**

```csharp
using System;
using System.Collections;

ArrayList integers = new ArrayList();
integers.Add(1);
integers.Add(2);
integers.Add(3);
foreach (int integer in integers)
{
    Console.WriteLine(integer);
}
```

**19. Iterating through a Collection of Dates**

```csharp
using System;
using System.Collections;

ArrayList dates = new ArrayList();
dates.Add(new DateTime(2023, 1, 1));
dates.Add(new DateTime(2023, 2, 1));
dates.Add(new DateTime(2023, 3, 1));
foreach (DateTime date in dates)
{
    Console.WriteLine(date);
}
```

**20. Iterating through a Collection of Booleans**

```csharp
using System;
using System.Collections;

ArrayList booleans = new ArrayList();
booleans.Add(true);
booleans.Add(false);
foreach (bool boolean in booleans)
{
    Console.WriteLine(boolean);
}
```

**21. Iterating through a Collection of Objects with a Custom Enumerator**

```csharp
using System;
using System.Collections;

public class MyCollection<T> : IEnumerable<T>
{
    private T[] items;

    public MyCollection(T[] items)
    {
        this.items = items;
    }

    public IEnumerator<T> GetEnumerator()
    {
        return new MyEnumerator<T>(this.items);
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        return this.GetEnumerator();
    }
}

public class MyEnumerator<T> : IEnumerator<T>
{
    private T[] items;
    private int index;

    public MyEnumerator(T[] items)
    {
        this.items = items;
    }

    public T Current
    {
        get
        {
            return this.items[this.index];
        }
    }

    object IEnumerator.Current
    {
        get
        {
            return this.Current;
        }
    }

    public bool MoveNext()
    {
        this.index++;
        return this.index < this.items.Length;
    }

    public void Reset()
    {
        this.index = 0;
    }

    public void Dispose()
    {
        this.items = null;
    }
}
```

**22. Iterating through a Collection with a `foreach` Loop**

```csharp
using System;
using System.Collections;

public class MyCollection<T> : IEnumerable<T>
{
    private T[] items;

    public MyCollection(T[] items)
    {
        this.items = items;
    }

    public IEnumerator<T> GetEnumerator()
    {
        return ((IEnumerable<T>)this.items).GetEnumerator();
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        return this.GetEnumerator();
    }
}

public class Program
{
    public static void Main()
    {
        MyCollection<int> collection = new MyCollection<int>(new int[] { 1, 2, 3 });
        foreach (int item in collection)
        {
            Console.WriteLine(item);
        }
    }
}
```

**23. Iterating through a Collection with a `foreach` Loop and a Lambda Expression**

```csharp
using System;
using System.Collections;

public class MyCollection<T> : IEnumerable<T>
{
    private T[] items;

    public MyCollection(T[] items)
    {
        this.items = items;
    }

    public IEnumerator<T> GetEnumerator()
    {
        return ((IEnumerable<T>)this.items).GetEnumerator();
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        return this.GetEnumerator();
    }
}

public class Program
{
    public static void Main()
    {
        MyCollection<int> collection = new MyCollection<int>(new int[] { 1, 2, 3 });
        collection.ForEach(item => Console.WriteLine(item));
    }
}
```

**24. Iterating through a Collection with a `foreach` Loop and an Anonymous Method**

```csharp
using System;
using System.Collections;

public class MyCollection<T> : IEnumerable<T>
{
    private T[] items;

    public MyCollection(T[] items)
    {
        this.items = items;
    }

    public IEnumerator<T> GetEnumerator()
    {
        return ((IEnumerable<T>)this.items).GetEnumerator();
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        return this.GetEnumerator();
    }
}

public class Program
{
    public static void Main()
    {
        MyCollection<int> collection = new MyCollection<int>(new int[] { 1, 2, 3 });
        collection.ForEach(delegate(int item) { Console.WriteLine(item); });
    }
}
```

**25. Iterating through a Collection with a `while` Loop and an `IEnumerator`**

```csharp
using System;
using System.Collections;

public class MyCollection<T> : IEnumerable<T>
{
    private T[] items;

    public MyCollection(T[] items)
    {
        this.items = items;
    }

    public IEnumerator<T> GetEnumerator()
    {
        return ((IEnumerable<T>)this.items).GetEnumerator();
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        return this.GetEnumerator();
    }
}

public class Program
{
    public static void Main()
    {
        MyCollection<int> collection = new MyCollection<int>(new int[] { 1, 2, 3 });
        IEnumerator<int> enumerator = collection.GetEnumerator();
        while (enumerator.MoveNext())
        {
            int item = enumerator.Current;
            Console.WriteLine(item);
        }
        enumerator.Dispose();
    }
}
```

**26. Iterating through a Collection with a `do-while` Loop and an `IEnumerator`**

```csharp
using System;
using System.Collections;

public class MyCollection<T> : IEnumerable<T>
{
    private T[] items;

    public MyCollection(T[] items)
    {
        this.items = items;
    }

    public IEnumerator<T> GetEnumerator()
    {
        return ((IEnumerable<T>)this.items).GetEnumerator();
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        return this.GetEnumerator();
    }
}

public class Program
{
    public static void Main()
    {
        MyCollection<int> collection = new MyCollection<int>(new int[] { 1, 2, 3 });
        IEnumerator<int> enumerator = collection.GetEnumerator();
        do
        {
            int item = enumerator.Current;
            Console.WriteLine(item);
        } while (enumerator.MoveNext());
        enumerator.Dispose();
    }
}
```

**27. Iterating through a Collection with a `for` Loop and an `IEnumerator`**

```csharp
using System;
using System.Collections;

public class MyCollection<T> : IEnumerable<T>
{
    private T[] items;

    public MyCollection(T[] items)
    {
        this.items = items;
    }

    public IEnumerator<T> GetEnumerator()
    {
        return ((IEnumerable<T>)this.items).GetEnumerator();
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        return this.GetEnumerator();
    }
}

public class Program
{
    public static void Main()
    {
        MyCollection<int> collection = new MyCollection<int>(new int[] { 1, 2, 3 });
        IEnumerator<int> enumerator = collection.GetEnumerator();
        for (int i = 0; i < collection.Count; i++)
        {
            int item = enumerator.Current;
            Console.WriteLine(item);
            enumerator.MoveNext();
        }
        enumerator.Dispose();
    }
}
```

**28. Iterating through a Collection with a `foreach` Loop and an `IDictionaryEnumerator`**

```csharp
using System;
using System.Collections;

public class MyCollection<T> : IDictionary<string, T>
{
    private Dictionary<string, T> items;

    public MyCollection(Dictionary<string, T> items)
    {
        this.items = items;
    }

    public T this[string key]
    {
        get { return this.items[key]; }
        set { this.items[key] = value; }
    }

    public ICollection<string> Keys
    {
        get { return this.items.Keys; }
    }

    public ICollection<T> Values
    {
        get { return this.items.Values; }
    }

    public int Count
    {
        get { return this.items.Count; }
    }

    public bool IsReadOnly
    {
        get { return false; }
    }

    public void Add(string key, T value)
    {
        this.items.Add(key, value);
    }

    public bool ContainsKey(string key)
    {
        return this.items.ContainsKey(key);
    }

    public bool Remove(string key)
    {
        return this.items.Remove(key);
    }

    public bool TryGetValue(string key, out T value)
    {
        return this.items.TryGetValue(key, out value);
    }

    public void Clear()
    {
        this.items.Clear();
    }

    public IEnumerator<KeyValuePair<string, T>> GetEnumerator()
    {
        return this.items.GetEnumerator();
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        return this.GetEnumerator();
    }
}

public class Program
{
    public static void Main()
    {
        MyCollection<int> collection = new MyCollection<int>(new Dictionary<string, int> { { "One", 1 }, { "Two", 2 }, { "Three", 3

```