[WPF] Mutable objects en DependencyProperties

[Mnstrspeed]

Ik heb ergens in mijn (fictieve) project een mutable class die een event triggert als er iets verandert:

C#:

public delegate void ChangedEventHandler(object sender, EventArgs e);

public class Configuration
{
    private string name;
    public string Name
    {
        set 
        { 
            this.name = value; 
            OnChanged(); 
        }
        get { return this.name; }
    }

    public event ChangedEventHandler Changed;

    protected void OnChanged()
    {
        if (this.Changed != null)
            this.Changed(this, EventArgs.Empty);
    }
}

En verderop ergens in mijn WPF-applicatie een UserControl met een DependencyProperty:

C#:

public class MyControl : UserControl
{
    public static readonly DependencyProperty ConfigurationProperty =
        DependencyProperty.Register("Configuration", typeof(Configuration), 
        typeof(MyControl), new FrameworkPropertyMetadata(null,
            FrameworkPropertyMetadataOptions.AffectsRender));
    
    public Configuration Configuration
    {
        get { return GetValue(ConfigurationProperty) as Configuration; }
        set { SetValue(ConfigurationProperty, value); }
    }

    protected override void OnRender(DrawingContext drawingContext)
    {
        // Render something with data from Configuration
    }
}

Dit had geweldig gewerkt als 'Configuration' immutable was geweest en ik iedere keer een nieuwe waarde aan de DependencyProperty had toegewezen, maar helaas. Ik zoek een manier om de DependencyProperty op het 'Changed' event uit 'Configuration' te laten reageren (een nieuwe render laten triggeren, volgens FrameworkPropertyMetadataOptions.AffectsRender). Nou kan ik zelf natuurlijk een PropertyChangedCallback aan de DependencyProperty hangen en me handmatig aanmelden voor 'Configuration.Changed' en dan een InvalidateRender() aanroepen bij iedere trigger, maar dat lijkt me geen mooie oplossing.

Is dit voorzien in WPF?

[Niemand_Anders]

Je moet de interface INotifyPropertyChanged implementeren voor de 'Configuration' class. De XAML DataBinding abonneert zich dan automatisch op dit event (PropertyChanged) en zal veranderingen direct doorvoeren op de GUI.

Het lijkt erop dat je nogal wat kennis mist van WPF. Aangezien XAML en databinding ook worden gebruikt in Silverlight en Windows Phone is het misschien geen slecht idee om een boek als 'Pro WPF' aan te schaffen. WPF is heel erg krachtig en het is jammer als maar een klein deel gebruikt zal worden.

[BM]

Of een NameChanged event, dat wil ook werken, maar is lang zo flexibel niet dat INotifyPropertyChanged

[Niemand_Anders]

Ik ga er vanuit dat Configuration meer properties zal bevatten dan alleen een naam. Was trouwens ook niet helemaal zeker of NameChanged standaard WPF was of een onderdeel van Caliburn..

[Mnstrspeed]

'Configuration' is maar een voorbeeld om niet een heel stuk code hier buiten context neer te hoeven gooien En inderdaad, ik heb nog niet veel met WPF gedaan; ik werk momenteel aan een hobby project waar ik nu een (simpele) GUI aan wil hangen en om WinForms er nou weer bij te pakken leek me ook zowat...

Ik heb INotifyPropertyChanged op Configuration geimplementeerd, maar niemand abboneert zich erop (PropertyChanged event is altijd null):

C#:

public class Configuration : INotifyPropertyChanged
{
    private string name; 
    public string Name 
    { 
        set  
        {  
            this.name = value;
            this.OnPropertyChanged("Name"); 
        } 
        get { return this.name; } 
    }

    public event PropertyChangedEventHandler PropertyChanged;

    protected void OnPropertyChanged(string propertyName)
    {
        if (this.PropertyChanged != null) // altijd null
        {
            this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
        }
    }
}

Mis ik toevallig een speciaal vlaggetje voor mijn DependencyProperty om 'm automagisch te laten abonneren?

[Snake]

Bind iets wel op Configuration.Name?

[Mnstrspeed]

C#:

public partial class MainWindow : Window
{
    public MainWindow()
    {
        InitializeComponent();
        myControl.Configuration = new Configuration() { Name = "Foo" };
    }

    private void Button_Click(object sender, RoutedEventArgs e)
    {
        myControl.Configuration.Name = "Bar";
    }
}

[Snake]

Ik bedoel in XAML

[Mnstrspeed]

In m'n MainWindow.xaml defineer ik alleen de control:

XML:

<Window x:Class="DependencyPropertyTest.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:local="clr-namespace:DependencyPropertyTest"
        Title="MainWindow" Height="350" Width="525">
    <StackPanel Orientation="Vertical">
        <local:MyControl x:Name="myControl" Width="200" Height="200" />
        <Button Content="Don't click me" Click="Button_Click" />
    </StackPanel>
</Window>

[Snake]

En in de MyControl? Hoe ziet daar de XAML er van uit?

[Mnstrspeed]

Die heeft geen XAML: ik render handmatig door OnRender te overriden. Reden hiervoor is, dat in mijn eigenlijke project de control te gecompliceerd is om helemaal in XAML te maken (denk aan een grafiekje of iets in die richting).