217

Вопрос по selecteditem, treeview, mvvm, wpf, c# – undefined

Как я могу получить элемент, выбранный в WPF-дереве? Я хочу сделать это в XAML, потому что я хочу связать это.

Вы можете подумать, что этоSelectedItem но очевидно чтоdoes not exist только для чтения и, следовательно, непригодный для использования.

Вот что я хочу сделать:

<TreeView ItemsSource="{Binding Path=Model.Clusters}" 
            ItemTemplate="{StaticResource ClusterTemplate}"
            SelectedItem="{Binding Path=Model.SelectedCluster}" />

Я хочу связатьSelectedItem в собственность на моей модели.

Но это дает мне ошибку:

'SelectedItem' property is read-only and cannot be set from markup.

Edit: Хорошо, это способ, которым я решил это:

<TreeView
          ItemsSource="{Binding Path=Model.Clusters}" 
          ItemTemplate="{StaticResource HoofdCLusterTemplate}"
          SelectedItemChanged="TreeView_OnSelectedItemChanged" />

и в codebehindfile моего xaml:

private void TreeView_OnSelectedItemChanged(object sender, RoutedPropertyChangedEventArgs<object> e)
{
    Model.SelectedCluster = (Cluster)e.NewValue;
}
  • Error: User Rate Limit Exceeded

    от
  • Error: User Rate Limit ExceededTreeView.SelectedItemError: User Rate Limit ExceededOneWayToSource)?

    от
  • Нету. это дает вам выбранныйTreeViewItemError: User Rate Limit Exceeded

    от
  • Error: User Rate Limit Exceeded

    от
  • Error: User Rate Limit ExceededSystem.Windows.InteractivityError: User Rate Limit Exceedednuget.org/packages/System.Windows.Interactivity.WPF

    от
  • Error: User Rate Limit Exceeded{Binding SelectedItem, Mode=TwoWay}Error: User Rate Limit Exceeded{Binding MyViewModelField, Mode=TwoWay}

    от
  • Error: User Rate Limit Exceeded

    от
  • Error: User Rate Limit Exceededmsdn.microsoft.com/en-us/library/ms788714.aspx

    от Natrium
  • Error: User Rate Limit ExceededTreeViewItemError: User Rate Limit ExceededTreeViewSelectedItemBehaviorError: User Rate Limit ExceedednullError: User Rate Limit ExceededItemContainerGeneratorError: User Rate Limit Exceeded

    от
  • Error: User Rate Limit Exceeded

    от
  • Error: User Rate Limit Exceeded

    от
  • Error: User Rate Limit Exceeded

    от
  • Error: User Rate Limit Exceeded

    от
  • Error: User Rate Limit Exceeded

    от
  • Error: User Rate Limit Exceeded

    от
  • Да ... и где та часть, котораяsetsError: User Rate Limit ExceededTreeView?

    от
  • Error: User Rate Limit Exceeded

    от
  • Error: User Rate Limit Exceededconfused.

    от
  • Error: User Rate Limit Exceeded

    от
  • Error: User Rate Limit Exceededstackoverflow.com/a/18700099/4227

    от
  • Error: User Rate Limit Exceeded

    от
  • Как указал Брент, мне также нужно было добавить Mode = TwoWay к привязке. Я не "Блендер" так не был знаком с поведением & lt; & gt; класс из System.Windows.Interactivity. Сборка является частью Expression Blend. Для тех, кто не хочет покупать / устанавливать пробную версию, чтобы получить эту сборку, вы можете загрузить BlendSDK, который включает System.Windows.Interactivity. BlendSDK 3 для 3.5 ... Я думаю, что это BlendSDK 4 для 4.0. Примечание. Позволяет получить только выбранный элемент, но не позволяет установить выбранный элемент.

    от
  • Вы также можете заменить UIPropertyMetadata на FrameworkPropertyMetadata (null, FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnSelectedItemChanged));

    от
  • Это единственная вещь, которая приблизилась к работе на меня до сих пор. Мне очень нравится это решение.

    от
  • Для этого я бы сделал привязанное поведение!

    от
  • Было бы немного лучше установить свойство зависимости как BindsTwoWayByDefault, тогда вам не нужно будет указывать TwoWay в XAML.

    от
  • Калибурн хорош и элегантен. Работает довольно легко для вложенных иерархий

    от
  • Не знаю, почему, но у меня это не сработало :( Мне удалось получить выбранный элемент из дерева, но не наоборот - изменить выбранный элемент из-за пределов дерева.

    от
  • Человек это отстой. Это меня тоже поразило. Я пришел сюда в надежде найти приличный путь, и я просто идиот. Это первый раз, когда мне грустно, что я не идиот ..

    от Andrei Rînea
  • это действительно отстой и испортить обязательную концепцию

    от Delta
  • Что касается связывания и MVVM, код позади не «запрещен», скорее код сзади должен поддерживать представление. По моему мнению, из всех других решений, которые я видел, код позади является гораздо лучшим вариантом, поскольку он все еще имеет дело с «связыванием». вид на модель. Единственный минус в том, что если у вас есть команда, в которой работает дизайнер, работающий только на XAML, то код может быть поврежден / игнорирован. Это небольшая цена за решение, для реализации которого требуется 10 секунд.

    от nrjohnstone
  • Возможно, одно из самых простых решений:stackoverflow.com/questions/1238304/…

    от JoanComasFdz
  • Надеюсь, что это может помочь кому-то привязать к выбранному древовидному элементу измененный обратный вызов в Icommandjacobaloysious.wordpress.com/2012/02/19/…

    от jacob aloysious
19 ответов
  • 38

    Ну, я нашел решение. Он перемещает беспорядок, так что MVVM работает.

    Сначала добавьте этот класс:

    public class ExtendedTreeView : TreeView
    {
        public ExtendedTreeView()
            : base()
        {
            this.SelectedItemChanged += new RoutedPropertyChangedEventHandler<object>(___ICH);
        }
    
        void ___ICH(object sender, RoutedPropertyChangedEventArgs<object> e)
        {
            if (SelectedItem != null)
            {
                SetValue(SelectedItem_Property, SelectedItem);
            }
        }
    
        public object SelectedItem_
        {
            get { return (object)GetValue(SelectedItem_Property); }
            set { SetValue(SelectedItem_Property, value); }
        }
        public static readonly DependencyProperty SelectedItem_Property = DependencyProperty.Register("SelectedItem_", typeof(object), typeof(ExtendedTreeView), new UIPropertyMetadata(null));
    }
    

    и добавьте это в свой xaml:

     <local:ExtendedTreeView ItemsSource="{Binding Items}" SelectedItem_="{Binding Item, Mode=TwoWay}">
     .....
     </local:ExtendedTreeView>
    

  • 13

    Все к сложному ... Пойдите с Калибурном Микро (http

    //caliburnmicro.codeplex.com/)

    Посмотреть:

    <TreeView Micro:Message.Attach="[Event SelectedItemChanged] = [Action SetSelectedItem($this.SelectedItem)]" />
    

    ViewModel:

    public void SetSelectedItem(YourNodeViewModel item) {}; 
    

  • 1

    После изучения Интернета в течение дня я нашел свое собственное решени

    е для выбора элемента после созданияnormal дерево вnormal Среда WPF / C #

    private void BuildSortTree(int sel)
            {
                MergeSort.Items.Clear();
                TreeViewItem itTemp = new TreeViewItem();
                itTemp.Header = SortList[0];
                MergeSort.Items.Add(itTemp);
                TreeViewItem prev;
                itTemp.IsExpanded = true;
                if (0 == sel) itTemp.IsSelected= true;
                prev = itTemp;
                for(int i = 1; i<SortList.Count; i++)
                {
    
                    TreeViewItem itTempNEW = new TreeViewItem();
                    itTempNEW.Header = SortList[i];
                    prev.Items.Add(itTempNEW);
                    itTempNEW.IsExpanded = true;
                    if (i == sel) itTempNEW.IsSelected = true;
                    prev = itTempNEW ;
                }
            }
    

  • 3

    Я перепробовал все решения этих вопросов. Никто не решил мою проблему

    полностью. Поэтому я думаю, что лучше использовать такой унаследованный класс с переопределенным свойством SelectedItem. Это будет отлично работать, если вы выберете элемент дерева из GUI и если вы установите это значение свойства в своем коде

    public class TreeViewEx : TreeView
    {
        public TreeViewEx()
        {
            this.SelectedItemChanged += new RoutedPropertyChangedEventHandler<object>(TreeViewEx_SelectedItemChanged);
        }
    
        void TreeViewEx_SelectedItemChanged(object sender, RoutedPropertyChangedEventArgs<object> e)
        {
            this.SelectedItem = e.NewValue;
        }
    
        #region SelectedItem
    
        /// <summary>
        /// Gets or Sets the SelectedItem possible Value of the TreeViewItem object.
        /// </summary>
        public new object SelectedItem
        {
            get { return this.GetValue(TreeViewEx.SelectedItemProperty); }
            set { this.SetValue(TreeViewEx.SelectedItemProperty, value); }
        }
    
        // Using a DependencyProperty as the backing store for MyProperty.  This enables animation, styling, binding, etc...
        public new static readonly DependencyProperty SelectedItemProperty =
            DependencyProperty.Register("SelectedItem", typeof(object), typeof(TreeViewEx),
            new FrameworkPropertyMetadata(null, FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, SelectedItemProperty_Changed));
    
        static void SelectedItemProperty_Changed(DependencyObject dependencyObject, DependencyPropertyChangedEventArgs e)
        {
            TreeViewEx targetObject = dependencyObject as TreeViewEx;
            if (targetObject != null)
            {
                TreeViewItem tvi = targetObject.FindItemNode(targetObject.SelectedItem) as TreeViewItem;
                if (tvi != null)
                    tv,i.IsSelected = true;
            }
        }                                               
        #endregion SelectedItem   
    
        public TreeViewItem FindItemNode(object item)
        {
            TreeViewItem node = null;
            foreach (object data in this.Items)
            {
                node = this.ItemContainerGenerator.ContainerFromItem(data) as TreeViewItem;
                if (node != null)
                {
                    if (data == item)
                        break;
                    node = FindItemNodeInChildren(node, item);
                    if (node != null)
                        break;
                }
            }
            return node;
        }
    
        protected TreeViewItem FindItemNodeInChildren(TreeViewItem parent, object item)
        {
            TreeViewItem node = null;
            bool isExpanded = parent.IsExpanded;
            if (!isExpanded) //Can't find child container unless the parent node is Expanded once
            {
                parent.IsExpanded = true;
                parent.UpdateLayout();
            }
            foreach (object data in parent.Items)
            {
                node = parent.ItemContainerGenerator.ContainerFromItem(data) as TreeViewItem;
                if (data == item && node != null)
                    break;
                node = FindItemNodeInChildren(node, item);
                if (node != null)
                    break;
            }
            if (node == null && parent.IsExpanded != isExpanded)
                parent.IsExpanded = isExpanded;
            if (node != null)
                parent.IsExpanded = true;
            return node;
        }
    } 
    

  • 1

    Это также можно сделать с помощью свойства IsSelected элемента TreeVie

    w. Вот как мне это удалось,

    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);
        }
      }
    }
    

    Затем в ViewModel, которая содержит данные, с которыми связан TreeView, просто подпишитесь на событие в классе TreeViewItem.

    TreeViewItem.OnItemSelected += TreeViewItemSelected;
    

    И, наконец, реализовать этот обработчик в той же ViewModel,

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

    И обязательна, конечно,

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

  • 218

    Я понимаю

    что этот ответ уже принят, но я собрал его вместе, чтобы решить проблему. Он использует идею, аналогичную решению Delta, но без необходимости подкласса TreeView:

    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 item = e.NewValue as TreeViewItem;
            if (item != null)
            {
                item.SetValue(TreeViewItem.IsSelectedProperty, true);
            }
        }
    
        #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;
        }
    }
    

    Затем вы можете использовать это в своем XAML как:

    <TreeView>
        <e:Interaction.Behaviors>
            <behaviours:BindableSelectedItemBehavior SelectedItem="{Binding SelectedItem, Mode=TwoWay}" />
        </e:Interaction.Behaviors>
    </TreeView>
    

    Надеюсь, это кому-нибудь поможет!

  • 1

    Я предлагаю вам свое решение

    которое предлагает следующие возможности:

    Supports 2 ways binding

    Auto updates the TreeViewItem.IsSelected properties (according to the SelectedItem)

    No TreeView subclassing

    Items bound to ViewModel can be of any type (even null)

    1 / Вставьте следующий код в вашу CS:

    public class BindableSelectedItem
    {
        public static readonly DependencyProperty SelectedItemProperty = DependencyProperty.RegisterAttached(
            "SelectedItem", typeof(object), typeof(BindableSelectedItem), new PropertyMetadata(default(object), OnSelectedItemPropertyChangedCallback));
    
        private static void OnSelectedItemPropertyChangedCallback(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            var treeView = d as TreeView;
            if (treeView != null)
            {
                BrowseTreeViewItems(treeView, tvi =>
                {
                    tvi.IsSelected = tvi.DataContext == e.NewValue;
                });
            }
            else
            {
                throw new Exception("Attached property supports only TreeView");
            }
        }
    
        public static void SetSelectedItem(DependencyObject element, object value)
        {
            element.SetValue(SelectedItemProperty, value);
        }
    
        public static object GetSelectedItem(DependencyObject element)
        {
            return element.GetValue(SelectedItemProperty);
        }
    
        public static void BrowseTreeViewItems(TreeView treeView, Action<TreeViewItem> onBrowsedTreeViewItem)
        {
            var collectionsToVisit = new System.Collections.Generic.List<Tuple<ItemContainerGenerator, ItemCollection>> { new Tuple<ItemContainerGenerator, ItemCollection>(treeView.ItemContainerGenerator, treeView.Items) };
            var collectionIndex = 0;
            while (collectionIndex < collectionsToVisit.Count)
            {
                var itemContainerGenerator = collectionsToVisit[collectionIndex].Item1;
                var itemCollection = collectionsToVisit[collectionIndex].Item2;
                for (var i = 0; i < itemCollection.Count; i++)
                {
                    var tvi = itemContainerGenerator.ContainerFromIndex(i) as TreeViewItem;
                    if (tvi == null)
                    {
                        continue;
                    }
    
                    if (tvi.ItemContainerGenerator.Status == System.Windows.Controls.Primitives.GeneratorStatus.ContainersGenerated)
                    {
                        collectionsToVisit.Add(new Tuple<ItemContainerGenerator, ItemCollection>(tvi.ItemContainerGenerator, tvi.Items));
                    }
    
                    onBrowsedTreeViewItem(tvi);
                }
    
                collectionIndex++;
            }
        }
    
    }
    

    2 / Пример использования в вашем файле XAML

    <TreeView myNS:BindableSelectedItem.SelectedItem="{Binding Path=SelectedItem, Mode=TwoWay}" />  
    

  • 0

    Если XAML имеет

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

    Что плохого в том, чтобы просто найти этот элемент в списке? Я также использую

    <Setter Property="IsExpanded" Value="{Binding IsExpanded, Mode=TwoWay}" />
    

    Чтобы убедиться, что когда я установил IsSelected = true в виртуальной машине, родители раскрываются.

  • 2

    WPF MVVM TreeView SelectedItem

    ... является лучшим ответом, но не упоминает способ получить / установить SelectedItem в ViewModel.

    Add a IsSelected boolean property to your ItemViewModel, and bind to it in a Style Setter for the TreeViewItem. Add a SelectedItem property to your ViewModel used as the DataContext for the TreeView. This is the missing piece in the solution above.
        ' ItemVM...
        Public Property IsSelected As Boolean
            Get
                Return _func.SelectedNode Is Me
            End Get
            Set(value As Boolean)
                If IsSelected  value Then
                    _func.SelectedNode = If(value, Me, Nothing)
                End If
                RaisePropertyChange()
            End Set
        End Property
        ' TreeVM...
        Public Property SelectedItem As ItemVM
            Get
                Return _selectedItem
            End Get
            Set(value As ItemVM)
                If _selectedItem Is value Then
                    Return
                End If
                Dim prev = _selectedItem
                _selectedItem = value
                If prev IsNot Nothing Then
                    prev.IsSelected = False
                End If
                If _selectedItem IsNot Nothing Then
                    _selectedItem.IsSelected = True
                End If
            End Set
        End Property
    
    <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>
    

  • 2

    Моим требованием было решение на основе PRISM-MVVM

    где требовалось TreeView, а связанный объект имеет тип Collection & lt; & gt; и, следовательно, нуждается в HierarchicalDataTemplate. BindableSelectedItemBehavior по умолчанию не сможет идентифицировать дочерний TreeViewItem. Чтобы это работало в этом сценарии.

    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;
        }
    }
    

    Это позволяет перебирать все элементы независимо от уровня.

  • 3

    Существует также способ создания привязываемого свойства XAML Selected

    Item без использования Interaction.Behaviors.

    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
    }
    

    Затем вы можете использовать это в своем XAML как:

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

  • 5

    Вы также можете использовать свойство TreeViewItem.IsSelected

  • 0

    Привязка к SelectedItem была бы очевидной

    (Давайте просто согласимся с тем, что TreeView явно обанкротился в отношении этой проблемы..Sigh)

    Мне нужно, чтобы решение правильно взаимодействовало со свойством IsSelected TreeViewItem, поэтому вот как я это сделал:

    // the Type CustomThing needs to implement IsSelected with notification
    // for this to work.
    public class CustomTreeView : TreeView
    {
        public CustomThing SelectedCustomThing
        {
            get
            {
                return (CustomThing)GetValue(SelectedNode_Property);
            }
            set
            {
                SetValue(SelectedNode_Property, value);
                if(value != null) value.IsSelected = true;
            }
        }
    
        public static DependencyProperty SelectedNode_Property =
            DependencyProperty.Register(
                "SelectedCustomThing",
                typeof(CustomThing),
                typeof(CustomTreeView),
                new FrameworkPropertyMetadata(
                    null,
                    FrameworkPropertyMetadataOptions.None,
                    SelectedNodeChanged));
    
        public CustomTreeView(): base()
        {
            this.SelectedItemChanged += new RoutedPropertyChangedEventHandler<object>(SelectedItemChanged_CustomHandler);
        }
    
        void SelectedItemChanged_CustomHandler(object sender, RoutedPropertyChangedEventArgs<object> e)
        {
            SetValue(SelectedNode_Property, SelectedItem);
        }
    
        private static void SelectedNodeChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            var treeView = d as CustomTreeView;
            var newNode = e.NewValue as CustomThing;
    
            treeView.SelectedCustomThing = (CustomThing)e.NewValue;
        }
    }
    

    С этим XAML:

    <local:CustonTreeView ItemsSource="{Binding TreeRoot}" 
        SelectedCustomThing="{Binding SelectedNode,Mode=TwoWay}">
        <TreeView.ItemContainerStyle>
            <Style TargetType="TreeViewItem">
                <Setter Property="IsSelected" Value="{Binding IsSelected, Mode=TwoWay}" />
            </Style>
        </TreeView.ItemContainerStyle>
    </local:CustonTreeView>
    

  • 34

    Ответ с прикрепленными свойствами и без внешних зависимостей

    если необходимость когда-либо возникнет!

    Вы можете создать присоединяемое свойство, которое является привязываемым и имеет геттер и сеттер:

    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;
            }
        }
    }
    

    Добавьте объявление пространства имен, содержащее этот класс, в ваш XAML и выполните привязку следующим образом (локально, как я назвал объявление пространства имен):

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

    Теперь вы можете связать выбранный элемент, а также настроить его в модели представления, чтобы изменить его программно, если это когда-либо возникнет. Это, конечно, при условии, что вы реализуете INotifyPropertyChanged для этого конкретного свойства.

  • 20

    Он отвечает немного больше

    чем ожидает OP ... Но я надеюсь, что он может помочь кому-то, по крайней мере.

    Если вы хотите выполнитьICommand всякий раз, когдаSelectedItem изменено, вы можете связать команду на событие и использование свойстваSelectedItem вViewModel больше не требуется.

    Для этого:

    1- Добавить ссылку наSystem.Windows.Interactivity

    xmlns:i="clr-namespace:System.Windows.Interactivity;assembly=System.Windows.Interactivity"
    

    2- Привязать команду к событиюSelectedItemChanged

    <TreeView x:Name="myTreeView" Margin="1"
                ItemsSource="{Binding Directories}">
        <i:Interaction.Triggers>
            <i:EventTrigger EventName="SelectedItemChanged">
                <i:InvokeCommandAction Command="{Binding SomeCommand}"
                                       CommandParameter="
                                                {Binding ElementName=myTreeView
                                                 ,Path=SelectedItem}"/>
            </i:EventTrigger>
        </i:Interaction.Triggers>
        <TreeView.ItemTemplate>
               <!-- ... -->
        </TreeView.ItemTemplate>
    </TreeView>
    

  • 18

    Это может быть выполнено в более «хорошем» виде. путем использования т

    олько привязки и EventToCommand библиотеки GalaSoft MVVM Light. В вашей виртуальной машине добавьте команду, которая будет вызываться при изменении выбранного элемента, и инициализируйте команду, чтобы выполнить любое необходимое действие. В этом примере я использовал RelayCommand и просто установлю свойство SelectedCluster.

    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; }
    }
    

    Затем добавьте поведение EventToCommand в ваш xaml. Это действительно легко, используя смесь.

    <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>
    

  • 43

    Это свойство существует:

    TreeView.SelectedItem

    Но это только для чтения, поэтому вы не можете назначить его через привязку, только получить его

  • 2

    Я предлагаю дополнение к поведению

    предоставленному Стивом Грейтрексом. Его поведение не отражает изменений из источника, поскольку он не может быть коллекцией TreeViewItems. Таким образом, нужно найти TreeViewItem в дереве, для которого datacontext является выбранным значением из источника. TreeView имеет защищенное свойство «ItemsHost», которое содержит коллекцию TreeViewItem. Мы можем пройти через отражение и пройтись по дереву в поисках выбранного элемента.

    private static void OnSelectedItemChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var behavior = sender as BindableSelectedItemBehaviour;
    
            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;
            }
    
            foreach (var item in treeViewItem.Items.OfType<TreeViewItem>())
                if (WalkTreeViewItem(item, selectedValue)) return true;
    
            return false;
        }
    

    Таким образом, поведение работает для двусторонних привязок. В качестве альтернативы можно перемещать получение ItemsHost в метод OnAttached поведения, сохраняя издержки на использование отражения каждый раз, когда привязка обновляется.

  • 8

    Я наткнулся на эту страницу в поисках того же ответа

    что и первоначальный автор, и доказал, что всегда есть более чем один способ сделать это, решение для меня было даже проще, чем ответы, представленные здесь до сих пор, поэтому я подумал, хорошо добавить в кучу.

    Мотивация для связывания состоит в том, чтобы держать это хорошим & amp; MVVM. Вероятное использование ViewModel состоит в том, чтобы иметь свойство с именем, таким как «CurrentThingy», и где-то еще, DataContext для некоторой другой вещи связан с «CurrentThingy».

    Вместо того, чтобы выполнять дополнительные необходимые шаги (например, настраиваемое поведение, сторонний контроль) для поддержки хорошей привязки TreeView к моей модели, а затем из чего-то другого к моей модели, мое решение заключалось в использовании простого Element, связывающего другое TreeView.SelectedItem, вместо того, чтобы связывать другую вещь с моей ViewModel, таким образом, пропуская дополнительную требуемую работу.

    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}" />
    

    Конечно, это отлично подходит для чтения выбранного в данный момент элемента, но не для его настройки, и это все, что мне нужно.