Mit BindingOperations.EnableCollectionSynchronization

Habe ich zwei WPF-Anwendungen "UI", "Debugger" und eine ClassLibrary "BL". UI Verweise auf Debugger und BL. Debugger verweist auf BL.
Ich habe die Sammlung in BL genannt MyCollection. UI-app startet den Debugger app und Debugger bindet an eine collection MyCollection in BL. Wenn ich versuche die MyCollection Sammlung von UI-app bin ich immer die Ausnahme.

A first chance exception of type 'System.NotSupportedException' occurred in PresentationFramework.dll

Additional information: This type of CollectionView does not support changes to its SourceCollection from a thread different from the Dispatcher thread.

War ich googeln um und fand dieses: BindingOperations.EnableCollectionSynchronization
Ich kann nicht herausfinden, wie es zu benutzen. Ich will nicht an Bezugnahme auf andere UI-dlls von meinem BL-Projekt. Kann jemand mir helfen?

Danke für die Hilfe!

InformationsquelleAutor Dilshod | 2014-02-12

  1. 18

    Allen Beispielen, die ich gesehen habe, auf Stack Overflow für dieses bekommen es falsch. Sie muss sperren der Auflistung ändern, wenn es aus einem anderen thread.

    Auf dem dispatcher (UI) - thread:

    _itemsLock = new object();
Items = new ObservableCollection<Item>();
BindingOperations.EnableCollectionSynchronization(Items, _itemsLock);

    Dann aus einem anderen thread:

    lock (_itemsLock)
{
    //Once locked, you can manipulate the collection safely from another thread
    Items.Add(new Item());
    Items.RemoveAt(0);
}

    Mehr Informationen in diesem Artikel: http://10rem.net/blog/2012/01/20/wpf-45-cross-thread-collection-synchronization-redux

    InformationsquelleAutor Drew Noakes

  2. 5

    Ich bin nicht sicher, ob dies helfen wird, aber trotzdem kann man es versuchen.

    Hinzufügen Property im Debugger was hält die Collection aus BL wie 

    private ObservableCollection<string> _data = new ObservableCollection<string>();
private object _lock = new object();

public ObservableCollection<string> Data { get {return _data;} }

    Im Konstruktor fügen Sie einfach die folgende Zeile

    BindingOperations.EnableCollectionSynchronization(_data, _lock);

    dieser wird über der Zeile kümmern wird thread-Sicherheit.

    Unten ist das Beispiel

    ViewModel (Debugger)

    internal class ViewModelClass : INotifyPropertyChanged
{
    private object _lock = new object ();
    private ObservableCollection<string> _data;

    public ObservableCollection<string> Data
    {
        get { return _data; }
        private set
        {
            _data = value;
            RaisePropertyChanged ("Data");
        }
    }

    private string _enteredText;
    public string EnteredText
    {
        get { return _enteredText; }
        set
        {
            _enteredText = value;
            _data.Add (value); RaisePropertyChanged ("EnteredText");
        }
    }

    private void RaisePropertyChanged (string name)
    {
        var pc = PropertyChanged;
        if (pc != null)
            pc (this, new PropertyChangedEventArgs (name));
    }

    public ViewModelClass ()
    {
        var _model = new ModelClass ();
        Data = _model.Data;
        _data.CollectionChanged += (s, e) => RaisePropertyChanged ("Data");
    }

    public event PropertyChangedEventHandler PropertyChanged;
}

    Modell(BL)

    internal class ModelClass
{
    private ObservableCollection<string> _data;

    public ObservableCollection<string> Data
    {
        get { return _data; }
        private set { _data = value; }
    }

    public ModelClass ()
    {
        _data = new ObservableCollection<string> { "Test1", "Test2", "Test3" };
    }
}

    MainWindow.xaml.cs

    public partial class MainWindow : Window
{
    public MainWindow ()
    {
        InitializeComponent ();
        this.DataContext = new ViewModelClass ();
    }
}

    MainWindow.xaml

    <Window x:Class="CollectionSynchronizationTest.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">
<StackPanel>
    <ComboBox IsEditable="True"
                        ItemsSource="{Binding Data}"
                        Text="{Binding EnteredText, Mode=TwoWay, UpdateSourceTrigger=LostFocus}" />
    <Button Content="Test" />
</StackPanel>

    Wenn das Fenster geladen wird, geben Sie einfach "SomeValue" in der ComboBox und dann nach drücken der Tab Schlüssel, sollten Sie den neuen Wert in die ComboBox dropdown -

    Was ist der Punkt, der mit NotifyPropertyChanged für ObservableCollection<T>?
    Die INotifyPropertyChanged - Schnittstelle wird verwendet, um Benachrichtigen von der Benutzeroberfläche für beliebiger änderung der Daten im ViewModel. Ansonsten ist die UI nie bekommen neue Werte.
    ObservableCollection<T> übernimmt das für Sie. So brauchen Sie nicht, um es für ObservableCollections.
    "BindingOperations.EnableCollectionSynchronization(_data, _lock);" kümmert sich nicht wirklich um thread-Sicherheit. Sie haben noch um es zu sperren _lock Objekt.
    Sie tun haben, um die Sperre auf das lock-Objekt, wenn eine änderung der Auflistung aus einem anderen thread (haben Sie nicht nur zum Versand an den UI-thread zu tun). Lesen Sie diesen Artikel für weitere Infos: 10rem.net/blog/2012/01/20/...

    InformationsquelleAutor Sandesh

  3. 1

    In diesem blog finden Sie eine einfache Anleitung, wie man mit BindingOperations...es ist ganz einfach.

    InformationsquelleAutor Marco

  4. -3

    Konnte ich nicht herausfinden, wie es zu benutzen, entweder, wenn ich hatte das gleiche problem.

    Ich endete mit meiner eigenen Sammlung geben, wo Lagere ich die dispatcher und verwenden Sie es, wenn nötig.
    Beachten Sie, dass meine Namensgebung war sehr schlecht, diese Sammlung ist nicht threadsicher, weit von es.

    public class ThreadableObservableCollection<T> : ObservableCollection<T>
{
    private readonly Dispatcher _dispatcher;
    public ThreadableObservableCollection()
    {
      _dispatcher = Dispatcher.CurrentDispatcher;
    }

    public void ThreadsafeRemove(T item, Action callback)
    {
      if (_dispatcher.CheckAccess())
      {
        Remove(item);
        callback();
      }
      else
      {
        _dispatcher.Invoke(() =>
          {
            Remove(item);
            callback();
          });
      }
    }

    public void ThreadsafeInsert(int pos, T item, Action callback)
    {
      if (_dispatcher.CheckAccess())
      {
        Insert(pos, item);
        callback();
      }
      else
      {
        _dispatcher.Invoke(() =>
          {
            Insert(pos, item);
            callback();
          });
      }
    }
  }
    Diese verwenden nicht die Technik ist gefragt, etwa in der Frage (BindingOperations.EnableCollectionSynchronization).

    InformationsquelleAutor Herm

Schreibe einen Kommentar