C# String GetEnumerator() Method

What You’ll Learn

The instance method GetEnumerator() returns a CharEnumerator that walks through a string character by character. It powers foreach loops over strings and is useful when you need explicit control with MoveNext() and Current.

Definition and Usage

In C#, GetEnumerator() provides an enumerator for the characters in a string. Because string implements IEnumerable<char>, you can iterate characters with foreach—but calling GetEnumerator() directly shows how that works under the hood.

The returned CharEnumerator is a lightweight struct. Call MoveNext() to advance; when it returns true, read the character from Current. When it returns false, you have reached the end of the string.

📝 Syntax

The public typed overload on System.String:

public CharEnumerator GetEnumerator();

CharEnumerator members

• MoveNext() — advances to the next character. Returns false at the end.
• Current — the char at the current position (valid after MoveNext() returns true).
• Reset() — returns to before the first character (rarely used).

Return Value

A CharEnumerator positioned before the first character. You must call MoveNext() before reading Current.

Examples Gallery

Run with dotnet run. Each example shows how to iterate string characters—from manual CharEnumerator usage to foreach, counting, and index-based loops.

using System;

class Program {
    static void Main() {
        string sampleString = "C# Enumerator";

        CharEnumerator en = sampleString.GetEnumerator();

        Console.Write("Characters: ");
        while (en.MoveNext()) {
            Console.Write(en.Current + " ");
        }
    }
}

Characters: C #   E n u m e r a t o r 

using System;

class Program {
    static void Main() {
        string text = "C#";

        Console.Write("Via foreach: ");
        foreach (char c in text) {
            Console.Write(c + " ");
        }
    }
}

Via foreach: C # 

using System;

class Program {
    static void Main() {
        string word = "Enumerator";
        int vowels = 0;

        CharEnumerator en = word.GetEnumerator();
        while (en.MoveNext()) {
            char c = char.ToLower(en.Current);
            if (c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u') {
                vowels++;
            }
        }

        Console.WriteLine($"Vowels in '{word}': {vowels}");
    }
}

Vowels in 'Enumerator': 5

using System;

class Program {
    static void Main() {
        string text = "ABC";

        for (int i = 0; i < text.Length; i++) {
            Console.WriteLine($"Index {i}: '{text[i]}'");
        }
    }
}

Index 0: 'A'
Index 1: 'B'
Index 2: 'C'

using System;
using System.Text;

class Program {
    static void Main() {
        string input = "Order #1042-A";
        StringBuilder digits = new StringBuilder();

        foreach (char c in input) {
            if (char.IsDigit(c)) {
                digits.Append(c);
            }
        }

        Console.WriteLine($"Digits only: {digits}");
    }
}

Digits only: 1042

🚀 Common Use Cases

• Character-by-character validation — check each symbol in a password or identifier.
• Custom parsing — walk input and build tokens without regex.
• Learning IEnumerable — understand how foreach works on strings.
• Legacy APIs — code that accepts or returns IEnumerator / CharEnumerator.
• Streaming-style reads — forward-only processing of large strings one char at a time.

📝 Notes

• CharEnumerator is a struct—lightweight and stack-friendly.
• Enumeration is forward-only; you cannot move backward.
• Do not read Current before the first successful MoveNext().
• foreach (char c in text) is the idiomatic alternative for most code.
• Strings implement IEnumerable<char>, enabling LINQ like text.Count(c => ...).
• Iteration does not modify the string—C# strings are immutable.

⚡ Optimization

GetEnumerator() and foreach over strings are efficient for typical lengths. For hot paths on large text, consider ReadOnlySpan<char> to avoid enumerator allocation patterns in some scenarios. For simple length checks, use text.Length instead of counting with an enumerator. Choose the style that balances readability and need.

💡 Best Practices