Textboxen binden funktioniert nicht

  • WPF

Es gibt 9 Antworten in diesem Thema. Der letzte Beitrag () ist von ErfinderDesRades.

    Textboxen binden funktioniert nicht

    Hallo zusammen,

    jedes Property einer bestimmten Klasse wird nur einen Wert enthalten. Jeder Wert soll jeweils an eine Textbox gebunden sein. Und bevor ich es vergesse; die Textboxen sollen später in einem Stackpanel sitzen.
    Alle Versuche schlugen fehl.

    XAML

    Spoiler anzeigen

    XML-Quellcode

    1. <Window x:Class="MainWindow"
    2. xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    3. xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    4. xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    5. xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    6. xmlns:local="clr-namespace:Textboxen_binden"
    7. mc:Ignorable="d"
    8. Title="MainWindow" Height="290" Width="800">
    9. <Grid>
    10. <DataGrid ItemsSource="{Binding Dings_Coll}" Width="500" Height="70" HorizontalAlignment="Center" VerticalAlignment="Top" Margin="20"/>
    11. <TextBox Text="{Binding Eins}" Width="500" Height="25"/>
    13. </Grid>
    14. </Window>


    Code:

    Spoiler anzeigen

    VB.NET-Quellcode

    1. Imports System.Collections.ObjectModel
    2. Imports System.Runtime.CompilerServices
    3. Imports System.ComponentModel
    5. Class MainWindow
    6. Implements INotifyPropertyChanged 'benachrichtigt die Oberfläche (View) bei Änderung eines Propertys (Datendings)
    8. Public Event PropertyChanged As PropertyChangedEventHandler Implements INotifyPropertyChanged.PropertyChanged
    10. Private Sub raisepropertychanged(<CallerMemberName> Optional ByVal prop As String = "") 'wird bei Änderung in den Propertys aufgerufen
    11. RaiseEvent PropertyChanged(Me, New PropertyChangedEventArgs(prop))
    12. End Sub
    14. Private Sub MainWindow_Loaded(sender As Object, e As RoutedEventArgs) Handles Me.Loaded
    15. Dings_Coll = New ObservableCollection(Of Stackpanel_Klasse)
    16. Dings_Coll.Add(New Stackpanel_Klasse("WFAFAWWA"))
    18. Me.DataContext = Me
    20. End Sub
    22. Private _Dings_Coll As ObservableCollection(Of Stackpanel_Klasse)
    23. Public Property Dings_Coll() As ObservableCollection(Of Stackpanel_Klasse)
    24. Get
    25. Return _Dings_Coll
    26. End Get
    27. Set(ByVal value As ObservableCollection(Of Stackpanel_Klasse))
    28. _Dings_Coll = value
    29. End Set
    30. End Property
    32. End Class


    Klasse

    Spoiler anzeigen

    VB.NET-Quellcode

    1. Imports System.ComponentModel
    2. Imports System.Runtime.CompilerServices
    4. 'Namespace Stackpanel_ns
    5. Public Class Stackpanel_Klasse
    6. Implements INotifyPropertyChanged 'benachrichtigt die Oberfläche (View) bei Änderung eines Propertys
    7. Public Event PropertyChanged As PropertyChangedEventHandler Implements INotifyPropertyChanged.PropertyChanged 'wird automatisch bei der Implementierung des INotifyPropertyChanged eingefügt
    9. Private Sub raisepropertychanged(<CallerMemberName> Optional ByVal prop As String = "") 'wird bei Änderung in den Propertys aufgerufen
    10. RaiseEvent PropertyChanged(Me, New PropertyChangedEventArgs(prop))
    11. End Sub
    13. Public Sub New(eins As String)
    14. Me.Eins = eins
    15. End Sub
    17. Private _eins As String
    18. Public Property Eins() As String
    19. Get
    20. Return _eins
    21. End Get
    22. Set(ByVal value As String)
    23. _eins = value
    24. raisepropertychanged()
    25. End Set
    26. End Property
    28. Private _zwei As String
    29. Public Property Zwei() As String
    30. Get
    31. Return _zwei
    32. End Get
    33. Set(ByVal value As String)
    34. _zwei = value
    35. raisepropertychanged()
    36. End Set
    37. End Property
    39. Private _drei As String
    40. Public Property Drei() As String
    41. Get
    42. Return _drei
    43. End Get
    44. Set(ByVal value As String)
    45. _drei = value
    46. raisepropertychanged()
    47. End Set
    48. End Property
    50. Private _vier As String
    51. Public Property Vier() As String
    52. Get
    53. Return _vier
    54. End Get
    55. Set(ByVal value As String)
    56. _vier = value
    57. raisepropertychanged()
    58. End Set
    59. End Property
    60. End Class
    61. 'End Namespace


    Der hier gezeigte Code ist nur der aktuelle Versuch; einer von vielen... Kann ja nicht alle Varianten posten.
    Ich weiß nicht einmal, ob der Ansatz über die Collection korrekt ist. Eigentlich ist eine Collection ja Quatsch, wenn ich nur einen Eintrag pro Property hab.
    Im DataGrid lässt sich der Wert anzeigen. Über die Bindung an Itemssource werden die Werte in den Spalten angezeigt. (das Grid dient nur Testzwecken, und soll im richtigen Projekt natürlich nicht zusätzlich drin sein)

    Im Netz findet man natürlich auch Lösungne, aber irgendwie nie das Passende...

    Kann mir hier jemand helfen?

    Gruß

    eddi

    Hallo

    eichseinet schrieb:

    jedes Property einer bestimmten Klasse wird nur einen Wert enthalten. Jeder Wert soll jeweils an eine Textbox gebunden sein. Und bevor ich es vergesse; die Textboxen sollen später in einem Stackpanel sitzen.

    Dann sehe ich hier aber eigendlich zwei auflistungen.

    1x die Liste von StackPanelKlasse
    1x die Liste IN der StackPanelKlasse

    Denn ich würde wenn ich die Properties (One, Two, ...) in einem WrapPanel rendern möchte diese als Auflistung implementieren. Also in deiner Klasse einfach nur eine ObservableCollection(Of String)
    Zumindest wenn die Anzahl dieser One, Two Properties flexibel sein soll und ich denke das dies der Fall ich wenn die Textboxen dazu später in einem WrapPanel sein sollen.

    Ansonsten beschreibe doch am besten was genau du erreichen willst, vieleicht gibt es sogar nochh eine bessere Möglichkeit.

    Grüße
    Sascha
    If _work = worktype.hard Then Me.Drink(Coffee)
    Seht euch auch meine Tutorialreihe <WPF Lernen/> an oder abonniert meinen YouTube Kanal.

    ## Bitte markiere einen Thread als "Erledigt" wenn deine Frage beantwortet wurde. ##

    Die Grundidee ist es 3 Stackpanel nebeneinander zu platzieren, die je mehrere Textboxen enthalten.
    1. Reihe enthält den Namen des Wertes
    2. Reihe enthält den Wert
    3. Reihe enthält eine Info / Beschreibung zu dem Wert

    Der Wert und die Info sollen änderbar sein. Das Ganz soll als XML gespeichert und beim Laden dees Projekts wieder gelesen werden. Speichern und laden in die XML hab in einem anderen Test grundsätzlich schon gemacht. Hier liegen die Werte aber im DataGrid. Im Grunde wäre mit auch ein Grid recht für die Aufgabe, aber dann wären ja jede Menge Spalte für jedes Property nebeneinander.

    P.S. Ganz vergessen: Ein weiteres Ziel war es, die Daten dann im Code möglichst einfach anzusprechen. Aktuell könnte man sie ja über Dings_Coll(0).Eins abfragen. Ich dachte so könnte man die Einstellwerte des Prrjktes schön abrufen, ohne sie extram auf eigene Varablen oder Propertys umzukopieren. Auch hätte man eine Auswahl der Werte mit Intellisense.

    Gruß

    eddi

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „eichseinet“ ()

    eichseinet schrieb:

    3 Stackpanel nebeneinander zu platzieren

    Dafür brauchst du aber nur 1 Stackpanel!!

    eichseinet schrieb:

    Das Ganz soll als XML gespeichert und beim Laden dees Projekts wieder gelesen werden. Speichern und laden in die XML hab in einem anderen Test grundsätzlich schon gemacht.

    Soweit gut, das bedeutet du hast ein Model? Kann ich das sehen, dann weis ich ja die Struktur der Daten.

    Wenn ich das jetzt nicht falsch verstehe brauchst du ja nur ein Listbox in welcher im ItemTemplate 3 Testbox drinnen sind. Fertich.
    Guck mal hier

    Grüße
    Sascha
    If _work = worktype.hard Then Me.Drink(Coffee)
    Seht euch auch meine Tutorialreihe <WPF Lernen/> an oder abonniert meinen YouTube Kanal.

    ## Bitte markiere einen Thread als "Erledigt" wenn deine Frage beantwortet wurde. ##

    eichseinet schrieb:

    Test grundsätzlich schon gemacht. Hier liegen die Werte aber im DataGrid. Im Grunde wäre mit auch ein Grid recht für die Aufgabe, aber dann wären ja jede Menge Spalte für jedes Property nebeneinander.
    Wenn du die Datensätze als Tabelle darstellen willst, ist DataGrid die richtige Wahl.
    Wenn bestimmte Properties nicht anzuzeigen sind, dann gestallte das DG so, dass sie nicht angezeigt werden.
    Stelle DG.AutoGenerateColumns=False ein, und füge diejenigen Spalten, die du anzeigen willst, hinzu.
    Geht alles ganz einfach im Designer (wenn du den DataContext des Windows auf ein brauchbares Viewmodel gesetzt hast)

    Musste das Projekt leider ne Weile verlassen, daher hat's jetzt länger gedauert.
    Wenn ich Sascha richtig verstanden habe meint er ungefährt das hier.

    XAML

    Spoiler anzeigen

    XML-Quellcode

    1. <ListBox ItemsSource="{Binding Dings_Coll}">
    2. <ListBox.ItemTemplate>
    3. <DataTemplate>
    4. <StackPanel Orientation="Horizontal" >
    5. <TextBox Text="{Binding Eins}" Width="200"/>
    6. <TextBox Text="{Binding Zwei}" Width="200"/>
    7. <TextBox Text="{Binding Drei}" Width="200"/>
    8. </StackPanel>
    9. </DataTemplate>
    10. </ListBox.ItemTemplate>
    11. </ListBox>


    Code

    Spoiler anzeigen

    VB.NET-Quellcode

    1. Private Sub MainWindow_Loaded(sender As Object, e As RoutedEventArgs) Handles Me.Loaded
    2. Dings_Coll = New ObservableCollection(Of Stackpanel_Klasse)
    3. Dings_Coll.Add(New Stackpanel_Klasse("Ordner DVB Dream", "C:\Temp", "Beschreibung dazu, falls nötig"))
    4. Dings_Coll.Add(New Stackpanel_Klasse("Ordner Aufnahmen", "C:\Aufnahmen", "Beschreibung dazu, falls nötig"))
    5. Dings_Coll.Add(New Stackpanel_Klasse("Vorlaufzeit", "5", "Angabe in min."))
    6. Dings_Coll.Add(New Stackpanel_Klasse("Nachlaufzeit", "5", "Angabe in min."))
    8. Me.DataContext = Me
    10. End Sub
    12. Private _Dings_Coll As ObservableCollection(Of Stackpanel_Klasse)
    13. Public Property Dings_Coll() As ObservableCollection(Of Stackpanel_Klasse)
    14. Get
    15. Return _Dings_Coll
    16. End Get
    17. Set(ByVal value As ObservableCollection(Of Stackpanel_Klasse))
    18. _Dings_Coll = value
    19. End Set
    20. End Property


    Wenn ich die Collection auch eigentlich in die Klasse setzten sollte, aber es soll mal gezeigt werden wie's aussieht.
    Das ist jetzt eigentlich die Methode, von der ich weg wollte. Das könnte man ja so auch einfach in ein DataGrid packen. Dann muss man aber entweder die eigenlichen Werte nochmal in eine Variable umkopieren, um sie im Code zu nutzen, oder man muss die Collection in einer Schleife durchsuche, bis der benötiggte Wert gefunden ist. Fest über einen Index will ich nicht lösen, weil es nicht mehr passt, wenn Werte eingefügt oder gelöscht werden.
    Meine Idee war es jetzt für die Werte hier im Beispiel 12 Propertys in der Klasse anzulegen. (4 "Zeilen" mit je 3 Werten) Dann im Code ein Property vom Typ der Klasse anlegen. Da könnte ich dann die eigentlichen Daten ablegen. Eine Collection kann ich als XML speichern. Hier mal der Code aus einem anderen Testprojekt:

    VB.NET-Quellcode

    1. Dim Seriendings As XmlSerializer = New XmlSerializer(GetType(ObservableCollection(Of Aufnahmen)))
    2. Dim Schreiber As IO.StreamWriter = New IO.StreamWriter("Aufnahmen.xml")
    4. Seriendings.Serialize(Schreiber, Aufnahmen_Coll)


    Theoretisch ließen sich die 12 Property nun in einem DataGrid anzeigen, aber dann alles nebeneinander. Jedes Property würde ja eine eigene Spalte bilden / belegen.
    Daher dachte ich man könnte 3 Reihen mit Textboxen nebeneinander komplett manuell in einem Stackpanel anlegen und jeder Textbox ein eigenes Property aus der Klasse zuweisen. (also alle 12 Textboxen einzeln im XAML erstellt)

    Das sah dann erst mal so aus (aber noch ohne Binding und wieder ein anderes Projekt, also andere Namen)

    Spoiler anzeigen

    XML-Quellcode

    1. <TabControl ItemsSource="{Binding Dings_View}" DataContext="Dings_View">
    2. <TabItem Header="Stackpanel">
    3. <Grid>
    4. <Grid.ColumnDefinitions>
    5. <ColumnDefinition Width="200"/>
    6. <ColumnDefinition Width="100*"/>
    7. <ColumnDefinition Width="200*"/>
    8. </Grid.ColumnDefinitions>
    9. <Grid.RowDefinitions>
    10. <RowDefinition Height="300"/>
    11. <RowDefinition Height="300*"/>
    12. </Grid.RowDefinitions>
    14. <StackPanel Grid.Column="0">
    15. <StackPanel.Resources>
    16. <Style TargetType="TextBox">
    17. <Setter Property="Padding" Value="1"/>
    18. <Setter Property="BorderBrush" Value="White"/>
    19. <Setter Property="Margin" Value="2"/>
    20. <Setter Property="IsReadOnly" Value="True"/>
    21. <Setter Property="Background" Value="Aquamarine"/>
    23. </Style>
    24. </StackPanel.Resources>
    25. <TextBox Text="Eins" />
    26. <TextBox Text="Zwei" />
    27. <TextBox Text="Drei" />
    28. <TextBox Text="Vier" />
    29. </StackPanel>
    30. <StackPanel Grid.Column="1" >
    31. <StackPanel.Resources>
    32. <Style TargetType="TextBox">
    33. <Setter Property="Padding" Value="1"/>
    34. <Setter Property="Margin" Value="2"/>
    36. </Style>
    37. </StackPanel.Resources>
    38. <TextBox Text="{Binding Eins}" Padding="1"/>
    39. <TextBox Text="Textbox ZWEI" Padding="1"/>
    40. <TextBox Text="Textbox DREI" Padding="1"/>
    41. <TextBox Text="Textbox VIER" Padding="1"/>
    42. </StackPanel>
    43. <StackPanel Grid.Column="2" >
    44. <StackPanel.Resources>
    45. <Style TargetType="TextBox">
    46. <Setter Property="Padding" Value="1"/>
    47. <Setter Property="Margin" Value="2"/>
    49. </Style>
    50. </StackPanel.Resources>
    51. <TextBox Text="Beschreibung" Padding="1"/>
    52. <TextBox Text="Beschreibung" Padding="1"/>
    53. <TextBox Text="Beschreibung" Padding="1"/>
    54. <TextBox Text="Beschreibung" Padding="1"/>
    55. </StackPanel>
    56. <Button x:Name="Tasdasf" Content="df" Click="Tasdasf_Click" Grid.Row="1"/>
    57. </Grid>


    Ich hoffe man kann verstehen wie das gemeint ist.

    In den letzten Wochen musst ich ja leider wg WPF alles aufgeben, was ich bisher gewohnt war, wenn es um Daten ging.
    Klassen, Propertys, Namespace, Collections, Views und mein besonderer Freund das Binding mit Itemsource und Datacontext sind alle neu für mich. Es fällt mir sehr schwer da den Überblick zu bekommen.

    Gruß

    eddi

    eichseinet schrieb:

    Ich hoffe man kann verstehen wie das gemeint ist.
    Nein.
    Bzw. ich halte es für kontraproduktiv, zu verstehen zu versuchen, wie irgendetwas gemeint ist.
    Wenn du etwas meinst, dann ist notwendig, dass du sagst, was du meinst, und zwar so, dass man versteht, was du meinst.
    Dabei bin ich gerne bereit zu helfen, nämlich durch nervtötende Nachfragen.
    Hintergrund ist, dass es zum Proggen fundamental wichtig ist, klar zu denken. Und wenn du dich verständlich ausdrückst, dann hast du klar gedacht.
    Viele viele Probleme sind dann bereits gelöst, weil in dem Moment, wo man eine Frage klar formuliert, kommt man sehr oft selbst auf die Lösung (eigene Erfahrung, immer wieder).
    Und wo man dann immer noch nicht drauf kommt - na da kann im Forum ja noch geantwortet werden.
    Und zwar zielführend, weil die Frage richtig verstanden wurde.
    Alle anneren Antworten basieren nur auf Vermutungen, sind Stochern im Trüben und führen meist sogar weg vom Ziel.


    Also bei deiner bisherigen Fragestellung ist mir unklar, ob du viele Datensätze anzeigen willst, jeden in einer Gruppe von 3 Zeilen?
    Oder willst du nur einen (den aktuellen) Datensatz anzeigen, und nur den, in 3 Zeilen?

    Beides wäre möglich, weil in Wpf ist vieles möglich.

    So oder so ist aber die Nach-Frage aufgeworfen, wie der User die 3 Zeilen verstehen soll.
    Normalerweise, bei mehreren Zeilen, steht über den Spalten eine Spaltenüberschrift, und die gibt an, welche Property in dieser Spalte steht. (Das ist das Prinzip einer Tabelle, und mittm DG perfekt umsetzbar).
    Wenn du aber alle möglichen Properties desselben Datensatzes über 3 Zeilen verteilen willst - wo willst du die Beschriftungen hinschreiben?
    Weil eine Spaltenüberschrift als Beschriftung scheidet aus, da wären dann ja verschiedene Props mit derselben Überschrift beschriftet.

    Beide Nach-Fragen musste uns noch beantworten, vorher können wir keine zielführenden Antworten geben, sondern nur allgemeines Blabla, bzw. dolle Lösungen angeben für etwas, was so bei dir garnet vorliegt.

    Dieser Beitrag wurde bereits 4 mal editiert, zuletzt von „ErfinderDesRades“ ()

    eichseinet schrieb:

    In den letzten Wochen musst ich ja leider wg WPF alles aufgeben, was ich bisher gewohnt war, wenn es um Daten ging.
    Klassen, Propertys, Namespace, Collections, Views und mein besonderer Freund das Binding mit Itemsource und Datacontext sind alle neu für mich. Es fällt mir sehr schwer da den Überblick zu bekommen.

    Aller Anfang ist schwer. Kopf hoch, das wird schon. Wirst sehen.

    Leider weis ich noch nicht Anhand deine Beispieldaten und diese Formulierungen was genau sache ist. Du schreibst was von Property One, Property Two, Property Three. Das lässt vermuten das es X Properties werden sollen. Also eine Unbekannte oder nicht? Bleiben es immer Drei? Die Benamsung in deinem Beispiel lässt auf etwas anderes schliessen.

    Je nachdem ob es eine fixe Anzahl an Eigenschaften gibt oder nicht ist es eine völlig andere Herangehensweise.

    PS: Vieleicht plaudern wir mal darüber was es werden soll /wofür es werden soll. Dann wissen wir vieleicht besser um was es geht.

    Wie @ErfinderDesRades schon richtig sagt, Wenn du selbst nicht genau erklären kannst was du brauchst bist du dir vieleicht auch noch nicht im klaren darüber was du brauchst. 8o
    Dann können wir dir sicher Helfen. Zumindest werden wir es sicher versuchen.

    Grüße
    Sascha
    If _work = worktype.hard Then Me.Drink(Coffee)
    Seht euch auch meine Tutorialreihe <WPF Lernen/> an oder abonniert meinen YouTube Kanal.

    ## Bitte markiere einen Thread als "Erledigt" wenn deine Frage beantwortet wurde. ##

    Erst mal Danke für die Antworten.
    Wenn jetzt nicht noch eine böse Überraschung kommt (wie vorhin), dann ist das Problem jetzt gelöst. Hauptsächlich durch hinzufügen einer Listbox. Aber von vorne.
    Ich versuche die Einstellungen zu meinem Programm (Ordnervorgaben, Zeitvorgaben usw.) anzuzeigen und kann sie hier auch ändern. Dabei gibt es pro Einstellwert drei Teile: Name der Funktion, der eingestellte Wert, eine Hilfe zum Wert. Diese 3 Teile sollen in einer Reihe nebeneinander stehen. Darunter dann die nächste 3er-Gruppe Name, Wert, Hilfe für den nächsten Wert. Mir ist klar, dass sich das ganz einfach in ein DataGrid packen lässt. 3 Propertys, deren Werte in mehreren Instanzen in einer Collection gesammelt werden. Dann muss man aber immer den richtigen Wert über eine Schleife in der Collection suchen lassen, um ihn im Code auszulesen (also kein direkter Zugriff über den Namen).
    Die Gesamtzahl der Werte ist fix und die Zahlen als Name waren jetzt einfach simpler für mich zum Testen.

    Meine Lösung sieht jetzt so aus:

    XML-Quellcode

    1. <ListBox ItemsSource="{Binding Dings_Coll}" HorizontalAlignment="Stretch">
    2. <ListBox.ItemTemplate>
    3. <DataTemplate>
    4. <Grid>
    5. <Grid.ColumnDefinitions>
    6. <ColumnDefinition Width="200*"/>
    7. <ColumnDefinition Width="300*"/>
    8. <ColumnDefinition Width="1500*"/>
    9. </Grid.ColumnDefinitions>
    11. <StackPanel Grid.Column="0" MinWidth="200">
    12. <TextBox Text="{Binding Ordner1_Bezeichner}"/>
    13. <TextBox Text="{Binding Ordner2_Bezeichner}"/>
    14. <TextBox Text="{Binding Zeitvorgabe_Bezeichner}"/>
    15. </StackPanel>
    17. <StackPanel Grid.Column="1" MinWidth="300">
    18. <TextBox Text="{Binding Ordner1_Wert}" />
    19. <TextBox Text="{Binding Ordner2_Wert}" />
    20. <TextBox Text="{Binding Zeitvorgabe_Wert}" />
    21. </StackPanel>
    23. <StackPanel Grid.Column="2" MinWidth="800">
    24. <TextBox Text="{Binding Ordner1_Hilfetext}"/>
    25. <TextBox Text="{Binding Ordner2_Hilfetext}" />
    26. <TextBox Text="{Binding Zeitvorgabe_Hilfetext}" />
    27. </StackPanel>
    28. </Grid>
    29. </DataTemplate>
    30. </ListBox.ItemTemplate>
    32. </ListBox>


    Das Ergebnis sieht dann so aus:


    ErfinderDesRades hat natürlich recht; wenn die Frage unklar formuliert ist kann keiner helfen.

    Herzlichen Dank nochmal, dass ihr beide es wieder versucht habt.
    Hoffentlich kann ich jetzt endlich ohne weitere Überraschungen an dem eigentlichen Projekt weiter arbeiten. Wenn das durch ist werde ich mich nochmal mit intensiv mit WPF beschäftigen.

    Gruß

    eddi

    Jo - sieht doch schnucklig aus. Und ist ein Beispiel für was Wpf recht einfach kann, was in WinForms glaub recht ungemütlich würde.
    Meine Frage nach der Beschriftung hat sich nu dahingehend geklärt, dass diese ja im Datensatz selbst enthalten sind.


    Nu wärs noch fein, wenn du dir ein richtiges Viewmodel basteln tätest, weil ich fürchte, du hast aus irgendeiner miesen Vorlage abgekupfert, wie im Window ans Window selbst gebunden wird.
    Das führt natürlich den grössten Vorteil von Wpf - die konsequente Trennung von Daten und Oberfläche - ad absurdum.
    Guck dir mal Grundlagen - MVVM-Anwendungs-Struktur an.


    Weiters hoffe ich, dass du die Bindings aus dem Property-Fenster "gepickt" hast, statt sie mühselig händisch hinzufrickeln.
    Zum Binding-Picking gugge hier: Grundlagen - MVVM: "Binding-Picking" im Xaml-Editor

Facebook
Telefonspende