An implementation of breadth first search or BFS in C#.

BFS.cs

public class Tree<K, V>
    where K : class, IComparable<K>
    where V : class
{
    private Node<K, V> root;

    public V BFS(K key) 
    {
        Queue<Node<K, V>> queue = new Queue<Node<K, V>>();
        
        while(queue.Any())
        {
            var node = queue.Dequeue();

            if(node.key == key)
            {
                return node.value;
            }
            foreach (var child  in node.children)
            {
                queue.Enqueue(child);
            }
        }
        return default(V);
    }

    private class Node<K, V>
        where K : class, IComparable<K>
        where V : class
    {
        public K key;
        public V value;
        public Node<K, V>[] children;
    }
}

Almost exactly what I was looking for, however, the queue.Any() function will always return false since the Queue is initialized and no elements are enqueue'd. Adding the the root node or the first generation before the while loop should fix the issue.

I like the neat implementation. The code however does not ignore the nodes that have already been visited. This would cause an infinite traversal in a graph with cycles.

Type parameter K has the same type parameter from outer part <K,V>

Line 10 should say queue.Enqueue(rootNode);

FTFY. Credit due to suggestions from other comments.

public class Tree<K, V>
    where K : class, IComparable<K>
    where V : class
{
    private Node<K, V> root;

    public V BFS(K key)
    {
        Queue<Node<K, V>> queue = new Queue<Node<K, V>>();
        // collection of visited nodes
        HashSet<Node<K, V>> visited = new HashSet<Node<K, V>>();

        // start with "first" node
        queue.Enqueue(root);
        visited.Add(root);

        while (queue.Any())
        {
            var node = queue.Dequeue();

            if (node.key == key)
            {
                return node.value;
            }
            foreach (var child in node.children)
            {
                // only add child node if it has not already been visited
                if (!visited.Contains(child))
                {
                    // mark child node visited
                    visited.Add(child);
                    queue.Enqueue(child);
                }
            }
        }
        return default(V);
    }

    private class Node<K, V>
        where K : class, IComparable<K>
        where V : class
    {
        public K key;
        public V value;
        public Node<K, V>[] children;
    }
}