Lent treeview en C#

J'ai un héritage de l'application est écrite en C# et il affiche une très complexes treeview avec 10 à 20 mille éléments.

Dans le passé, j'ai rencontré un problème similaire (mais en C++) que j'ai résolu avec la OWNERDATA la capacité offerte par l'API Win32.

Est-il un mécanisme similaire en C#?

EDIT: Le plan est d'optimiser le temps de création ainsi que les temps de navigation. La méthode disponible par le biais de l'API Win32 est excellent dans ces deux cas, comme il réduire le temps d'initialisation à rien, et le nombre de demandes pour les éléments sont limités à seulement celles qui sont visibles à tout moment.
Joshl: Nous sommes en train de faire exactement ce que vous suggérez déjà, mais nous avons encore besoin de plus d'efficacité.

OriginalL'auteur Fabien Hure | 2008-09-23

  1. 7

    Je ne crois pas que l' .NET Arborescence prend en charge ce que vous voulez, bien que ce type de modèle est pris en charge par .NET DataGridView (voir DataGridView est VirtualMode de la propriété). Dans l'Arborescence, vous permettra de tirer vos propres noeuds, mais il ne vous laisseront pas de les remplir de certains magasin virtuel.

    Si possible, vous pouvez envisager l'utilisation d'un DataGridView pour votre application. En effet, la gestion des nœuds manuellement (comme joshl mentionne ci-dessus) pourrait fonctionner si vous pouvez obtenir autour de certaines questions relatives à l'actualisation de l'écran lorsque les nœuds sont développés. En dehors de cela, vous pourriez vouloir vérifier certains des fournisseurs tiers, comme celui-ci (Divelements SandGrid), qui pourrait (accent sur la puissance) support de votre choix de mode de fonctionnement.

    REMARQUE: Le SandGrid n'est pas pris en charge par Divelements à la fin du mois de juillet 2013.

    Le VirtualMode de la DataGridView semble correspondre parfaitement au projet de loi. Merci beaucoup pour la réponse rapide.

    OriginalL'auteur Ken Wootton

  2. 20

    Une technique pour l'amélioration de la performance est à la charge TreeNodes que l'utilisateur développe l'arborescence. Normalement, l'utilisateur n'aura pas besoin de 20 000 nœuds à ouvrir sur leur écran à la fois. Charger uniquement le niveau que l'utilisateur a besoin de voir, ainsi que tout ce que l'enfant informations dont vous avez besoin pour afficher correctement les affordances de l'utilisateur (icône si les enfants existent, les chiffres, les icônes, etc). En tant que l'utilisateur développe des nœuds, la charge les enfants juste à temps.

    Conseil de Keith: Avec les winforms TreeView, vous devez avoir au moins un enfant de moins de nœud ou de ne pas montrer la développer [+], mais ensuite vous manipulez le TreeNodeExpanded événement pour supprimer le mannequin nœud et remplissez les enfants.

    Délai de chargement... je crois que cela s'appelle. Belle réponse.
    Cette réponse est évidemment bien comme c'était déjà quelque chose qui a été mis en place sur mon côté.
    Avec les winforms TreeView, vous devez avoir au moins un enfant de moins de nœud ou de ne pas montrer la développer [+], mais ensuite vous manipulez le TreeNodeExpanded événement pour supprimer le mannequin nœud et remplissez les enfants.
    Aussi appelé "lazy loading"

    OriginalL'auteur JoshL

  3. 11

    Dans notre principale application WinForm, nous avons un treeview chargé tout d'un coup:

    • BeginUpdate()
    • Charge de 20.000 nœuds
    • EndUpdate()

    et la mesure de la performance est toujours agréable. C'est en fait l'un des quelques éléments, nous ne sommes pas en la remplaçant par des tiers.

    L'Arborescence de la performance, dans mon expérience, est au ralenti lorsque vous chargez des nœuds (d'un seul coup, ou sur demande) sans appeler Commencer/EndUpdate(), surtout si votre nœuds sont triés, mais si vous appelez de Commencer/EndUpdate() correctement, vous ne devriez pas vraiment les problèmes de performance liés au composant lui-même.

    OriginalL'auteur Filini

  4. 7

    NOTE: Cette réponse est invalidée par une modification par l'interlocuteur en disant qu'il a déjà fait ce genre de chose, mais j'ai décidé de tout de même poster pour référence future par d'autres, la recherche sur ce sujet

    Quand j'ai fait des choses semblables dans le passé, j'ai eu tendance à opter pour de la naïveté de lazy-loading style.

    • Utiliser le TreeNode.Tag propriété de tenir une de référence que vous pouvez utiliser pour rechercher les enfants
    • Utiliser le TreeView.BeforeExpand événement pour remplir les nœuds enfants
    • Éventuellement utiliser la TreeView.AfterCollapse événement à supprimer.
    • Pour obtenir le [+]/[-] boîtes à apparaître, le meilleur moyen que j'ai trouvé est de créer un singleton mannequin TreeNode qui est ajouté comme un enfant à tous inhabitée Nœuds, et de vérifier son existence avant le remplissage avec BeforeExpand.

    OriginalL'auteur Alex Lyman

  5. 5

    Il y a une manière de rendre le TreeView effectuer beaucoup mieux et c'est de créer tous les sous-nœuds et les connecter ensemble et puis ajouter les nœuds de l'Arborescence. Si c'est le graphique de performance dont nous parlons.

    TreeView tree = new TreeView();
TreeNode root = new TreeNode("Root");
PopulateRootNode(root); //Get all your data
tree.Nodes.Add(root);

    Autrement, de les charger de nœud en nœud à l'aide de OnTreeNodeExpanded.

    OriginalL'auteur Seb Nilsson

  6. 1

    Pour les données de grande taille dans les Fenêtres de programmation C#, que ce soit en WPF ou WinForms, j'ai toujours ajouté des nœuds de façon dynamique. Je charge initiale de la racine de l'arbre + enfants + petits-enfants de profondeur. Quand un nœud est élargi, je charge l'arborescence de nœuds qui représentent les petits-enfants de l'expansion de nœud, le cas échéant.

    Ce modèle fonctionne aussi bien avec la récupération de données. Si vous êtes vraiment le chargement de données à partir d'une source de milliers ou des millions d'enregistrements, vous ne voulez probablement pas à la charge de tous ceux à l'avant. Aucun utilisateur ne veut attendre que d'être chargé, et il n'y a pas de raison de charger des données qui peuvent ne jamais être vu.

    J'ai généralement chargé les petits-enfants ou arrière-petits-enfants les nœuds de données nécessaires sur un thread d'arrière-plan, puis maréchal de ces données vers le thread d'INTERFACE utilisateur et de créer et d'ajouter des nœuds. Cela laisse de l'INTERFACE utilisateur réactive. Vous pouvez visuellement décorer les nœuds de l'arborescence pour indiquer qu'ils sont toujours en cours de chargement pour le cas où l'utilisateur prend de l'avance de votre IO à la banque de données.

    OriginalL'auteur Jason Jackson