1. Diese Seite verwendet Cookies. Wenn du dich weiterhin auf dieser Seite aufhältst, akzeptierst du unseren Einsatz von Cookies. Weitere Informationen

[c#] Binding Basics - Object in Listview/Gridview

Dieses Thema im Forum ".NET WPF & Silverlight" wurde erstellt von chmee, 26. August 2014.

  1. chmee

    chmee verstaubtes inventar Premium-User

    Bis Dato hab ich die Objekt-Daten in der Gridview autark per Items.Add() in die Gridview eingetragen (sourcecode ~Zeilen 268+). Nun wird es Zeit, das Eine (List<Object>) an das Andere (Listview mit Gridview) zu binden, weil ich weitere Dinge wie zB Entfernen oder Markieren zum Konvertieren in der Listview zulassen will. Langer Rede kurzer Sinn: Mir will das Binden nur so halb gelingen.

    Das Object sieht so aus (verkürzt, hier komplett):
    Code (Text):
    1. public class rawList : ObservableCollection<raw>
    2.   {
    3.   }
    4.  
    5. public class raw
    6. {
    7.   public data data { get; set; }
    8.   public List<Blocks.rawBlock> RAWBlocks { get; set; }
    9.   public List<Blocks.mlvBlock> VIDFBlocks { get; set; }
    10.   public List<Blocks.mlvBlock> AUDFBlocks { get; set; }
    11. }
    12. public class data
    13. {
    14.   public metadata metaData { get; set; }
    15.   public audiodata audioData { get; set; }
    16.   public filedata fileData { get; set; }
    17. }
    18. public class metadata
    19. {
    20.    public string fpsString { get; set; }
    21.    public int whiteBalance { get; set; }
    22.    public bool isMLV { get; set; }
    23. }
    24. public class audiodata
    25. {
    26.     public bool hasAudio { get; set; }
    27.     public int audioSamplingRate { get; set; }
    28.     public int audioChannels { get; set; }
    29. }
    30. public class filedata
    31. {
    32.    public bool convertIt { get; set; }
    33.    public string fileNameOnly { get; set; }
    34. }
    Wie Ihr seht, Objekt mit Objekten drin, in eine Liste gefüllt. Ich nutze im Hauptcode eine List<raw>, die ich als Observable<raw> angelegt habe. OneWay funktionierts soweit, aber

    (1) Probleme macht mir ein boolean (data.filedata.convertIt), dass ich als Checkbox zeigen möchte und natürlich auch TwoWay im Object ändern.

    (2) Abgesehen von anderen booleans, die nur OneWay sind, aber optimalerweise nicht als string dargestellt werden sollen, sondern als SpecialChars (Kreuz und Check), das klingt nach nem Template.

    Die XAML sieht momentan so aus (verkürzt):
    Code (Text):
    1. <Window x:Class="raw2cdng_v2.MainWindow"
    2.   xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    3.   xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    4.   xmlns:local="clr-namespace:raw2cdng_v2"
    5.   xmlns:sys="clr-namespace:System;assembly=mscorlib"
    6.   Title="raw2cdng"
    7.   ResizeMode="NoResize"
    8.   WindowStyle="None"
    9.   mc:Ignorable="d"
    10.   xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    11.   xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    12.   Height="556" Width="917"
    13.   MaxWidth="920" MaxHeight="556" SizeToContent="WidthAndHeight"
    14.   BorderBrush="#FFC8C8C8"
    15.   HorizontalAlignment="Left" VerticalAlignment="Top"
    16.   BorderThickness="1"
    17.   MouseLeftButtonDown="Window_MouseLeftButtonDown"
    18.   Icon="/raw2cdng_v2;component/appicon.ico">
    19.  
    20.   <Window.Resources>
    21.  
    22.   <ObjectDataProvider x:Key="rawFilesList" ObjectType="{x:Type local:rawList}" />
    23.  
    24. <Style x:Key="chmeeListview" TargetType="{x:Type ListViewItem}">
    25.   <Style.Resources>
    26.   <SolidColorBrush x:Key="{x:Static SystemColors.HighlightBrushKey}" Color="White" />
    27.   <SolidColorBrush x:Key="{x:Static SystemColors.ControlBrushKey}" Color="White" />
    28.   <SolidColorBrush x:Key="{x:Static SystemColors.HighlightTextBrushKey}" Color="Black" />
    29.   <SolidColorBrush x:Key="{x:Static SystemColors.ControlTextBrushKey}" Color="Black" />
    30.   </Style.Resources>
    31.   <Setter Property="Focusable" Value="False" />
    32.   </Style>
    33.   </Window.Resources>
    Das also der "obere" Teil. Hier die Listview.
    Code (Text):
    1. <Grid Width="894" HorizontalAlignment="Left" VerticalAlignment="Top" Height="515">
    2.   <ListView ItemsSource="{Binding}" Height="400" HorizontalAlignment="Left" Margin="8,71,0,0" Name="_batchList" VerticalAlignment="Top" Width="550" Drop="batchList_Drop" AllowDrop="True" PreviewMouseLeftButtonUp="batchList_Click" SelectionMode="Extended" IsTextSearchEnabled="False" HorizontalContentAlignment="Center" DataContext="Resource_of_rawFiles">
    3.   <ListView.View>
    4.   <GridView>
    5.   <GridViewColumn Header="do" Width="22">
    6.   <GridViewColumn.CellTemplate>
    7.   <DataTemplate>
    8.   <CheckBox Margin="-4,0,-4,0" IsChecked="{Binding Path=data.filedata.convertIt,Mode=TwoWay}" Checked="convert_Checked" Unchecked="convert_Unchecked" DataContext="{Binding data.filedata.convertIt}"/>
    9.   </DataTemplate>
    10.   </GridViewColumn.CellTemplate>
    11.   </GridViewColumn>
    12.   <GridViewColumn Header="type" Width="36" DisplayMemberBinding="{Binding Path=data.metaData.isMLV}" />
    13.   <GridViewColumn Header="filename" Width="120" DisplayMemberBinding="{Binding Path=data.fileData.fileNameOnly}"/>
    14.   <GridViewColumn Header="fps" Width="50" DisplayMemberBinding="{Binding Path=data.metaData.fpsString}"/>
    15.   <GridViewColumn Header="audio" Width="36" DisplayMemberBinding="{Binding Path=data.metaData.hasAudio}"/>
    16.   </GridView>
    17.   </ListView.View>
    18.   </ListView>
    19. </Grid>
    Ich bin Durcheinander :D
    Databinding in XAML, ItemsSource oder DataContext?
    Wie packe ich die booleans in die reflektierte Checkbox? (convertIt)
    Wie ändere ich boolean true/false in andere Chars (isMLV als RAW oder MLV)?

    Hier noch Exzerpte aus dem MainCode:
    Code (Text):
    1. public rawList rawFiles = new rawList();
    2.  
    3.   // daten auslesen, Object füllen
    4.   // und dann aus nem Subthread in die Liste packen
    5.   this.Dispatcher.Invoke((Action)(() =>
    6.   {
    7.   rawFiles.Add(importRaw);
    8.   }));
    Nun, ich stecke einfach fest, weil ich das Konzept des Bindings scheinbar noch nicht kapiert hab. Danke für all die Hilfe, die da kommen mag :)

    mfg chmee
     
    Zuletzt bearbeitet: 26. August 2014
  2. chmee

    chmee verstaubtes inventar Premium-User

    ich sehe die Aufrufe, aber fehlende Antworten. Ich probiers nochmal mit weniger Text:

    * OneWay, also reine Ausgabe der Objektdaten funktioniert, wenn auch nur als .toString().

    * Gegeben ist eine Liste von Objekt raw (welches auch aus Objekten besteht), die dynamisch erstellt wird.
    * jene soll standesgemäß in einer Gridview dargestellt werden, an einigen Stellen mit einer Rückkopplung auf das Objekt (zB read/write boolean)
    * Schönheitskorrekturen bei Objekten, die als .toString() wenig Sinn machen (zB boolean), zB in Form von Checkbox oder Ersatzzeichen.

    Ich habe schon recht viele Sachen im Netz gelesen, aber das Verständnis fehlt, wann ItemsSource, wann Datacontext (das Gleiche?), wie (anders) verhält sich ein Observable ggüber dem normalen Objekt, ist ein INotify nötig oder ist es inherited in Observable?

    mfg chmee
     
  3. rd4eva

    rd4eva Erfahrenes Mitglied

    Etwas verspätet aber lass mich mal versuchen etwas Licht ins Dunkel zu bringen.

    Datacontext und ItemsSource haben eigentlich überhaupt nichts miteinander zu tun.

    Mit Datacontext bestimmst du welches Objekt (genauer eigentlich Objekt-Typ) die Eigenschaften für deine Bindings bereit stellt.
    Dein visueller Layer (xaml) ist völlig unabhängig von deinem Daten Layer und nur dafür da die Daten auf eine Benutzerfreundliche Art darzustellen.
    Damit dieser visuelle Layer jetzt weiss worauf sich deine Bindings beziehen musst du den Datacontext setzen.
    Der Datacontext wird dabei übrigens nach unten vererbt (solange er nicht überschrieben wird logischerweise).

    Angenommen ich habe nun also folgende MainWindow.xaml
    Code (XML):
    1. <Window x:Class="WpftestApplication1.MainWindow"
    2.  xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    3.  xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    4.  Title="MainWindow"
    5.  mc:Ignorable="d"
    6.  xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    7.  xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    8.  d:DesignHeight="350" d:DesignWidth="525"
    9.  x:Name="MainWin"
    10.  DataContext="{Binding RelativeSource={RelativeSource Self}}"
    11.  >
    12.  
    13.   <StackPanel Orientation="Vertical">
    14.  
    15.   <TextBlock Text="{Binding MyClassInstance}" />
    16.  
    17.   </StackPanel>
    18.  
    19. </Window>
    Und die dazugehörige Code-Behind Datei (MainWindow.xaml.cs)
    Code (C#):
    1. using System.Windows;
    2.  
    3. namespace WpftestApplication1
    4. {
    5.   public partial class MainWindow : Window
    6.   {
    7.      public MainWindow()
    8.      {
    9.         InitializeComponent();  
    10.      }
    11.  
    12.      private MyClass myClassInstance = new MyClass();
    13.      public MyClass MyClassInstance
    14.      {
    15.         get { return myClassInstance; }
    16.         set { myClassInstance = value; }
    17.      }
    18.   }
    19.  
    20.  
    21.   public class MyClass
    22.   {
    23.      private int myIntProperty = 123;
    24.      public int MyIntProperty
    25.      {
    26.         get { return myIntProperty; }
    27.         set { myIntProperty = value; }
    28.      }
    29.   }
    30.  
    31. }
    Durch DataContext="{Binding RelativeSource={RelativeSource Self}}" im xaml setze ich den DataContext auf den Typen MainWindow (MainWindow.xaml.cs).
    Dieser Datacontext wird nach unten vererbt. Also haben StackPanel und TextBlock den gleichen DataContext.
    Alle Bindings beziehen sich nun als auf das Objekt (bzw. den Typen) MainWindow.
    Das TextBlock Binding {Binding MyClassInstance} ist also nicht TextBlock.MyClassInstance sonder TextBlock.DataContext.MyClassInstance. Durch den gesetzten DataContext wird das aufgelöst nach MainWindow.MyClassInstance.
    Wenn ich nun die Eigenschaft MyIntProperty in meinem TextBlock anzeigen möcht kann ich folgendes machen:
    Code (XML):
    1. <TextBlock Text="{Binding MyClassInstance.MyIntProperty}" />
    Falls MyClass jetzt aber mehrere Eigenschaften hat welche ich anzeigen lassen will und ich keine Lust hab jedes mal MyClassInstance. in meinen Bindings zu schreiben könnte ich aber auch folgendes machen:
    Code (XML):
    1. <StackPanel Orientation="Vertical" DataContext="{Binding MyClassInstance}">
    2.  
    3.   <TextBlock Text="{Binding MyIntProperty}" />
    4.  
    5.   <TextBlock Text="{Binding MyStringProperty}" />
    6.  
    7.   </StackPanel>
    MyClass sieht jetzt logischerweise so aus
    Code (C#):
    1. public class MyClass
    2.   {
    3.   private int myIntProperty = 123;
    4.   public int MyIntProperty
    5.   {
    6.   get { return myIntProperty; }
    7.   set { myIntProperty = value; }
    8.   }
    9.  
    10.   private string myStringProperty = "Im a string";
    11.   public string MyStringProperty
    12.   {
    13.   get { return myStringProperty; }
    14.   set { myStringProperty = value; }
    15.   }
    16.  
    17.   }

    Nun zur ItemsSource.
    Mit der ItemsSource gebe ich einer ItemsControl (oder abgeleitet) ein IENumerable.
    Alle im IENumerable enthaltenen Objekte werden von der ItemsControl verwendet um den Inhalt zu generieren.

    MainWindow.xaml.cs
    Code (XML):
    1. <Window x:Class="WpftestApplication1.MainWindow"
    2.  xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    3.  xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    4.  Title="MainWindow"
    5.  mc:Ignorable="d"
    6.  xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    7.  xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    8.  d:DesignHeight="350" d:DesignWidth="525"
    9.  x:Name="MainWin"
    10.  DataContext="{Binding RelativeSource={RelativeSource Self}}"
    11.  >
    12.  
    13.   <Grid>
    14.  
    15.   <DataGrid ItemsSource="{Binding MyClassList}">
    16.  
    17.   </DataGrid>
    18.  
    19.   </Grid>
    20.  
    21. </Window>
    MainWindow.xaml.cs
    Code (C#):
    1. using System.Windows;
    2. using System.Linq;
    3. using System.Collections.Generic;
    4.  
    5. namespace WpftestApplication1
    6. {
    7.   public partial class MainWindow : Window
    8.   {
    9.   public MainWindow()
    10.   {
    11.   this.initializeMyClassList();
    12.   InitializeComponent();  
    13.   }
    14.  
    15.   private void initializeMyClassList()
    16.   {
    17.   List<MyClass> lst = new List<MyClass>()
    18.   {
    19.   new MyClass(){ MyIntProperty = 1, MyStringProperty = "myClass1", MyBoolProeprty = true},
    20.   new MyClass(){ MyIntProperty = 2, MyStringProperty = "myClass2", MyBoolProeprty = false},
    21.   new MyClass(){ MyIntProperty = 3, MyStringProperty = "myClass3", MyBoolProeprty = true}
    22.   };
    23.  
    24.   this.myClassList = lst;
    25.   }
    26.  
    27.   private IEnumerable<MyClass> myClassList;
    28.   public IEnumerable<MyClass> MyClassList
    29.   {
    30.   get { return myClassList; }
    31.   set { myClassList = value; }
    32.   }
    33.  
    34.  
    35.   }
    36.  
    37.  
    38.   public class MyClass
    39.   {
    40.   private int myIntProperty;
    41.   public int MyIntProperty
    42.   {
    43.   get { return myIntProperty; }
    44.   set { myIntProperty = value; }
    45.   }
    46.  
    47.   private string myStringProperty;
    48.   public string MyStringProperty
    49.   {
    50.   get { return myStringProperty; }
    51.   set { myStringProperty = value; }
    52.   }
    53.  
    54.   private bool myBoolProperty;
    55.   public bool MyBoolProeprty
    56.   {
    57.   get { return myBoolProperty; }
    58.   set { myBoolProperty = value; }
    59.   }
    60.  
    61.  
    62.   }
    63.  
    64. }
    Das ItemsSource Binding des DataGrid bewirkt jetzt vereinfacht in PseudoCode ausgedrückt also folgendes
    Code (Text):
    1. foreach object o in this.ItemsSource
    2. {
    3.   DataGridRow row = new DataGridRow
    4.   row.DataContext = o
    5.   foreach Property p in row.DataContext.Properties
    6.   {
    7.      DataGridCell cell = new DataGridCell
    8.      cell.Content = p
    9.      row.Cells.Add(cell)
    10.   }
    11.   this.Rows.Add(row)
    12. }
    Wie gesagt...stark vereinfacht.... aber das Prinzip von ItemsSource sollte jetzt klar sein.
    Anhand des ItemTemplate/ItemTemplateSelector oder generell DataTemplates wird dann entschieden wie genau der Inhalt der Zelle dargestellt werden soll.

    Jetzt zum Observable.
    Wenn du in WPF ein Binding auf eine Eigenschaft erstellst dann versucht WPF den INotify (INotifyPropertyChanged, INotifyCollectionCanged etc.) Events der DataContext Klasse zu lauschen damit Änderungen im Daten Layer auch im Visuellen Layer übernommen werden.
    Das bedeutet jetzt folgendes (siehe nochmal oberes Beispiel mit dem StackPanel/TextBlock)
    Ändere ich zur Laufzeit den Wert von MyIntProperty von 123 auf 456 wird sich am Inhalt des TextBlock überhaupt nichts ändern weil MyClass nicht die nötigen INotify Events bereitstellt damit WPF merkt das sich überhaupt was geändert hat.
    Änder ich MyClass jetzt aber ab:
    Code (C#):
    1. public class MyClass : INotifyPropertyChanged
    2.   {
    3.   private int myIntProperty;
    4.   public int MyIntProperty
    5.   {
    6.   get { return myIntProperty; }
    7.   set
    8.   {
    9.   if (value == myIntProperty)
    10.   return;
    11.  
    12.   myIntProperty = value;
    13.   this.OnNotifyPropertyChanged("MyIntProperty");
    14.   }
    15.   }
    16.  
    17.   private string myStringProperty;
    18.   public string MyStringProperty
    19.   {
    20.   get { return myStringProperty; }
    21.   set { myStringProperty = value; }
    22.   }
    23.  
    24.   private bool myBoolProperty;
    25.   public bool MyBoolProeprty
    26.   {
    27.   get { return myBoolProperty; }
    28.   set { myBoolProperty = value; }
    29.   }
    30.  
    31.   public event PropertyChangedEventHandler PropertyChanged;
    32.  
    33.   private void OnNotifyPropertyChanged(string property)
    34.   {
    35.   if (this.PropertyChanged != null)
    36.   this.PropertyChanged(this, new PropertyChangedEventArgs(property));
    37.   }
    38.   }
    Wenn ich jetzt zur Laufzeit den Wert von MyIntProperty ändere wird das PropertyChanged event ausgelöst.
    WPF lauscht diesem Event und wird den neuen Wert abfragen und im TextBlock anzeigen.
    Das gleiche gilt logischerweise für ObservableCollections.
    Wenn du willst das Änderungen an der Collection (child add, remove etc.) im xaml (z.b. im DataGrid)
    reflektiert werden musst du an eine ObservableCollection binden.
    Aber Achtung: ObservableCollection informiert nur über Änderungen an der Collection und nicht über Änderungen der objekte in der Collection.
    Ändert sich also eine Eigenschaft eines Objektes in einer ObservableCollection ist ihr das völlig egal.
    Ändert sich die Collection an sich wird das INotifyCollectionChanged Event ausgelöst.

    Damit die Werte in einem TwoWay Binding vom xaml in deinen DatenLayer übernommen werden sind übrigens keine INotify Events nötig. Das geht immer. Einzige voraussetzung ist wie gesagt ein TwoWay oder OneWayToSource Binding.
     
Die Seite wird geladen...