Seltsames Verhalten bei String.Compare

Hallo,
ich habe mir mit Hilfe von List<> und einem eigenen Typ einen Baum gebastelt.
Der eigene Typ MyTreeNode ist wie folgt implementiert:

public class MyTreeNode
{
private MyTreeNode _parent = null;
private List<MyTreeNode> _children = new List<MyTreeNode>();
private string _name;

public MyTreeNode Parent
{
get { return _parent; }
set 
{ 
_parent = value;
if (value != null)
value.AppendChild(this);
}
}

public List<MyTreeNode> Children
{
get { return _children; }
set { _children = value; }
}

public string Name
{
get { return _name; }
set { _name = value; }
}

public void AppendChild(MyTreeNode newChild)
{
if (!_children.Contains(newChild))
_children.Add(newChild);
}

public int CompareTo(object treeNode)
{
if (treeNode == null)
return 1;
else
return String.Compare(((MyTreeNode)treeNode).Name, this.Name, StringComparison.CurrentCultureIgnoreCase);
}
}

So, nun fülle ich die Liste bzw. den Baum:

List<MyTreeNode> myTree = new List<MyTreeNode>();
MyTreeNode rootNode1 = new MyTreeNode();
rootNode1.Name = "2099";
myTree.Add(rootNode1);

MyTreeNode rootNode2 = new MyTreeNode();
rootNode1.Name = "2006";
myTree.Add(rootNode2);

Nach dieser Art und Weise baue ich mir folgenden Baum auf:

2099
----- Klasse 10
----- Klasse 06
---------- NH-KL-06-02
---------- NH-KL-06-01
----- Klasse 12
----- Klasse 11
---------- NH-KL-10-05
---------- NH-KL-10-02
2006
----- Klasse 04
----- Klasse 02
---------- NH-KL-02-07
---------- NH-KL-02-01
---------- NH-KL-02-02

So weit, so gut.
Nun möchte ich jede Ebene sortieren. Dafür gehe ich den Baum Ebene für Ebene durch und wende List<>.Sort() an, welche meine CompareTo()-Methode verwendet, also nach dem Namen sortiert.

Ich erwarte also das Ergebnis:

2006
----- Klasse 02
---------- NH-KL-02-01
---------- NH-KL-02-02
---------- NH-KL-02-07
----- Klasse 04
2099
----- Klasse 06
---------- NH-KL-06-01
---------- NH-KL-06-02
----- Klasse 10
----- Klasse 11
---------- NH-KL-10-02
---------- NH-KL-10-05
----- Klasse 12

Seltsamerweise erhalte ich aber das Folgende als Ergebnis:

2099
----- Klasse 12
----- Klasse 11
---------- NH-KL-10-02
---------- NH-KL-10-05
----- Klasse 10
----- Klasse 06
---------- NH-KL-06-01
---------- NH-KL-06-02
2006
----- Klasse 04
----- Klasse 02
---------- NH-KL-02-01
---------- NH-KL-02-02
---------- NH-KL-02-07

Das heißt also, dass nur die letzte (unterste) Ebene richtig sortiert wird, alle darüberliegenden genau falsch herum. Kann sich das jemand erklären?

Falls es von Interesse ist, hier noch meine Sortiermethode:

private void SortiereEbene(List<MyTreeNode> ebene)
{
ebene.Sort();
for (int i = 0; i < ebene.Count; ++i)
{
if (ebene[i].Children.Count > 1)
SortiereEbene(ebene[i].Children);
}
}

Sorry für den langen Beitrag!!

Ich habe gerade meine Sortiermethode geändert. Und zwar habe ich das ebene.Sort() an das Ende der Methode verschoben:

private void SortiereEbene(List<MyTreeNode> ebene)
{
for (int i = 0; i < ebene.Count; ++i)
{
if (ebene[i].Children.Count > 1)
SortiereEbene(ebene[i].Children);
}
ebene.Sort();
}

Damit wird nun jede Ebene falsch herum sortiert.

String.Compare für sich genommen funktioniert natürlich richtig und wenn ich zwei Objekte vom Typ MyTreeNode vergleiche, bekomme ich auch das richtige Ergebnis.
Deshalb wundert es mich wirklich, dass das über die rekursive Methode oben nicht funktioniert.

Vorübergehend habe ich es so gelöst, dass ich das Ergebnis von MyTreeNode.CompareTo() einfach umkehre (-1 -> 1, 0 -> 0, 1 -> -1). Damit wird der Baum erstmal richtig dargestellt. Natürlich klappt das Vergleichen von zwei einzelnen MyTreeNode-Objekten nun nicht mehr richtig (umgekehrtes Ergebnis). Daher ist es für mich keine endgültige Lösung.

Weiß vielleicht jemand, warum die rekursive Methode Probleme macht?