Cóż, to chyba trochę bardziej naiwny niż ty gdzie nadzieję, ale mogłaby dać punkt wyjścia. To może zrobić z pewnym refaktoryzacji, ale zostało to zrobione dosłownie w ciągu 15 minut, więc weź to za to, co jest, co nie jest dobrze przetestowane ani nie używa żadnych wyobrażeń o WPF.
pierwsze proste UserControl, który właśnie odbywa TreeView
<UserControl x:Class="ObjectBrowser.PropertyTree"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
mc:Ignorable="d"
d:DesignHeight="300" d:DesignWidth="300">
<Grid>
<TreeView Name="treeView1" TreeViewItem.Expanded="treeView1_Expanded" />
</Grid>
</UserControl>
związany kod za to będzie miał tylko jedną właściwość o nazwie ObjectGraph
, to jest ustawione na wystąpienie obiektu, który chcesz przeglądać.
Drzewo zostaje załadowane tylko z pierwszym poziomem właściwości dla każdego węzła ma format Nazwa właściwości: Wartość lub Nazwa właściwości: Typ, jeśli właściwość jest typem pierwotnym (patrz funkcja IsPrimitive), wówczas wyświetlana jest wartość, w przeciwnym razie pusty łańcuch jest dodawany jako węzeł potomny. Dodanie pustego łańcucha wskazuje użytkownikowi, że węzeł może się rozwinąć.
Po wypuszczeniu węzła następuje szybkie sprawdzenie, czy pierwsze dziecko jest pustym łańcuchem, czy jest to węzeł jest wyczyszczony, a właściwości dla tego węzła są załadowane do drzewa.
To zasadniczo buduje drzewo w miarę powiększania się węzła. To sprawia, że łatwiej jakby z dwóch powodów
1- Nie trzeba wykonywać rekursji
2- Nie ma potrzeby, aby wykryć cykliczne odniesienia, które rozwinie się wiecznością lub jakiegoś zasobu jest wyczerpany, co nastąpi pierwsze.
using System;
using System.Windows;
using System.Windows.Controls;
using System.Reflection;
namespace ObjectBrowser
{
public partial class PropertyTree : UserControl
{
public PropertyTree()
{
InitializeComponent();
}
private void treeView1_Expanded(object sender, RoutedEventArgs e)
{
TreeViewItem item = e.OriginalSource as TreeViewItem;
if (item.Items.Count == 1 && item.Items[0].ToString() == string.Empty)
{
LoadGraph(item.Items, item.Tag);
}
}
public object ObjectGraph
{
get { return (object)GetValue(ObjectGraphProperty); }
set { SetValue(ObjectGraphProperty, value); }
}
public static readonly DependencyProperty ObjectGraphProperty =
DependencyProperty.Register("ObjectGraph", typeof(object), typeof(PropertyTree),
new UIPropertyMetadata(0, OnObjectGraphPropertyChanged));
private static void OnObjectGraphPropertyChanged(DependencyObject source, DependencyPropertyChangedEventArgs e)
{
PropertyTree control = source as PropertyTree;
if (control != null)
{
control.OnObjectGraphChanged(source, EventArgs.Empty);
}
}
protected virtual void OnObjectGraphChanged(object sender, EventArgs e)
{
LoadGraph(treeView1.Items, ObjectGraph);
}
private void LoadGraph(ItemCollection nodeItems, object instance)
{
nodeItems.Clear();
if (instance == null) return;
Type instanceType = instance.GetType();
foreach (PropertyInfo pi in instanceType.GetProperties(BindingFlags.Instance | BindingFlags.Public))
{
object propertyValue =pi.GetValue(instance, null);
TreeViewItem item = new TreeViewItem();
item.Header = BuildItemText(instance, pi, propertyValue);
if (!IsPrimitive(pi) && propertyValue != null)
{
item.Items.Add(string.Empty);
item.Tag = propertyValue;
}
nodeItems.Add(item);
}
}
private string BuildItemText(object instance, PropertyInfo pi, object value)
{
string s = string.Empty;
if (value == null)
{
s = "<null>";
}
else if (IsPrimitive(pi))
{
s = value.ToString();
}
else
{
s = pi.PropertyType.Name;
}
return pi.Name + " : " + s;
}
private bool IsPrimitive(PropertyInfo pi)
{
return pi.PropertyType.IsPrimitive || typeof(string) == pi.PropertyType;
}
}
}
Korzystanie z kontroli jest dość proste. Tutaj po prostu ustawię formant, a następnie ustawię ObjectGraph na instancję obiektu, arbitralnie wybrałem XmlDataProvider
.
XAML
<Window x:Class="ObjectBrowser.MainWindow"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
Title="MainWindow" Height="350" Width="525" xmlns:my="clr-namespace:ObjectBrowser" Loaded="Window_Loaded">
<Grid>
<my:PropertyTree x:Name="propertyTree1" />
</Grid>
</Window>
Kod za
using System;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
namespace ObjectBrowser
{
/// <summary>
/// Interaction logic for MainWindow.xaml
/// </summary>
public partial class MainWindow : Window
{
public MainWindow()
{
InitializeComponent();
}
private void Window_Loaded(object sender, RoutedEventArgs e)
{
var o = new XmlDataProvider();
o.Source = new Uri("http://www.stackoverflow.com");
propertyTree1.ObjectGraph = o;
}
}
}
Oczywiście byłoby to jeszcze trzeba wiele pracy, specjalnej obsługi dla typów, takich jak macierze ewentualnie mechanizm obsługiwać niestandardowe widoki do specjalnych typów itp.
Nie masz pojęcia, ile mnie uratowałeś! Wiem, że komentarze nie są dla "Dziękuję" - ale spędzają 8 minut na kopiowaniu i dostosowywaniu zamiast rozwijaniu przez 80 minut ... Ty i Chris zasługują na wielkie podziękowania! –
@ G.Y Takie komentarze powodują, że staram się odpowiadać na pytania dotyczące SO. Dziękuję ** Ty ** –
Zachary - Świetna robota. Naprawdę zaoszczędził mi czasu. Z myślą o wszystkich przesłałem działający projekt do codeplexu, który można znaleźć tutaj: https://wpfobjecttreeview.codeplex.com/ –