Question

我正在尝试将Microsoft示例ObservableConcurrentDictionary.cs对象绑定到TreeView。我搜索了关于绑定词典的例子，但是虽然有很多例子，但它们似乎都不适合我。每当我运行它时，屏幕显示为空treeview（仅白色轮廓）。我已经将我的代码剥离到最低限度以进行测试，我的实现如下：

<Window x:Name="AppWindow" x:Class="ControlCenter.MainWindow"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    Title="Control Center" Height="1000" Width="1200"
    WindowStartupLocation="CenterScreen">
<Grid x:Name="left_grid" Margin="362,199,551,237">
    <TreeView ItemsSource="{Binding _hostList}">
        <TreeView.ItemTemplate>
            <DataTemplate>
                <TextBlock Text="{Binding _hostList.Values}"/>
            </DataTemplate>
        </TreeView.ItemTemplate>
    </TreeView>
</Grid>

public partial class MainWindow : Window
{

    public ObservableConcurrentDictionary<string, string> _hostList = new ObservableConcurrentDictionary<string, string>();
    public MainWindow()
    {
        InitializeComponent();
        _hostList.Add("TestHost1", "Host1");
        _hostList.Add("TestHost2", "Host2");
        _hostList.Add("TestHost3", "Host3");
    } 
}

using System.Collections.Generic;
using System.Collections.Specialized;
using System.ComponentModel;
using System.Threading;
using System.Diagnostics;

namespace System.Collections.Concurrent
{
[DebuggerDisplay("Count={Count}")]
public class ObservableConcurrentDictionary<TKey, TValue> :
    ICollection<KeyValuePair<TKey, TValue>>, IDictionary<TKey, TValue>,
    INotifyCollectionChanged, INotifyPropertyChanged
{
    private readonly SynchronizationContext _context;
    private readonly ConcurrentDictionary<TKey, TValue> _dictionary;

    /// <summary>
    /// Initializes an instance of the ObservableConcurrentDictionary class.
    /// </summary>
    public ObservableConcurrentDictionary()
    {
        _context = AsyncOperationManager.SynchronizationContext;
        _dictionary = new ConcurrentDictionary<TKey, TValue>();
    }

    /// <summary>Event raised when the collection changes.</summary>
    public event NotifyCollectionChangedEventHandler CollectionChanged;
    /// <summary>Event raised when a property on the collection changes.</summary>
    public event PropertyChangedEventHandler PropertyChanged;

    /// <summary>
    /// Notifies observers of CollectionChanged or PropertyChanged of an update to the dictionary.
    /// </summary>
    private void NotifyObserversOfChange()
    {
        var collectionHandler = CollectionChanged;
        var propertyHandler = PropertyChanged;
        if (collectionHandler != null || propertyHandler != null)
        {
            _context.Post(s =>
            {
                if (collectionHandler != null)
                {
                    collectionHandler(this, new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset));
                }
                if (propertyHandler != null)
                {
                    propertyHandler(this, new PropertyChangedEventArgs("Count"));
                    propertyHandler(this, new PropertyChangedEventArgs("Keys"));
                    propertyHandler(this, new PropertyChangedEventArgs("Values"));
                }
            }, null);
        }
    }

    /// <summary>Attempts to add an item to the dictionary, notifying observers of any changes.</summary>
    /// <param name="item">The item to be added.</param>
    /// <returns>Whether the add was successful.</returns>
    private bool TryAddWithNotification(KeyValuePair<TKey, TValue> item)
    {
        return TryAddWithNotification(item.Key, item.Value);
    }

    /// <summary>Attempts to add an item to the dictionary, notifying observers of any changes.</summary>
    /// <param name="key">The key of the item to be added.</param>
    /// <param name="value">The value of the item to be added.</param>
    /// <returns>Whether the add was successful.</returns>
    private bool TryAddWithNotification(TKey key, TValue value)
    {
        bool result = _dictionary.TryAdd(key, value);
        if (result) NotifyObserversOfChange();
        return result;
    }

    /// <summary>Attempts to remove an item from the dictionary, notifying observers of any changes.</summary>
    /// <param name="key">The key of the item to be removed.</param>
    /// <param name="value">The value of the item removed.</param>
    /// <returns>Whether the removal was successful.</returns>
    private bool TryRemoveWithNotification(TKey key, out TValue value)
    {
        bool result = _dictionary.TryRemove(key, out value);
        if (result) NotifyObserversOfChange();
        return result;
    }

    /// <summary>Attempts to add or update an item in the dictionary, notifying observers of any changes.</summary>
    /// <param name="key">The key of the item to be updated.</param>
    /// <param name="value">The new value to set for the item.</param>
    /// <returns>Whether the update was successful.</returns>
    private void UpdateWithNotification(TKey key, TValue value)
    {
        _dictionary[key] = value;
        NotifyObserversOfChange();
    }

    #region ICollection<KeyValuePair<TKey,TValue>> Members
    void ICollection<KeyValuePair<TKey, TValue>>.Add(KeyValuePair<TKey, TValue> item)
    {
        TryAddWithNotification(item);
    }

    void ICollection<KeyValuePair<TKey, TValue>>.Clear()
    {
        ((ICollection<KeyValuePair<TKey, TValue>>)_dictionary).Clear();
        NotifyObserversOfChange();
    }

    bool ICollection<KeyValuePair<TKey, TValue>>.Contains(KeyValuePair<TKey, TValue> item)
    {
        return ((ICollection<KeyValuePair<TKey, TValue>>)_dictionary).Contains(item);
    }

    void ICollection<KeyValuePair<TKey, TValue>>.CopyTo(KeyValuePair<TKey, TValue>[] array, int arrayIndex)
    {
        ((ICollection<KeyValuePair<TKey, TValue>>)_dictionary).CopyTo(array, arrayIndex);
    }

    int ICollection<KeyValuePair<TKey, TValue>>.Count
    {
        get { return ((ICollection<KeyValuePair<TKey, TValue>>)_dictionary).Count; }
    }

    bool ICollection<KeyValuePair<TKey, TValue>>.IsReadOnly
    {
        get { return ((ICollection<KeyValuePair<TKey, TValue>>)_dictionary).IsReadOnly; }
    }

    bool ICollection<KeyValuePair<TKey, TValue>>.Remove(KeyValuePair<TKey, TValue> item)
    {
        TValue temp;
        return TryRemoveWithNotification(item.Key, out temp);
    }
    #endregion

    #region IEnumerable<KeyValuePair<TKey,TValue>> Members
    IEnumerator<KeyValuePair<TKey, TValue>> IEnumerable<KeyValuePair<TKey, TValue>>.GetEnumerator()
    {
        return ((ICollection<KeyValuePair<TKey, TValue>>)_dictionary).GetEnumerator();
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        return ((ICollection<KeyValuePair<TKey, TValue>>)_dictionary).GetEnumerator();
    }
    #endregion

    #region IDictionary<TKey,TValue> Members
    public void Add(TKey key, TValue value)
    {
        TryAddWithNotification(key, value);
    }

    public bool ContainsKey(TKey key)
    {
        return _dictionary.ContainsKey(key);
    }

    public ICollection<TKey> Keys
    {
        get { return _dictionary.Keys; }
    }

    public bool Remove(TKey key)
    {
        TValue temp;
        return TryRemoveWithNotification(key, out temp);
    }

    public bool TryGetValue(TKey key, out TValue value)
    {
        return _dictionary.TryGetValue(key, out value);
    }

    public ICollection<TValue> Values
    {
        get { return _dictionary.Values; }
    }

    public TValue this[TKey key]
    {
        get { return _dictionary[key]; }
        set { UpdateWithNotification(key, value); }
    }
    #endregion
}

}

Answer 1

有一些问题。首先，因为您没有在绑定中指定来源，所以DataContext是null。

我认为您正在考虑，因为您正在使用MainWindow，绑定语句的来源将是MainWindow对象，但这不是绑定的默认值。如果你想这样做，你必须在绑定中使用RelativeSource，但通常你只需将集合作为视图模型的一部分弹出到DataContext中，或者直接作为整个视图模型弹出。像这样：

public ObservableConcurrentDictionary<string, string> _hostList = new ObservableConcurrentDictionary<string, string>();
public MainWindow()
{
    InitializeComponent();
    _hostList.Add("TestHost1", "Host1");
    _hostList.Add("TestHost2", "Host2");
    _hostList.Add("TestHost3", "Host3");
    DataContext = _hostList;
}

然后您只需将绑定从DataContext移开，以便按以下步骤更新代码：

<TreeView ItemsSource="{Binding}">
    <TreeView.ItemTemplate>
        <DataTemplate>
            <TextBlock Text="{Binding Values}"/>
        </DataTemplate>
    </TreeView.ItemTemplate>
</TreeView>

这不会完全解决我想到的问题，因为我认为你绑定了错误的属性。 ItemsSource应绑定到某种IEnumerable的某些内容，而Text应绑定到string。

所以我不确定你想要表现出什么，但我很确定你没有正确绑定。通常使用TreeView，您将使用HierarchicalDataTemplate，我认为这可能是您想要使用的内容。

Answer 2

我认为问题在于您需要绑定到属性，而不是类型（字符串）。否则绑定将无法工作。具体

 public ObservableConcurrentDictionary<string, string>...

应该是

 public ObservableConcurrentDictionary<string, myobj>...

，并确保显示的数据是适当的属性，而不是字段。即。

       public class myobj {
            public string mystg { get; set; }
        }

已设置

  listBox.ItemsSource = _hostList;

（您做了一棵树，我用列表视图进行了测试）然后绑定应该是

{Binding Value.mystg}

我确实注意到，字典不支持排序，并且在我看来，新添加的项目是随机出现的，因此排序可能是另一种动物。

如何将ObservableConcurrentDictionary绑定到WPF TreeView

2 个答案: