我会尽力解释这一点。我很难弄清楚这个逻辑。
基本上，我有一个包含数千个对象的集合，每个对象由一个 Parent 和一个 Child 属性组成。
所以，大致是这样的：
public class MyObject{
public string Parent { get; set; }
public string Child { get; set; }
}
我想弄清楚的是如何将它构建到一个普通的 TreeView 控件中。我需要建立关系，但我不知道怎么做，因为它们可以混合。我可能可以用树的样子更好地解释这一点：
因此，如果我的收藏中有以下物品：
0. Parent: "A", Child: "B"
1. Parent: "B", Child: "C"
2. Parent: "B", Child: "D"
我希望我的树看起来像这样：
-A
--B
---C
-A
--B
---D
-B
--C
-B
--D
我怎样才能在 C# 中做到这一点？我需要它来支持多达 N 个关系，因为我们有一些分支，我希望能够达到大约 50 个节点的深度。
更新
这个问题实际上比我最初意识到的要复杂得多，因为需要为每条路径重复整个树。我只是删除了旧代码，因为我不想增加任何进一步的混淆。
我确实想记录下来，使用递归数据结构使这更容易：
public class MyRecursiveObject
{
public MyRecursiveObject Parent { get; set; }
public string Name { get; set; }
public List<MyRecursiveObject> Children { get; set; }
}
阅读下面的实现代码后，您会非常清楚地看到为什么这更容易：
private void PopulateTree(IEnumerable<MyObject> items)
{
var groupedItems =
from i in items
group i by i.Parent into g
select new { Name = g.Key, Children = g.Select(c => c.Child) };
var lookup = groupedItems.ToDictionary(i => i.Name, i => i.Children);
foreach (string parent in lookup.Keys)
{
if (lookup.ContainsKey(parent))
AddToTree(lookup, Enumerable.Empty<string>(), parent);
}
}
private void AddToTree(Dictionary<string, IEnumerable<string>> lookup,
IEnumerable<string> path, string name)
{
IEnumerable<string> children;
if (lookup.TryGetValue(name, out children))
{
IEnumerable<string> newPath = path.Concat(new string[] { name });
foreach (string child in children)
AddToTree(lookup, newPath, child);
}
else
{
TreeNode parentNode = null;
foreach (string item in path)
parentNode = AddTreeNode(parentNode, item);
AddTreeNode(parentNode, name);
}
}
private TreeNode AddTreeNode(TreeNode parent, string name)
{
TreeNode node = new TreeNode(name);
if (parent != null)
parent.Nodes.Add(node);
else
treeView1.Nodes.Add(node);
return node;
}
首先，我意识到字典将包含中间节点以及根节点的键，因此我们不需要在递归AddToTree方法中进行两次递归调用来获取“B”节点作为根；方法中的初始步PopulateTree已经做到了。
我们需要注意的是在初始遍历中添加叶节点；使用有问题的数据结构，这些可以通过检查父字典中是否有键来检测。使用递归数据结构，这会更容易：只需检查Parent == null. 但是，递归结构不是我们所拥有的，所以上面的代码是我们必须使用的。
这AddTreeNode主要是一种实用方法，因此我们以后不必重复这种空检查逻辑。
真正的丑陋在于第二种递归AddToTree方法。因为我们试图创建每个子树的唯一副本，所以我们不能简单地添加一个树节点，然后将该节点作为父节点进行递归。“A”在这里只有一个孩子，“B”，但“B”有两个孩子，“C”和“D”。需要有两个“A”副本，但是当“A”最初传递给方法时，无法知道这一点AddToTree。
所以我们实际上要做的就是在最后阶段之前不要创建任何节点，并存储一个临时路径，我选择IEnumerable<string>它是因为它是不可变的，因此不可能搞砸。当有更多的孩子要添加时，这个方法只是简单地添加到路径中并递归；当没有更多子节点时，它会遍历整个保存的路径并为每个子节点添加一个节点。
这是非常低效的，因为我们现在在每次调用AddToTree. 对于大量节点，它可能会占用大量内存。这可行，但使用递归数据结构会更有效。使用顶部的示例结构，您根本不必保存路径或创建字典；当没有孩子离开时，只需使用参考在while循环中走上路径。Parent
无论如何，我想这是学术性的，因为这不是一个递归对象，但我认为无论如何都值得指出，作为未来设计要牢记的东西。上面的代码将产生您想要的结果，我已经在真实的 TreeView 上进行了测试。
更新 2 - 所以上面的版本在内存/堆栈方面非常残酷，很可能是创建所有这些IEnumerable<string>实例的结果。虽然这不是很好的设计，但我们可以通过更改为 mutable 来消除该特定问题List<string>。以下代码段显示了差异：
private void PopulateTree(IEnumerable<MyObject> items)
{
// Snip lookup-generation code - same as before ...
List<string> path = new List<string>();
foreach (string parent in lookup.Keys)
{
if (lookup.ContainsKey(parent))
AddToTree(lookup, path, parent);
}
}
private void AddToTree(Dictionary<string, IEnumerable<string>> lookup,
IEnumerable<string> path, string name)
{
IEnumerable<string> children;
if (lookup.TryGetValue(name, out children))
{
path.Add(name);
foreach (string child in children)
AddToTree(lookup, newPath, child);
path.Remove(name);
}
// Snip "else" block - again, this part is the same as before ...
}
像鲁本斯一样，我都试过了，但我认为更好一点我认为通用树集合
这个树集合有一些很好的内置功能可以在树周围移动，去阅读整篇文章
上面链接的示例
Static Class Module1
{
public static void Main()
{
Common.ITree<myObj> myTree = default(Common.ITree<myObj>);
myObj a = new myObj("a");
myObj b = new myObj("b");
myObj c = new myObj("c");
myObj d = new myObj("d");
myTree = Common.NodeTree<myObj>.NewTree;
myTree.InsertChild(a).InsertChild(b).InsertChild(c).Parent.Parent.InsertNext(a).InsertChild(b).InsertChild(d).Parent.Parent.InsertNext(b).InsertChild(c).Parent.InsertNext(b).InsertChild(d);
Console.WriteLine(myTree.ToStringRecursive);
Console.ReadKey();
}
}
Class myObj
{
public string text;
public myObj(string value)
{
text = value;
}
public override string ToString()
{
return text;
}
}
正是你刚刚展示的
-A
--B
---C
-A
--B
---D
-B
--C
-B
--D
如果我理解正确，那么您要做的就是取一棵树并将其转换为另一棵树。转换本质上获取输入树中的每个非叶节点，并在输出树中为它（及其后代）创建一个节点。
首先，如果你为你的节点设计一个真正递归的数据结构，你会更开心：
public class Node
{
public Node Parent { get; private set; }
public IEnumerable<Node> Children { get; private set; }
public bool HasChildren { get { return Children.Count() > 0; } }
public Node()
{
Children = new List<Node>();
}
}
您的MyObject类表示字符串值之间的父/子关系。只要您能够实现FindChildren()为给定父值返回子值的方法，使用此类来合理化父/子关系就很简单：
public string Value { get; set; }
public static Node Create(string parentKey)
{
Node n = new Node();
n.Value = parentKey;
foreach (string childKey in FindChildren(parentKey))
{
Node child = n.Children.Add(Node.Create(childKey));
child.Parent = n;
}
return n;
}
实现一个返回节点后代的属性很简单：
public IEnumerable<Node> Descendants
{
get
{
foreach (Node child in Children)
{
yield return child;
foreach (Node descendant in child.Descendants)
{
yield return descendant;
}
}
}
}
要将 a 添加Node到 TreeView，您需要两种方法。（请注意，这些不是Node类的方法！）我已经让它们重载，但是可以为它们提供不同的名称：
public void AddNode(Node n, TreeView tv)
{
TreeNode tn = tv.Nodes.Add(n.Value);
tn.Tag = n;
foreach (Node child in n.Children)
{
AddNode(child, tn);
}
}
public void AddNode(Node n, TreeNode parent)
{
TreeNode tn = parent.Nodes.Add(n.Value);
parent.Tag = n;
foreach (Node child in n.Children)
{
AddNode(child, tn);
}
}
我设置了Tag每个TreeNode，这样你就可以找到回到原来的方式Node。
TreeView因此，要从顶级父键列表中初始化您，您需要这样的方法：
public void PopulateTreeView(IEnumerable<string> parents, TreeView t)
{
foreach (string parentKey in parents)
{
Node n = Node.Create(parentKey);
AddNode(n, t);
foreach (Node descendant in n.Descendants)
{
if (n.HasChildren)
{
AddNode(descendant, t);
}
}
}
}
编辑：
我不太明白你的MyObject课是如何工作的。我想我现在这样做了，我已经相应地编辑了这个。