INotifyPropertyChanged w podklasie

Question

Chcę powiązać TextBox w oknie z właściwością zawartą w klasie, która jest zmienną viewmodel i upewnić się, że właściwość PropertyChanged INotifyPropertyChanged rozprzestrzenia się z klasy do rodzica.

Pozwól mi zilustrować na przykładzie:

(Window DataContext jest ustawiony do instancji ViewModel)

public class ViewModel { 
    private OtherClass classInstance = new OtherClass(); 

    public int Attribute { 
     get { return classInstance.Attribute; } 
    } 
} 

public class OtherClass : INotifyPropertyChanged { 
    private int _attribute; 
    public int Attribute { 
     get { return _attribute; } 
     set { 
      _attribute = value; 
      PropertyChanged("Attribute"); 
     } 
    } 
    ... 
} 

Problemem w tym przypadku jest to, że podczas zmiany atrybutów a bound Textbox nie aktualizuje wiązania, ponieważ zakładam, że słucha zdarzenia PropertyChanged ViewModel, a nie instancji klasy OtherClass.

Jakieś pomysły, jak zaradzić tej sytuacji? Zastanawiałem się nad powiązaniem INotifyPropertyChanged Innego rodzaju z rodzica, ale musi istnieć lepszy sposób.

Answer 1

Dlaczego nie powiązać bezpośrednio z właściwością klasy zamiast z serwerem proxy?

public class ViewModel { 
    private OtherClass classInstance = new OtherClass(); 

    public OtherClass MyOtherClass { 
     get { return classInstance; } 
    } 
} 

Następnie w wiązaniu można po prostu odwołać się do własności poprzez podklasy

{Binding MyOtherClass.Attribute} 

---

Kropla martwy prosty przykład, ale to działa!

związany kod:

public partial class MainWindow : Window { 
    private readonly SomeClass _someClass = new SomeClass(); 

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

public class SomeClass: INotifyPropertyChanged {  
    private readonly SomeSubClass _mySubClass = new SomeSubClass(); 

    public SomeSubClass MySubClass { 
     get { return _mySubClass; } 
    } 

    private String _name; 
    public String Name { 
     get { return _name; } 
     set { 
     _name = value; 
     OnPropertyChanged("Name"); 
     } 
    } 

    //Property Change Stuff 
} 

public class SomeSubClass : INotifyPropertyChanged { 
    private String _name; 
    public String Name { 
     get { 
     return _name; 
     } 
     set { 
     _name = value; 
     OnPropertyChanged("Name"); 
     } 
    } 

    //Property Change Stuff 
} 

XAML:

<Window x:Class="JWC.Examples.WPF.MainWindow" 
     xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" 
     xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" 
     Title="MainWindow"> 
    <StackPanel> 
     <Label Content="Name" VerticalAlignment="Top" /> 
     <TextBox Text="{Binding Name}" /> 
     <Label Content="SubClass.Name" /> 
     <TextBox Text="{Binding MySubClass.Name}" /> 
     <Label Content="Bound to Name" /> 
     <TextBlock Text="{Binding Name}" /> 
     <Label Content="Bound to MySubClass.Name" /> 
     <TextBlock Text="{Binding MySubClass.Name}" /> 
    </StackPanel> 
</Window> 

Answer 2

myślę klasa dominująca powinna zapisać się do dziecka propertyCahnged event..something jak:

public class ViewModel 
{ 
    private OtherClass classInstance = new OtherClass(); 

    public ViewModel() 
    { 
     classInstance.PropertyChanged += NotifyChildAttributeChanged; 
    } 
    public int Attribute 
    { 
     get { return classInstance.Attribute; } 
    } 
} 

NotifyChildAttributeChanged jest w zasadzie to metoda, która słucha tylko „atrybut” własności i wystrzeliwuje powiadomienia o PropertyChanged własny ..

Oczywiście nasza klasa nadrzędna musi implementować INotifyPropertyChanged, a także wszystkie ViewModels (najlepiej) i Twój DataContext wykryje zmianę.

Answer 3

Trzeba będzie zrobić coś takiego:

public class ViewModel { 
    public ViewModel() { 
     classInstance = new OtherClass(); 
     classInstance.PropertyChanged += HandleAttributeChanged; 
    } 

    private void HandleAttributeChanged(object Sender, NotifyPropertyChangedEventArgs args) { 
     PropertyChanged("Attribute"); 
    } 
} 

nie pokazać go tutaj, ale należy również wdrożyć IDisposable i zrezygnować z imprezy PropertyChanged na dziecko, w przeciwnym razie wycieku pamięci.

Alternatywnie można wystawić classInstance jako właściwość publiczną i ustawić powiązanie na: ViewModel.classInstance. Uwaga: musi to być właściwość, a nie samo pole.

Answer 4

Aby obejść ten problem trzeba zaimplementować INotifyPropertyChanged na widoku modelu, jak również.Wystarczy dodać interfejs i wydarzenie, a reszta zajmie się sobą - nie trzeba łączyć ze sobą zdarzeń/połączeń.

Sprawdź to za pomocą refleksji, aby uzyskać nieruchomość.

http://tsells.wordpress.com/2011/02/08/using-reflection-with-wpf-and-the-inotifypropertychanged-interface/