C# 9 Detailed explanation of the example using foreach extension

In C# 9, the foreach loop can use the extension method. In this article, we will review with examples how to extend a foreach loop in C# 9.

Code Demo

Here is an example code for performing a depth-first traversal of a tree structure:

using System;
using ;
 
namespace Example
{
    class TreeNode
    {
        public int Value { get; set; }
        public List<TreeNode> Children { get; set; }
 
        public TreeNode(int value)
        {
            Value = value;
            Children = new List<TreeNode>();
        }
    }
 
    static class TreeExtensions
    {
        public static IEnumerable<TreeNode> DepthFirst(this TreeNode root)
        {
            yield return root;
            foreach (var child in (DepthFirst))
            {
                yield return child;
            }
        }
    }
 
    class Program
    {
        static void Main(string[] args)
        {
            var root = new TreeNode(1);
            (new TreeNode(2));
            (new TreeNode(3));
            [0].(new TreeNode(4));
            [0].(new TreeNode(5));
 
            foreach (var node in ())
            {
                ();
            }
            // Outputs: 1 2 4 5 3
        }
    }
}

In this example code, we define a value attribute and a list attribute for storing child nodes in the TreeNode class. We also define a DepthFirst extension method in the TreeExtensions class, which uses the yield return statement to return the depth-first traversal results of the tree structure.

In the Main method, we create a tree structure and then use a foreach loop to traverse the depth-first traversal results of the tree structure.

The reason for using extension methods is often because we can add new functionality to the TreeNode class without modifying the TreeNode class.

Then next we hope to add the DepthFirst behavior to the TreeNode class by default in C# 9, so that we can directly use the foreach loop to traverse the depth-first traversal results of the tree structure.

Foreach extension in C# 9

In C# 9, we can use the foreach extension to achieve the above requirements. We just need to add a GetEnumerator method to the TreeNode class, which returns an object that implements the IEnumerable interface.

static class TreeExtensions
{
    public static IEnumerable<TreeNode> DepthFirst(this TreeNode root)
    {
        yield return root;
        foreach (var child in (DepthFirst))
        {
            yield return child;
        }
    }
 
    public static IEnumerator<TreeNode> GetEnumerator(this TreeNode root)
    {
        return ().GetEnumerator();
    }
}

In the above code, we added a GetEnumerator method to the TreeNode class, which returns an object that implements the IEnumerable interface. This object is the result we use the yield return statement in the DepthFirst method.

Now we can directly use the foreach loop to traverse the depth-first traversal results of the tree structure.

foreach (var node in root)
{
    ();
}

Summarize

In C# 9, we can use the foreach extension to add new behavior to the class. In the example code above, we added the DepthFirst behavior to the TreeNode class so that we can directly use the foreach loop to traverse the depth-first traversal results of the tree structure.

This is the end of this article about the detailed explanation of C# 9's example using foreach extension. For more related contents of C# 9 foreach extension, please search for my previous articles or continue browsing the related articles below. I hope everyone will support me in the future!