Sammlung Abhängigkeit Eigenschaften

Habe ich ein benutzerdefiniertes Steuerelement, das eine DependencyProperty Typ ObservableCollection gebunden ist, um eine observableCollection:

<MyControl MyCollectionProperty = {Binding MyObservableCollection} ...

Problem ist das hinzufügen zu MyObservableCollection nicht aktualisiert MyCollectionProperty.

Muss ich komplett ersetzen, die MyObservableCollection zu machen, arbeiten z.B.

MyObservableCollection = null;
MyObservableCollection = new ObservableCollection(){...}

Gibt es eine bessere Möglichkeit, damit umzugehen?

EDIT:

    public ObservableCollection<string> Columns
    {
        get { return (ObservableCollection<string>)GetValue(ColumnsProperty); }
        set { SetValue(ColumnsProperty, value); }
    }

    public static readonly DependencyProperty ColumnsProperty =
        DependencyProperty.Register("Columns", typeof(ObservableCollection<string>), typeof(MyControl),
                                    new PropertyMetadata(new ObservableCollection<string>(), OnChanged));
  • Würden Sie post von der definition der Abhängigkeit-Eigenschaft? Könnte etwas aus dort...
  • Ist Ihre "MyControl" monitoring PropertyChanged-oder CollectionChanged und sind Sie die überwachung PropertyChanged auf die Objekte in Ihrem beobachtbaren Sammlung?
  • ja, es ist ein Rückruf in der Definition und den handler für die CollectionChanged nie gefeuert wird. Ich sehe nicht, wo das hören für PropertyChanged auf die Elemente ist relevant, da wir reden über das hinzufügen.
  • Kannst du die Methode onChanged-Ereignisse? Btw es ist nicht eine gute Idee, um eine Voreinstellung für Ihre dp. Jede Instanz des Steuerelements wird auf die gleiche collection-Instanz standardmäßig.
  • Ah.. guter Punkt, um den default-Wert. Ich könnte den handler aber es ist irgendwie irrelevant, weil Sie nie aufgerufen wird.
  • Ähnliches problem gefragt und hier beantwortet stackoverflow.com/questions/4362278/...

InformationsquelleAutor user1604008 | 2013-02-22
  1. 6

    Unten ist ein lauffähiges Beispiel, das kann helfen.

    In diesem Beispiel wird die Methode onChanged-Ereignisse wird sofort aufgerufen, wenn die Schaltfläche Hinzufügen geklickt wird "Geändert" wird in die Konsole geschrieben.

    Die Kontrolle

    public class MyControl : Control
{

    public ObservableCollection<string> ExtraColumns
    {
        get { return (ObservableCollection<string>)GetValue(ExtraColumnsProperty); }
        set { SetValue(ExtraColumnsProperty, value); }
    }

    public static readonly DependencyProperty ExtraColumnsProperty =
        DependencyProperty.Register("ExtraColumns", typeof(ObservableCollection<string>), typeof(MyControl),
                                    new PropertyMetadata(new ObservableCollection<string>(), OnChanged));

    static void OnChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
    {
        (sender as MyControl).OnChanged();

    }

    void OnChanged()
    {
        if ( ExtraColumns != null )
            ExtraColumns.CollectionChanged += new System.Collections.Specialized.NotifyCollectionChangedEventHandler(ExtraColumns_CollectionChanged);
    }

    void ExtraColumns_CollectionChanged(object sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs e)
    {
        Console.WriteLine("Changed");    
    }
}

    Dem Fenster

    <Window x:Class="WpfApplication18.MainWindow"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:local="clr-namespace:WpfApplication18"
    Title="MainWindow" Height="350" Width="525">
  <StackPanel>
    <local:MyControl ExtraColumns="{Binding Extras}"/>
    <Button Click="Button_Click">Add</Button>
  </StackPanel>
</Window>

    Fenster Code Hinter

    public partial class MainWindow : Window
{
    private ObservableCollection<string> _extras = new ObservableCollection<string>( );
    public ObservableCollection<string> Extras
    {
        get { return _extras; }
        set
        {
            if (value != _extras)
            {
                _extras = value;
            }
        }
    }


    public MainWindow()
    {
        InitializeComponent();
        DataContext = this;
    }

    private void Button_Click(object sender, RoutedEventArgs e)
    {
        Extras.Add("Additional");
    }
}
    • Sie sollten nicht verwenden Sie den code new PropertyMetadata(new ObservableCollection<string>() bei der Registrierung von abhängigkeitseigenschaften. Siehe hier für die Erklärung
    InformationsquelleAutor grantnz
  2. 14

    Zusätzlich zu dem, was grantz beantwortet hat, würde ich vorschlagen, zu erklären, dass die Eigenschaft mit dem Typ IEnumerable<string> und prüfen zur Laufzeit, wenn das collection-Objekt implementiert die , INotifyCollectionChanged - Schnittstelle. Dies bietet eine höhere Flexibilität als um die konkrete collection-Implementierung kann verwendet werden als-Eigenschaft-Wert. Ein Benutzer kann dann entscheiden, haben Ihre eigenen spezialisierten Implementierung eines beobachtbaren Sammlung.

    Beachten Sie auch, dass in der ColumnsPropertyChanged Rückruf der CollectionChanged event-handler angeschlossen ist, um die neue Kollektion, aber auch entfernt von der alten.

    public static readonly DependencyProperty ColumnsProperty =
    DependencyProperty.Register(
        "Columns", typeof(IEnumerable<string>), typeof(MyControl),
        new PropertyMetadata(null, ColumnsPropertyChanged));

public IEnumerable<string> Columns
{
    get { return (IEnumerable<string>)GetValue(ColumnsProperty); }
    set { SetValue(ColumnsProperty, value); }
}

private static void ColumnsPropertyChanged(
    DependencyObject obj, DependencyPropertyChangedEventArgs e)
{
    var control= (MyControl)obj;
    var oldCollection = e.OldValue as INotifyCollectionChanged;
    var newCollection = e.NewValue as INotifyCollectionChanged;

    if (oldCollection != null)
    {
        oldCollection.CollectionChanged -= control.ColumnsCollectionChanged;
    }

    if (newCollection != null)
    {
        newCollection.CollectionChanged += control.ColumnsCollectionChanged;
    }

    control.UpdateColumns();
}

private void ColumnsCollectionChanged(
    object sender, NotifyCollectionChangedEventArgs e)
{
    //optionally take e.Action into account
    UpdateColumns();
}

private void UpdateColumns()
{
    ...
}
    InformationsquelleAutor Clemens
Schreibe einen Kommentar