LeetCode: maximum-depth-of-n-ary-tree
Your solution seems pretty optimal - for breadth-first traversal (see below)


MaxDepth() could/should be static.  The containing class too.
The LeetCode question does not require breadth-first traversal.
Depth first would not require an(y) additional data structure (no queue, but would implicitly use the stack) 
which might be optimised away by tail-recursion (if C# is smart enough).


The following is therefore not criticism but a suggested alternative.
- I would not expect (much of) a performance difference
- Space-advantage, if significant (due to tail-recursion optimisation, compiler-and/or run-time environment dependent) would have to be measured
- So the main consideration in (not) choosing depth-first traversal would be a (probably) religious argument about brevity/readability of code

public static int MaxDepth2(IEnumerator&lt;Node&gt; nodeEnum = null, int depth = 0)
{
  //  No current node
  if (nodeEnum == null || !nodeEnum.MoveNext()) return depth;

  //  The greater of current and maximum of siblings
  using (var nodeEnumInner = nodeEnum.Current?.children?.GetEnumerator())
    return Math.Max(MaxDepth2(nodeEnumInner, depth + 1), MaxDepth2(nodeEnum, depth));
}

:
:
using (var nodeEnum = new List&lt;Node&gt; { root }.GetEnumerator())
  depth2 = MaximumDepthOfN_aryTree.MaxDepth2(nodeEnum);