La liaison de données pour SelectedItem dans un WPF Treeview

Cette propriété existe : TreeView.SelectedItem

Mais il est en lecture seule, donc vous ne pouvez pas affecter par une liaison, seulement récupérer

Réponse avec des propriétés attachées et sans dépendances externes, si besoin est!

Vous pouvez créer une propriété attachée qui est peut être liée et a un getter et setter:

public class TreeViewHelper
{
private static Dictionary<DependencyObject, TreeViewSelectedItemBehavior> behaviors = new Dictionary<DependencyObject, TreeViewSelectedItemBehavior>();
public static object GetSelectedItem(DependencyObject obj)
{
return (object)obj.GetValue(SelectedItemProperty);
}
public static void SetSelectedItem(DependencyObject obj, object value)
{
obj.SetValue(SelectedItemProperty, value);
}
//Using a DependencyProperty as the backing store for SelectedItem.  This enables animation, styling, binding, etc...
public static readonly DependencyProperty SelectedItemProperty =
DependencyProperty.RegisterAttached("SelectedItem", typeof(object), typeof(TreeViewHelper), new UIPropertyMetadata(null, SelectedItemChanged));
private static void SelectedItemChanged(DependencyObject obj, DependencyPropertyChangedEventArgs e)
{
if (!(obj is TreeView))
return;
if (!behaviors.ContainsKey(obj))
behaviors.Add(obj, new TreeViewSelectedItemBehavior(obj as TreeView));
TreeViewSelectedItemBehavior view = behaviors[obj];
view.ChangeSelectedItem(e.NewValue);
}
private class TreeViewSelectedItemBehavior
{
TreeView view;
public TreeViewSelectedItemBehavior(TreeView view)
{
this.view = view;
view.SelectedItemChanged += (sender, e) => SetSelectedItem(view, e.NewValue);
}
internal void ChangeSelectedItem(object p)
{
TreeViewItem item = (TreeViewItem)view.ItemContainerGenerator.ContainerFromItem(p);
item.IsSelected = true;
}
}
}

Ajouter la déclaration d'espace de noms contenant la classe de votre XAML et lier comme suit (local est ainsi que j'ai nommé la déclaration d'espace de noms):

        <TreeView ItemsSource="{Binding Path=Root.Children}" local:TreeViewHelper.SelectedItem="{Binding Path=SelectedItem, Mode=TwoWay}">
</TreeView>

Maintenant, vous pouvez lier l'élément sélectionné, et aussi le mettre dans votre modèle de vue de modifier par programmation, cette exigence devrait jamais survenir. C'est, bien sûr, en supposant que vous implémenter INotifyPropertyChanged sur ce bien particulier.

Ce qui peut être accompli dans un agréable chemin en utilisant uniquement la liaison et le GalaSoft MVVM Light bibliothèque EventToCommand. Dans votre VM ajouter une commande qui sera appelée lorsque l'élément sélectionné est modifié, et initialiser la commande à effectuer toutes les démarches nécessaires. Dans cet exemple j'ai utilisé un RelayCommand et il suffit de régler le SelectedCluster propriété.

public class ViewModel
{
public ViewModel()
{
SelectedClusterChanged = new RelayCommand<Cluster>( c => SelectedCluster = c );
}
public RelayCommand<Cluster> SelectedClusterChanged { get; private set; } 
public Cluster SelectedCluster { get; private set; }
}

Puis ajouter le EventToCommand comportement dans votre xaml. C'est vraiment facile à l'aide d'un mélange.

<TreeView
x:Name="lstClusters"
ItemsSource="{Binding Path=Model.Clusters}" 
ItemTemplate="{StaticResource HoofdCLusterTemplate}">
<i:Interaction.Triggers>
<i:EventTrigger EventName="SelectedItemChanged">
<GalaSoft_MvvmLight_Command:EventToCommand Command="{Binding SelectedClusterChanged}" CommandParameter="{Binding ElementName=lstClusters,Path=SelectedValue}"/>
</i:EventTrigger>
</i:Interaction.Triggers>
</TreeView>

Je suis tombé sur cette page à la recherche pour la même réponse que l'auteur original, et de prouver il y a toujours plus d'une façon de le faire, la solution pour moi a été de même plus facile que les réponses fournies jusqu'ici, j'ai donc pensé que je pourrais ajouter à la pile.

La motivation pour la liaison est de garder belle & MVVM. La probable utilisation du ViewModel est d'avoir une propriété w/un nom tel que "CurrentThingy", et d'autre part, le DataContext sur quelque chose d'autre est lié à "CurrentThingy".

Plutôt que de passer par des étapes supplémentaires requises (par exemple: comportement personnalisé, 3ème contrôle du parti) à l'appui d'une agréable reliure de l'Arborescence de mon Modèle, puis à partir de quelque chose d'autre à mon Modèle, ma solution a été d'utiliser simple Élément de liaison de l'autre chose à TreeView.SelectedItem, plutôt que de liaison de l'autre chose à mon ViewModel, en sautant ainsi le travail supplémentaire nécessaire.

XAML:

<TreeView x:Name="myTreeView" ItemsSource="{Binding MyThingyCollection}">
.... stuff
</TreeView>
<!-- then.. somewhere else where I want to see the currently selected TreeView item: -->
<local:MyThingyDetailsView 
DataContext="{Binding ElementName=myTreeView, Path=SelectedItem}" />

Bien sûr, ce qui est excellent pour la lecture de l'élément actuellement sélectionné, mais ne pas le mettre, ce qui est tout ce dont j'avais besoin.

Il est aussi un moyen de créer XAML peut être liée propriété SelectedItem sans l'aide de l'Interaction.Les comportements.

public static class BindableSelectedItemHelper
{
#region Properties
public static readonly DependencyProperty SelectedItemProperty = DependencyProperty.RegisterAttached("SelectedItem", typeof(object), typeof(BindableSelectedItemHelper),
new FrameworkPropertyMetadata(null, OnSelectedItemPropertyChanged));
public static readonly DependencyProperty AttachProperty = DependencyProperty.RegisterAttached("Attach", typeof(bool), typeof(BindableSelectedItemHelper), new PropertyMetadata(false, Attach));
private static readonly DependencyProperty IsUpdatingProperty = DependencyProperty.RegisterAttached("IsUpdating", typeof(bool), typeof(BindableSelectedItemHelper));
#endregion
#region Implementation
public static void SetAttach(DependencyObject dp, bool value)
{
dp.SetValue(AttachProperty, value);
}
public static bool GetAttach(DependencyObject dp)
{
return (bool)dp.GetValue(AttachProperty);
}
public static string GetSelectedItem(DependencyObject dp)
{
return (string)dp.GetValue(SelectedItemProperty);
}
public static void SetSelectedItem(DependencyObject dp, object value)
{
dp.SetValue(SelectedItemProperty, value);
}
private static bool GetIsUpdating(DependencyObject dp)
{
return (bool)dp.GetValue(IsUpdatingProperty);
}
private static void SetIsUpdating(DependencyObject dp, bool value)
{
dp.SetValue(IsUpdatingProperty, value);
}
private static void Attach(DependencyObject sender, DependencyPropertyChangedEventArgs e)
{
TreeListView treeListView = sender as TreeListView;
if (treeListView != null)
{
if ((bool)e.OldValue)
treeListView.SelectedItemChanged -= SelectedItemChanged;
if ((bool)e.NewValue)
treeListView.SelectedItemChanged += SelectedItemChanged;
}
}
private static void OnSelectedItemPropertyChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
{
TreeListView treeListView = sender as TreeListView;
if (treeListView != null)
{
treeListView.SelectedItemChanged -= SelectedItemChanged;
if (!(bool)GetIsUpdating(treeListView))
{
foreach (TreeViewItem item in treeListView.Items)
{
if (item == e.NewValue)
{
item.IsSelected = true;
break;
}
else
item.IsSelected = false;                        
}
}
treeListView.SelectedItemChanged += SelectedItemChanged;
}
}
private static void SelectedItemChanged(object sender, RoutedEventArgs e)
{
TreeListView treeListView = sender as TreeListView;
if (treeListView != null)
{
SetIsUpdating(treeListView, true);
SetSelectedItem(treeListView, treeListView.SelectedItem);
SetIsUpdating(treeListView, false);
}
}
#endregion
}

Vous pouvez ensuite l'utiliser dans votre XAML comme:

<TreeView  helper:BindableSelectedItemHelper.Attach="True" 
helper:BindableSelectedItemHelper.SelectedItem="{Binding SelectedItem, Mode=TwoWay}">

Mon exigence était pour PRISM-MVVM solution à base d'où un TreeView était nécessaire et l'objet lié est de type Collection<>, et par conséquent, les besoins HierarchicalDataTemplate. La valeur par défaut BindableSelectedItemBehavior ne sera pas en mesure d'identifier l'enfant TreeViewItem. Pour se rendre à travailler dans ce scénario.

public class BindableSelectedItemBehavior : Behavior<TreeView>
{
#region SelectedItem Property
public object SelectedItem
{
get { return (object)GetValue(SelectedItemProperty); }
set { SetValue(SelectedItemProperty, value); }
}
public static readonly DependencyProperty SelectedItemProperty =
DependencyProperty.Register("SelectedItem", typeof(object), typeof(BindableSelectedItemBehavior), new UIPropertyMetadata(null, OnSelectedItemChanged));
private static void OnSelectedItemChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
{
var behavior = sender as BindableSelectedItemBehavior;
if (behavior == null) return;
var tree = behavior.AssociatedObject;
if (tree == null) return;
if (e.NewValue == null)
foreach (var item in tree.Items.OfType<TreeViewItem>())
item.SetValue(TreeViewItem.IsSelectedProperty, false);
var treeViewItem = e.NewValue as TreeViewItem;
if (treeViewItem != null)
treeViewItem.SetValue(TreeViewItem.IsSelectedProperty, true);
else
{
var itemsHostProperty = tree.GetType().GetProperty("ItemsHost", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance);
if (itemsHostProperty == null) return;
var itemsHost = itemsHostProperty.GetValue(tree, null) as Panel;
if (itemsHost == null) return;
foreach (var item in itemsHost.Children.OfType<TreeViewItem>())
{
if (WalkTreeViewItem(item, e.NewValue)) 
break;
}
}
}
public static bool WalkTreeViewItem(TreeViewItem treeViewItem, object selectedValue)
{
if (treeViewItem.DataContext == selectedValue)
{
treeViewItem.SetValue(TreeViewItem.IsSelectedProperty, true);
treeViewItem.Focus();
return true;
}
var itemsHostProperty = treeViewItem.GetType().GetProperty("ItemsHost", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance);
if (itemsHostProperty == null) return false;
var itemsHost = itemsHostProperty.GetValue(treeViewItem, null) as Panel;
if (itemsHost == null) return false;
foreach (var item in itemsHost.Children.OfType<TreeViewItem>())
{
if (WalkTreeViewItem(item, selectedValue))
break;
}
return false;
}
#endregion
protected override void OnAttached()
{
base.OnAttached();
this.AssociatedObject.SelectedItemChanged += OnTreeViewSelectedItemChanged;
}
protected override void OnDetaching()
{
base.OnDetaching();
if (this.AssociatedObject != null)
{
this.AssociatedObject.SelectedItemChanged -= OnTreeViewSelectedItemChanged;
}
}
private void OnTreeViewSelectedItemChanged(object sender, RoutedPropertyChangedEventArgs<object> e)
{
this.SelectedItem = e.NewValue;
}
}

Ceci permet de parcourir tous les éléments quel que soit le niveau.

WPF MVVM TreeView SelectedItem

... est une meilleure réponse, mais il ne mentionne pas un moyen d'obtenir/définir le SelectedItem dans le ViewModel.

1. Ajouter une propriété boolean IsSelected à votre ItemViewModel, et se lier à elle dans un Style Setter pour la TreeViewItem.
2. Ajouter une propriété SelectedItem à votre ViewModel utilisé comme le DataContext de la vue arborescente. C'est la pièce manquante dans la solution ci-dessus.

 ' ItemVM... 
Bien Public Boolean IsSelected 
Obtenez de l' 
Retour _func.SelectedNode Est Moi 
Fin Obtenir 
Set(valeur Booléenne) 
Si IsSelected valeur 
_func.SelectedNode = Si(valeur, Moi, Rien) 
Fin De Si 
RaisePropertyChange() 
La Fin De Set 
Fin De La Propriété 
'TreeVM... 
Public De La Propriété SelectedItem Comme ItemVM 
Obtenez de l' 
Retour _selectedItem 
Fin Obtenir 
Set(valeur ItemVM) 
Si _selectedItem Est la valeur Alors 
De retour 
Fin De Si 
Dim prev = _selectedItem 
_selectedItem = valeur 
Si prev IsNot Nothing then 
prev.IsSelected = False 
Fin De Si 
Si _selectedItem IsNot Nothing then 
_selectedItem.IsSelected = True 
Fin De Si 
La Fin De Set 
Fin De La Propriété 

<TreeView ItemsSource="{Binding Path=TreeVM}" 
BorderBrush="Transparent">
<TreeView.ItemContainerStyle>
<Style TargetType="TreeViewItem">
<Setter Property="IsExpanded" Value="{Binding IsExpanded}"/>
<Setter Property="IsSelected" Value="{Binding IsSelected, Mode=TwoWay}"/>
</Style>
</TreeView.ItemContainerStyle>
<TreeView.ItemTemplate>
<HierarchicalDataTemplate ItemsSource="{Binding Children}">
<TextBlock Text="{Binding Name}"/>
</HierarchicalDataTemplate>
</TreeView.ItemTemplate>
</TreeView>

Il peut aussi être fait en utilisant la propriété IsSelected de l'Arborescence de l'élément. Voici comment je l'ai réussi,

public delegate void TreeviewItemSelectedHandler(TreeViewItem item);
public class TreeViewItem
{      
public static event TreeviewItemSelectedHandler OnItemSelected = delegate { };
public bool IsSelected 
{
get { return isSelected; }
set 
{ 
isSelected = value;
if (value)
OnItemSelected(this);
}
}
}

Puis dans le ViewModel qui contient les données de votre TreeView est lié à, il suffit de s'abonner à l'événement dans la TreeViewItem classe.

TreeViewItem.OnItemSelected += TreeViewItemSelected;

Et enfin, de mettre en œuvre ce gestionnaire dans le même ViewModel,

private void TreeViewItemSelected(TreeViewItem item)
{
//Do something
}

Et la liaison de cours,

<Setter Property="IsSelected" Value="{Binding IsSelected}" />    

Je sais que ce fil est de 10 ans, mais le problème persiste....

La question d'origine était de "récupérer" l'élément sélectionné. J'ai aussi besoin de "récupérer" l'élément sélectionné dans mon viewmodel (pas). De toutes les réponses dans ce fil de discussion, l'un par 'Wes' est le seul qui aborde le problème différemment: Si vous pouvez utiliser l'Élément Sélectionné comme cible pour la liaison de données de l'utiliser comme source pour la liaison de données. Wes fait un autre point de vue de la propriété, je vais le faire à un viewmodel de la propriété:

Nous avons besoin de deux choses:

• De créer une dépendance de la propriété du viewmodel (dans mon cas du type "Monobjet" comme mon treeview est lié à un objet de la "Monobjet " type")
• Liaison à partir de l'Arborescence.SelectedItem de cette propriété dans le point de Vue du constructeur (oui, c'est le code derrière mais, il est probable que vous aurez init datacontext, il y a l')

Viewmodel:

public static readonly DependencyProperty SelectedTreeViewItemProperty = DependencyProperty.Register("SelectedTreeViewItem", typeof(MyObject), typeof(MyViewModel), new PropertyMetadata(OnSelectedTreeViewItemChanged));
private static void OnSelectedTreeViewItemChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
(d as MyViewModel).OnSelectedTreeViewItemChanged(e);
}
private void OnSelectedTreeViewItemChanged(DependencyPropertyChangedEventArgs e)
{
//do your stuff here
}
public MyObject SelectedWorkOrderTreeViewItem
{
get { return (MyObject)GetValue(SelectedTreeViewItemProperty); }
set { SetValue(SelectedTreeViewItemProperty, value); }
}

Vue constructeur:

Binding binding = new Binding("SelectedItem")
{
Source = treeView, //name of tree view in xaml
Mode = BindingMode.OneWay
};
BindingOperations.SetBinding(DataContext, MyViewModel.SelectedTreeViewItemProperty, binding);