Wie aktualisiert man den Wert einer Zeile eines WPF DataGrid von IronPython?

Question

Ich habe eine einfache WPF-Anwendung. Hier ist der WPF-Code

<Window 
     xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" 
     xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" 
     Title="WpfApplication3" Height="300" Width="300"> 
     <Grid> 
     <DataGrid x:Name="dg" Margin="0" Height="149" Width="136"> 
      <DataGrid.Columns> 
       <DataGridTextColumn Binding="{Binding value}" ClipboardContentBinding="{x:Null}"/> 
      </DataGrid.Columns> 
     </DataGrid> 
     <Button x:Name="button" Content="Button" HorizontalAlignment="Left" Margin="109,230,0,0" VerticalAlignment="Top" Width="75" Click="button_Click"/> 
    </Grid> 
</Window> 

und hier wird der Python-Code:

import wpf 

from System.Windows import Application, Window, MessageBox 
from time import sleep 

class MyWindow(Window): 
    def __init__(self): 
     self.value = Value() 
     wpf.LoadComponent(self, 'WpfApplication3.xaml') 

     self.dg.Items.Add(self.value) 

    def button_Click(self, sender, e): 
     self.value.increment() 
     MessageBox.Show(str(self.value.value)) 

class Value: 
    def __init__(self): 
     self.value = 1 

    def increment(self): 
     self.value += 1 

if __name__ == '__main__': 
    Application().Run(MyWindow()) 

Das Verhalten, das ich erwarte, ist, dass Schaltfläche auf klicken, wird der Wert im Datagrid aktualisieren soll. Wenn ich die Anwendung starte, wird ein Eintrag in der Spalte mit dem Wert 1 platziert, aber beim Klicken auf die Schaltfläche wird er nicht aktualisiert. Die MessageBox bestätigt, dass der Wert aktualisiert wird, aber das DataGrid erkennt nicht, dass der Wert aktualisiert wird. Wo gehe ich falsch?

Answer 1

Ok, ich bin nicht vertraut mit Python mich so korrigieren, wenn ich falsch liege, aber ich denke, dass Ihr Code wie so etwas wie dies in C# aussehen:

public partial class MainWindow : Window 
{ 
    public Value value; 
    public MainWindow() 
    { 
     InitializeComponent(); 
     value = new Value(); 
     dg.Items.Add(value); 
    } 
    private void Button_Click(object sender, RoutedEventArgs e) 
    { 
     value.Increament(); 
     MessageBox.Show(Convert.ToString(value.value)); 
    } 
} 

public class Value 
{ 
    public int value; 
    public Value() 
    { 
     value = 1; 
    } 
    public void Increament() 
    { 
     value++; 
    } 
} 

Jetzt für Binding="{Binding value}" in der XAML zu arbeiten , zwei Änderungen müssen vorgenommen werden:

(1) Die DataContext muss eingestellt werden. Dies kann leicht wie folgt erfolgen:

import wpf 

from System.Windows import Application, Window, MessageBox 
from time import sleep 

class MyWindow(Window): 
    def __init__(self): 
     self.value = Value() 
     wpf.LoadComponent(self, 'WpfApplication3.xamll') 

     self.dg.DataContext = self 
     self.dg.Items.Add(self.value) 

    def button_Click(self, sender, e): 
     self.value.increment() 
     MessageBox.Show(str(self.value.value)) 

(2) Die Value Klasse INotifyPropertyChanged implementieren müssen. Daher ist die folgende die korrekte Implementierung dieser Klasse in C#:

public class Value : INotifyPropertyChanged 
{ 
    public event PropertyChangedEventHandler PropertyChanged; 
    void OnPropertyChanged(string propertyName) 
    { 
     if (PropertyChanged != null) 
      PropertyChanged(this, new PropertyChangedEventArgs(propertyName)); 
    } 

    int _value; 
    public int value 
    { 
     get 
     { 
      return _value; 
     } 
     set 
     { 
      _value = value; OnPropertyChanged("value"); 
     } 
    } 
    public Value() 
    { 
     value = 1; 
    } 
    public void Increament() 
    { 
     value++; 
    } 
} 

Von dem, was ich verstehe, durch diese Blog lesen (was, da ich Sie nicht keine Python wissen, sollte es auf jeden Fall lesen) Es ist möglich, INotifyPropertyChanged zu implementieren in IronPython. Um dies zu erreichen, sollten Sie Ihre Value Klasse implementieren INotifyPropertyChanged:

from System.ComponentModel import INotifyPropertyChanged 
from System.ComponentModel import PropertyChangedEventArgs 

class Value(INotifyPropertyChanged): 
    def __init__(self): 
     self.propertyChangedHandlers = [] 
     self.value= 1 

    def RaisePropertyChanged(self, propertyName): 
     args = PropertyChangedEventArgs(propertyName) 
     for handler in self.propertyChangedHandlers: 
      handler(self, args) 

    def add_PropertyChanged(self, handler): 
     self.propertyChangedHandlers.append(handler) 

    def remove_PropertyChanged(self, handler): 
     self.propertyChangedHandlers.remove(handler) 


    def Increament(self): 
     self.value += 1 
     self.RaisePropertyChanged("value")