So wählen Sie bestimmte untergeordnete Knoten in TreeView, C#

Question

Ich habe ein Problem mit der Auswahl eines bestimmten Kind-Knoten.

Was ich erreichen möchte: Ich Sie haben diese treeview zum Beispiel (ein Elternteil mit zwei untergeordneten Knoten):

Eltern -Kind mit einem Wert 5
-Kind mit einem Wert 2.

Ich möchte fügen sie diese beiden Werte und ordnen sie übergeordneten Knoten:

Geordnetes Ergebnis 7
-Kind 5
-Kind 2.

natürlich ein größeres treeview mehrere Eltern und viele Kinder haben würden und sie werden alle summieren sich zu ein Wurzelknoten.

Wie kann ich das tun ?? Bitte helfen.

thx,
Caslav

Answer 1

weiß nicht, ob diese Ihrer Anfrage entspricht, aber das wird alle Childs> Elternknoten

private void button2_Click(object sender, EventArgs e) 
    { 
     int grandTotal = CalculateNodes(this.treeView1.Nodes); 
    } 
    private int CalculateNodes(TreeNodeCollection nodes) 
    { 
     int grandTotal = 0; 
     foreach (TreeNode node in nodes) 
     { 
      if (node.Nodes.Count > 0) 
      { 
       int childTotal = CalculateNodes(node.Nodes); 
       node.Text = childTotal.ToString(); 
       grandTotal += childTotal; 
      } 
      else 
      { 
       grandTotal += Convert.ToInt32(node.Text); 
      } 
     } 
     return grandTotal; 
    } 

Sie sollten einige Fehler tun Überprüfung etc etc hinzufügen, um es

Answer 2

So:

public class TotalingTreeNode : TreeNode 
{ 
    private int _value = 0; 

    public int Value 
    { 
     get 
     { 
      if (this.Nodes.Count > 1) 
       return GetTotaledValue(); 
      else 
       return _value; 
     } 
     set 
     { 
      if (this.Nodes.Count < 1) 
       _value = value; 
     } 
    } 

    private int GetTotaledValue() 
    { 
     foreach (TotalingTreeNode t in this.Nodes.Cast<TotalingTreeNode>()) 
     { 
      _value += t.Value; 
     } 
     return _value; 
    } 
} 

Answer 3

private TreeNode SearchTree(TreeNodeCollection nodes, string searchtext) 
     { 
      TreeNode n_found_node = null; 
      bool b_node_found = false; 
      foreach (TreeNode node in nodes) 
      { 
       if (node.Tag.ToString() as string == searchtext) 
       { 
        b_node_found = true; 
        n_found_node = node; 
       } 
       if (!b_node_found) 
       { 
        n_found_node = SearchTree(node.Nodes, searchtext); 
       } 
      } 
      return n_found_node; 
     } 

Quelle: http://www.experts-exchange.com/Programming/Languages/C_Sharp/Q_21895513.html

Answer 4

In WinForms ein childNode eines Baumes seine Eltern kennt. Auf diese Weise können Sie jederzeit mithilfe der TreeNode.Parent-Eigenschaft das Parent erreichen. Umgekehrt weiß jeder Knoten, dass er untergeordnete Knoten ist. Sie können sie mit Node.Nodes erreichen. Diese Auflistung verfügt über einen Indexer, mit dem Sie mit einem int oder einer Zeichenfolge auf die untergeordneten Knoten zugreifen können.

treeView.Nodes.Find("nodeKey", true); 

Sie finde Eine Beschreibung dieses Verfahrens bei MSDN

Answer 5

Sie erben könnte von TreeNode mit etwas wie folgt aus::

Um einen TreeNode mit einem speziellen Schlüssel verwenden, den folgenden Code zu finden

public class TreeNodeEx : TreeNode { 
    // only displayed when having no children 
    public int Value { get; set; } 

    public bool HasChildren { 
     get { return Nodes.Count > 0; } 
    } 

    public int GetSumOfChildren() { 
     if (!HasChildren) 
      return Value; 

     var children = Nodes.Cast<TreeNode>().OfType<TreeNodeEx>(); 

     int sum = 0; 
     foreach (var child in children) 
      sum += child.GetSumOfChildren(); 

     return sum; 
    } 
} 

Answer 6

Sie könnten etwas wie das Folgende tun. Es nimmt an, dass der gewünschte Wert Teil des Textes ist (der letzte Wert nach dem letzten Leerzeichen).

using System; 
using System.Collections.Generic; 
using System.ComponentModel; 
using System.Data; 
using System.Drawing; 
using System.Text; 
using System.Windows.Forms; 

namespace TreeViewRecurse 
{ 
    public partial class Form1 : Form 
    { 
     public Form1() 
     { 
     InitializeComponent(); 
     RecurseTreeViewAndSumValues(treeView1.Nodes); 
     } 

     public void RecurseTreeViewAndSumValues(TreeNodeCollection treeNodeCol) 
     { 
     int tree_node_sum = 0; 
     foreach (TreeNode tree_node in treeNodeCol) 
     { 
      if (tree_node.Nodes.Count > 0) 
      { 
       RecurseTreeViewAndSumValues(tree_node.Nodes); 
      } 
      string[] node_split = tree_node.Text.Split(' '); 
      string num = node_split[node_split.Length - 1]; 
      int parse_res = 0; 
      bool able_to_parse = int.TryParse(num, out parse_res); 
      if (able_to_parse) 
      { 
       tree_node_sum += parse_res; 
      } 
     } 
     if (treeNodeCol[0].Parent != null) 
     { 
      string[] node_split_parent = treeNodeCol[0].Parent.Text.Split(' '); 
      node_split_parent[node_split_parent.Length - 1] = tree_node_sum.ToString(); 
      treeNodeCol[0].Parent.Text = string.Join(" ", node_split_parent); 
     } 
     } 
    } 
} 

Answer 7

ich solide zu machen verwendet eine modifizierte Version von Redburn's Antwort, um einen Treenode nach Name zu finden:

private TreeNode GetNodeByName(TreeNodeCollection nodes, string searchtext) 
    { 
     TreeNode n_found_node = null; 
     bool b_node_found = false; 
     foreach (TreeNode node in nodes) 
     { 
      //show(node.Name + ":" +searchtext); 
      if (node.Name == searchtext) 
      { 
       //show("score!"); 
       b_node_found = true; 
       n_found_node = node; 
       return n_found_node; 
      } 
      if (!b_node_found) 
      { 
       //show("here"); 
       n_found_node = f_get_node_by_name(node.Nodes, searchtext); 
       if (n_found_node!=null) 
       { 
        return n_found_node; 
       } 
      } 
     } 
     return null; 
    }