DataBinding mit einem TabControl auf einem untergeordnetem Fenster

  • WPF

Es gibt 47 Antworten in diesem Thema. Der letzte Beitrag () ist von Nofear23m.

    DataBinding mit einem TabControl auf einem untergeordnetem Fenster

    Hallo,

    ich habe folgendes Problem mit Binding und einem TabControl auf einem weiteren Fenster (ChildWindow).
    Ich habe hierzu ein Beispielprojekt zusammengeklickst, welches das Verhalten zeigt.
    Das Projekt ist so aufgebaut:
    Auf dem MainWindow finden sich 2 Buttons. Einer öffnet ein ChildWindow welches einen TabControl enthält und der andere erhöht den Index des SelectedItems des TabControls auf dem ChildWindow. Funktioniert wunderprächtig, solange man nur die Buttons bedient.
    Wenn man jetzt aber über das ChildWindow ein TabItem auswählt, danach über den Button auf dem MainWindow den SelectedIndex verändert und wieder den Focus auf das ChildWindow legt, springt das TabControl wieder auf den Index zurück, welchen es hatte als man es direkt auf dem ChildWindow geklickt hat.
    Es scheint mit, als ob im Hintergrund des ChildWindows irgendwo der direkt eingegebene Index hinterlegt und verwendet wird statt dem Index über Binding. Es schickt sogar den direkt eingegebenen Index an das ViewModel und überschreibt den index im Viewmodel wenn es Focus bekommt. Über Haltepunkte sieht man im Viewmodel, dass das Binding aber grundsätzlich in beide Richtungen funktioniert.

    Weiß jemand einen Rat, wie hier ein richtiges TwoWay Binding funktionieren könnte? Der Index soll sowohl über den Button als auch im TabControl einstellbar sein. Die offensichtlichen Einstellungen beim Picken des Bindings wie UpdateSourceTrigger, Mode, und so weiter habe ich bereits ausprobiert.

    ​Edit: Das gleiche Verhalten des TabControls lässt sich auch reproduzieren, wenn ich die TabItems direkt via "IsSelected" an ein Enum des ViewModels binde. Die direkt getroffene Auswahl überschreibt die Auswahl des Viewmodels, wenn das Fenster wieder den Focus bekommt.

    Viele Grüße
    Keks
    Dateien

    Dieser Beitrag wurde bereits 2 mal editiert, zuletzt von „SKeks“ ()

    es hat wohl mit dem Focus zu tun.
    Der Focus bleibt auf dem geklicksten Label, und wenn du wieder zurückkommst aufs childWindow, ist da wieder der focus, und aktiviert die TabPage.
    Ich hab eine Textbox zugefügt, hab ein Tab geklickst, dann in die Textbox, und dann hats nicht gesponnen.

    Ist natürlich nicht wirklich eine Lösung... :S
    Hallo Skeks

    Das Fehlverhalten liegt einfach daran das KEIN Content im TabItem enthalten ist. Selbst wenn du ein Label in das TabItem gibst ist das Verhalten so wie du es willst.

    PS: Wenn du MVVM einhalten willst hat folgende Zeile NICHTS in einer ViewModel Klasse zu suchen.
    ​ Private _childWindow As New ChildWindow
    Das ViewModel DARF DIE VIEW NICHT KENNEN. Solltest du nun das ViewModel in eine eigene Assembly auslagern (was man ja normalerweise im MVVM auch macht) stehst du schon an.

    Hier solltest du mit DataTemplates arbeiten. Du sagst das du die Klasse xyzVm mit den Control abc rendern willst. Den Rest macht die die WPF. Gerne kann ich dir hier helfen.

    Grüße
    Sascha
    If _work = worktype.hard Then Me.Drink(Coffee)
    Seht euch auch meine Tutorialreihe <WPF Lernen/> an oder abonniert meinen YouTube Kanal.
    Hi,
    was ist der (richtige) MVVM-Weg um ein neues Fenster zu öffnen? Oder einen Dialog?

    Das Problem, welches sich mir vormalig gestellt hatte, war von verschiedenen Stellen ein neues Fenster zu öffnen bzw zu schließen, das heißt über Buttons oder Mausklick. Oder über einen Dialog Dateien zu öffnen. Irgendwo muss ich ja hinterlegen was der Dateipfad ist oder was mit der geöffneten Datei passieren soll. Da erschien es mir als das kleinere Übel kurz dem Vm mitzuteilen, welches Control/Window es zu steuern hat, als Verrenkungen anzustellen. Im prinzip ein ähnliches Spiel mit dem Code-behind, gerade wenn es darum geht mausklicks zu steuern.
    Mein bisheriger Wissenstand war eigentlich, dass die (der :) ) View nichts vom ViewModel wissen sollte, aber das ViewModel sehr wohl über die View Bescheid weiß, da dieses ja das ganze Binding steuert und den verschiedenen Views mitteilt was wo angezeigt werden soll.
    Ich hatte es bisher dann so gehalten, dass das Model in einer eigenen Assembly liegt und VM und V zusammen ein einer, so dass sich mir bisher nicht das Problem gestellt hat.

    Gerne nehme ich aber trotzdem deine Hilfestellung in Anspruch etwas neues zu lernen! Vielleicht anhand von dem Beispiel hier im Thread, da dieses eng umrissen ist?

    Viele Grüße

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

    Hallo

    ​Schön das du für Veränderungen offen bist. Das ganze mit Dialogen, Messageboxen (Ja, die haben im VM auch nix verloren), Mousecursor usw. macht man über Services.
    ​Unter anderem ist das Ziel beim MVVM ja das die einzelnen Teile austauschbar sind. Mit deinem Ansatz kannst du die Views ja nicht tauschen.

    ​Gerne mach ich dir ein Beispiel so wie du es oben hast, nur ohne eine Referenz auf das View und in getrennten Assemblys.
    ​Geht sich nur heute leider nicht mehr aus. Melde mich dann morgen wieder.

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

    Ich hab dir mal ein kleines Demo gemacht wie ich das meine. Nun hat das ViewModel keinerlei Referenzen auf die Views oder ein PresentationFoundation oder anderes.
    Es ist auch eine eigene Assembly. Nun könntest du eine Windows Phone oder eine Windows 10 App machen und genau das selbe ViewModel verwenden.
    Die App muss dann nur die Serices erstellen. Fertig. Während in der Windows Desktop App eine Messagebox kommen würde, würde die Windows Phone App dann einen MessageDialog zeigen weil es dort ja keine Messagebox gibt.

    Ich habe jetzt auf ein Model verzichtet weil es für die Darstellung unerheblich ist wie oder von wo Daten kommen.

    Anbei das Beispiel so wie ich ein MVVM Projekt aufbaue.
    PS: Falls jemand einwende hat bin auch aber auch offen für Vorschläge, mein Ansatz geht evtl. noch besser auch.

    Grüße
    Sascha
    Dateien
    • MVVM_Demo.zip

      (318,12 kB, 45 mal heruntergeladen, zuletzt: )
    If _work = worktype.hard Then Me.Drink(Coffee)
    Seht euch auch meine Tutorialreihe <WPF Lernen/> an oder abonniert meinen YouTube Kanal.
    Hallo

    Gerne. Ich habe versucht es einfach zu halten. Auch habe ich absichtlich keinen OpenFileDialog eingebaut. Du kannst ja mal versuchen dieses Service selbst du integrieren. Brauchst ja nur wie ich ein Interface und ein Klasse dafür zu erstellen welchen das Interface implementiert. Versuchs mal. Ist im Grunde einfach.

    PS: Schau auch in die Application.xaml. Dort sind auch DataTemplates drinnen.
    Wenn du fragen hast frag nur.

    Grüße
    Sascha
    If _work = worktype.hard Then Me.Drink(Coffee)
    Seht euch auch meine Tutorialreihe <WPF Lernen/> an oder abonniert meinen YouTube Kanal.
    Hi,
    habe ich das so richtig verstanden:
    So arg viel unterscheiden sich die beiden Lösungen nicht zum Öffnen eines neuen Fensters: (zumindest tun beide irgendwo das Gleiche :) ) :
    Während bei mir direkt im VM steht welche V genutzt werden soll und zusätzlich in der V der DataContext direkt festgelegt wird, wird bei dir über verschiedene Templates und VM gearbeitet, welche in ganz kleine Häppchen geteilt sind. Dafür steht dann in application.xaml welche V zu welchem VM gehört.

    Wie machst du das mit dem Binding wenn du den DataContext erst zur Laufzeit festlegst? Schreiben und hoffen, dass kein Schreibfehler drin ist oder kann man damit auch irgendwie VisualStudio zum Binding picken nutzen?
    Hallo

    So arg viel unterscheiden sich die beiden Lösungen nicht

    Doch, enorm sogar. Weil das VM nicht svom View weis. Das regelt die WPF über das DataTemplate. Du sagst ihr welches VM du mit welchem Control gerendert haben willst.

    Wie machst du das mit dem Binding wenn du den DataContext erst zur Laufzeit festlegst? Schreiben und hoffen, dass kein Schreibfehler drin ist oder kann man damit auch irgendwie VisualStudio zum Binding picken nutzen?

    Klar. WENN du den DataContext auf ein VM festlegst ja, hierfür in der DesignTime Datencontext da. So hast du IntelliSense im VS XAML Designer.

    Oben um UserControl oder Fenster folgenden Import:

    XML-Quellcode

    1. xmlns:vm="clr-namespace:Demo.ViewModel;assembly=Demo.ViewModel"

    und dann im UserControl oder Window folgendes:

    XML-Quellcode

    1. d:DataContext="{d:DesignInstance IsDesignTimeCreatable=True, Type={x:Type vm:MyStartVm}}"


    Grüße
    Sascha
    If _work = worktype.hard Then Me.Drink(Coffee)
    Seht euch auch meine Tutorialreihe <WPF Lernen/> an oder abonniert meinen YouTube Kanal.
    Ich glaube so langsam steige ich dahinter was dein Ansatz bzw. du mir sagen will. Habe mal angefangen das ganze von dir zu re-engineeren und in mein größeres Projekt einzubauen.
    Der Vorteil von meinem Projekt ist ja, dass es nur ein Hobby ist. Ich kann dir also mit 100%iger Sicherheit sagen, dass daraus nie eine App wird oder was weiß ich :)

    Eine Sache die mir aufgefallen ist:
    Nehmen wir an ich habe ein recht umfangreiches Viewmodel mit vielen unterschiedlichen Eigenschaften. Dies möchte ich in mehreren thematisch unabhängigen Fenstern bearbeiten (jedoch hängen die Eigenschaften im Viewmodel/Model eng zusammen), weswegen hier eine Trennung nicht ganz so einfach ist.
    Mit dem Ansatz von dir müsste ich für jedes Fenster ein eigenes Viewmodel bauen und die Eigenschaften aus dem großen VM in das Fenster-VM übergeben. Oder das große VM als Referenz in das kleine VM übergeben und Eigenschaften an das Fenster durchreichen. Irgendwie auf jeden Fall, da die Auswahl des UserControls zur Anzeige im ChildWindow über den DataContext läuft. Was wäre hierfür ein geeigneter Ansatz?
    Aktuell habe ich es mit der Referenz im kleinen VM des Fensters auf das dahinterliegende VM und dem Durchreichen von Eigenschaften gelöst.

    Vielleicht noch eine Sache die mir beim Durcharbeiten deines Codes des RelayCommands aufgefallen ist. Du prüfst mit vb 6 If IsNothing(obj) = false bei der execute-Methode. Wieso nicht mit if obj is nothing oder If obj isNot nothing?

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

    Hallo

    ​Nehmen wir an ich habe ein recht umfangreiches Viewmodel mit vielen unterschiedlichen Eigenschaften. Dies möchte ich in mehreren thematisch unabhängigen Fenstern bearbeiten (jedoch hängen die Eigenschaften im Viewmodel/Model eng zusammen), weswegen hier eine Trennung nicht ganz so einfach ist.


    ​Ich denke ich weis was du meinst. Angenommen du willst mehrere View z.b. für die Kundendateneingabe haben. Evtl. einen View für die Schnelleingabe und einen View zum bearbeiten. Hier kannst du natürlich das selbe ViewModel nehmen. du hast jetzt z.b. in der Application.xaml ein DataTemplate für die "volle" Kundendateneingabe. Die WPF wird dieses Control rendern.
    ​Um dann das Control für die "schnelleingabe" zu verlangen öffnest du einfach ein Fenster wo innerhalb der Fensterresourcen ein DataTemplate für die "schnelleingabe" vorhanden ist.
    ​Dieses überschreibt dann natürlich das DataTemplate von der Application.xaml. Wie bei Styles. Wenn du ein Style z.b. Fensterweit für einen Button definierst wo du sagst: Margin = 5 haben die Buttons in dem Fenster alle ein Margin von 5. Wenn du dann bei einem Button ein Margin von 3 vergiebst überschreibst du den Setter des Styles.

    Man, ich kann das nicht so gut erklären.

    ​Vielleicht noch eine Sache die mir beim Durcharbeiten deines Codes des RelayCommands aufgefallen ist. Du prüfst mit vb 6 If IsNothing(obj) = false bei der execute-Methode. Wieso nicht mit if obj is nothing oder If obj isNot nothing?

    ​Oh, vielen Dank für den Hinweis, ist wohl noch ein altes relikt. Soll man nicht machen und liest sich auch nicht so gut. Danke ;)

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

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

    Ich habe es nun doch mit der Referenz gelöst. Erschien mir logischer als dann doch wieder 1000 verschiedene Fenster plus zusätzlich Controls zu erstellen die dann vorher gesetzte Templates wieder überschreiben statt wie in deinem Beispiel nur die verschiedenen unterschiedlichen Controls welche auf einem Standart-Fenster dargestellt werden.

    Ich habe deine IWindow-Schnittstelle erweitert:

    VB.NET-Quellcode

    1. Public Interface IWindowVm
    2. Property IsOpen As Boolean
    3. ReadOnly Property DataContextVM As Helpers.WPF.ViewModel.Infrastructure.ViewModelBase
    4. ReadOnly Property ContentVM As Helpers.WPF.ViewModel.Infrastructure.ViewModelBase
    5. End Interface

    Nicht verwirrt sein, ich habe die Begriffe umgedreht. Dein vormaliges ContentVM heißt nun DataContextVM und im neuen ContentVM hinterlege ich das bereits existierende und zu nutzende Viewmodel. oder ich erstelle ein neues. Dies ist hier ganz nach Belieben. Der Name der Eigenschaft die die Schnittstelle implementiert ist ja beliebig, so dass ich hier klingende Namen wählen kann und keine Verwirrungen enstehen. Ein Beispiel:

    VB.NET-Quellcode

    1. Public Class ChildWindowVM
    2. Inherits WPF.ViewModel.Infrastructure.ViewModelBase
    3. Implements IWindowVm
    4. Private _bigVM As BigVM
    5. Public ReadOnly Property BigVM As ViewModelBase Implements IWindowVm.ContentVM
    6. Get
    7. Return _bigVM
    8. End Get
    9. End Property
    10. Public ReadOnly Property DataContextVM As ViewModelBase Implements IWindowVm.DataContextVM
    11. Get
    12. Return Me
    13. End Get
    14. End Property
    15. Public Property IsOpen As Boolean Implements IWindowVm.IsOpen
    16. Public Sub New(bigVM As BigVM, isOpen As Boolean)
    17. _IsOpen = isOpen
    18. _bigVM = bigVM
    19. End Sub
    20. End Class


    Wenn ich also das Usercontrol gestalte, kann ich wie du vorgeschlagen hast über

    XML-Quellcode

    1. d:DataContext="{d:DesignInstance IsDesignTimeCreatable=True, Type={x:Type vm:BigVm}}"

    das Binding im Design-Prozess nutzen und kann jetzt nun auch aber an einem einzigen Ort mit einem einzigen Fenster meiner App sagen, wie und was gerendert werden soll. Also bei mir steht nun nur in Application.xaml drin:

    XML-Quellcode

    1. <DataTemplate DataType="{x:Type local:ChildWindowVM}">
    2. <local:ChildWindowControl DataContext="{Binding}"/>
    3. </DataTemplate>


    Die restliche Implementierung ist die Gleiche wie du vorgeschlagen hast.
    Ich denke, das Ganz hat nun mehrere Vorteile: Ich habe an einem einzigen Ort stehen, welches Control mit welchem Template, ich kann beim Gestalten gezielt auf die Eigenschaften eines großen VM zugreifen, die ich brauche und mir die (bereits bestehende) Logik im VM zu Nutze machen um Eingabedaten zu verarbeiten.
    Ein weiterer Vorteil, welchen man natürlich auch über Styles hätte lösen können: Ich kann das ChildWindow bereits designen mit Farben und Custom-Buttons und muss nur noch das Usercontrol drauf darstellen über

    XML-Quellcode

    1. <ContentControl Grid.Row="1" Content="{Binding DataContextVM}"/>


    Was hältst du von diesem Weg?

    Viele Grüße
    Hallo

    ​Entweder ich verstehe nun dein Vorhaben nicht ganz oder ich stehe gerade voll auf dem Schlauch. ?(
    ​So handelst du dir echt Probleme ein. Wenn du für den Designer einen Context angibst der zur Laufzeit ein anderer sein kann hast du Probleme mit dem Binding.
    ​Selbst wenn das VM welches zur DesignTime angegeben wird die selben Properties hat kannst du dich irgendwann vertun.

    ​Beschreib doch am besten Anhand eines Beispiels was du erreichen willst. Mit Beispiel meine ich: "Ich habe 2 Control, eines für Kundendaten und eines für Mitarbeiterdaten und die sollen das selbe VM bekommen können.
    Dann weis ich ungefähr was du erreichen willst.

    ​Wir finden sicher eine Lösung für das Problem. Gerne kannst du auch ein Beispielprojekt hochladen und erklären was es machen soll, dann schau ich mir das sehr gerne mal an.

    ​Grüße
    Sascha

    ​PS: Es gibt viele Wege im MVVM. Jeder einzelne hat seine Vor und Nachteile. Es ist ein Pattern, weshalb es nie DEN EINEN Weg geben kann.
    ​Ich mache jetzt seit 2 Jahren nur noch MVVM und komme immer wieder auf neue Sachen. Vielleicht ist dein Weg eh Top und ich komm nur einfach jetzt nicht mit.
    If _work = worktype.hard Then Me.Drink(Coffee)
    Seht euch auch meine Tutorialreihe <WPF Lernen/> an oder abonniert meinen YouTube Kanal.
    Hallo,

    ich habe im Anhang mal dein Projekt modifiziert so wie es mir vorstelle.
    Ich muss mich aber hierbei verbessern. Jedes ChildWindow Viewmodel muss seine eigene Property ContentVM bereitsstellen und kann dies nicht über die Schnittstelle und den Typ ViewModelbasetun, sonst funktioniert das Picken in den UserControls nicht. Ich bin da gestern einem Copy-Paste-Fehler aufgesessen. Heute beim komplett neu erstellen mit deinem Projekt ist mir das Problem mit dem Binding Picken aufgefallen. Es sei denn es gibt einen Weg für die Konvertierung auf einen abgeleiteten Typ über die Schnittstelle? Also Deklaration in der Schnittstelle auf den Basistyp und Implementierung mit einem abgeleiteten Typ.
    Edit: Habe eben gefunden, dass es nicht geht mit der Schnittstelle. Lösung hierfür wäre eine Vererbung der Schnittstelle und Angabe des abgeleiteten Typs in der vererbten Schnittstelle

    Achso, und was mich gerade 2 Stunden gekostet hat und in die selbe Kerbe schlägt. Wenn man in XAML IntelliSense für Datatemplates nutzen will muss das ChildWindowVM parameterlose Konstruktoren bereit stellen, sonst wird es nicht vom IntelliSense in XAML gefunden?! Auch das habe ich erst eben bemerkt beim komplett neu von Hand schreiben
    Dateien
    • MVVM_DEMO.zip

      (191,28 kB, 35 mal heruntergeladen, zuletzt: )

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

    Hallo

    ​Habe nun das Beispiel heruntergeladen. Was willst du nun bewerkstelligen??
    Es gibt 2 Button "Childwindow 1" und "ChildWindow 2".
    ​Das ein geht auf mit einem Rectangle als Inhalt und das andere mit einem Text.

    Was willst du erreichen?? Das hast du leider im letzten Posting nicht erklärt.
    ​Sorry, das mit dem parameterlosen Constructor habe ich leider nicht erwähnt.

    ​Wenn ich weis was du am Ende erreichen willst kann ich evtl. einen Weg finden wie dies einfach möglich ist. Am besten anhand eines PRaKTISCHEN Beispiels.

    Grüße
    Sascha
    If _work = worktype.hard Then Me.Drink(Coffee)
    Seht euch auch meine Tutorialreihe <WPF Lernen/> an oder abonniert meinen YouTube Kanal.
    Hi,
    Danke für dein Bemühen.
    Also ich probiere ein möglichst einfache Problembeschreibung. Dazu aber vorweg, diese ist von meiner eigentlichen Problemstellung abstrahiert und hat eigentlich auch nichts mehr mit der ursprünglichen Fragestellung hier im Thread zu tun.

    Wie du bereits erkannt hast, habe ich ein großes Viewmodel nennen wir es Person. Dieses möchte ich mit zwei unterschiedlichen Controls bearbeiten.

    Auf dem einen Control soll alles abgearbeitet werden, was die Person für biologische Eigenschaften hat (Haarfarbe, Hautfarbe, Größe) und auf dem anderen Control alles was mit dem Beruf der Person zu tun hat (Arbeitsstelle, Entfernung zur Arbeit, Werdegang).
    Du siehst also beide Controls sind also über ein gemeinsames Viewmodel verknüpft, haben aber thematisch nichts miteinander zu tun.
    Aus Gründen soll die Bearbeitung der Themenfelder in zwei unterschiedlichen Child-Fenstern passieren, welche sich auf Knopfdruck auf dem Mainwindow öffnen. Hinterlegt als Viewmodel ist natürlich bei beiden Fenstern die gleiche Person. Zusätzlich dazu soll Binding wie bisher mit Unterstützung von VisualStudio passieren um Fehler auszuschließen.
    So ist der Plan. Meine Lösung bisher funktioniert, aber da weiß mein Personenviewmodel über die beiden Views Bescheid. Dies soll nun mit richtigem MVVM umgearbeitet werden.

    In der Solution 2 Posts drüber habe ich probiert das nachzustellen. Auf dem Mainwindow befinden sich 2 Buttons welche jeweils ein Childwindow öffnen. ChildWindow1 zeigt hierbei die Boolean-Eigenschaft, ChildWindow2 die Integer-Eigenschaft eines Viewmodels genannt BigVM.
    Ich habe probiert nach Möglichkeit mich an deine Vorlage zu halten, mit der Einschränkung, dass ich genau an einer Stelle festlegen möchte welche View zu welchem Viewmodel gehört. In der Solution in Application.xaml.
    In der bisherigen Lösung von dir wurde die Unterscheidung welche View benutzt wird über den typ des Viewmodel ContentVM gesteuert, was natürlich bei dem gleichen VM zum Absturz führt.
    Deswegen meine Frage, was hierbei besser ist:
    a) Referenz in den VM der Childwindows auf das PersonenViewmodel wie in der Solution oben
    b) durchreichen von zu bearbeitenden Eigenschaften des Personenviewmodel über Eigenschaftszugriffe des VM des Childwindows
    c)....?

    Ich hoffe nun wird mein Anliegen klarer?

    Viele Grüße
    Hallo

    Jetzt weis ich was du machen möchtest. Dachte ich mir fast. So umständlich musst du es gar nicht machen. Die IWindow Schnittstelle musst du hierfür gar nicht verbiegen.
    Das geht in der WPF mit Triggern.

    Ich habe mal ein Beispiel erstellt. In diesen gibt es im PersonVM ein Property OpenInSecondView wenn du dieses auf True setzt Rendert die WPF nun ein anderes Control.
    Es gibt PersonView1 und PersonView2. Im 1er wird Vorname, Nachname und Haarfarbe behandelt. Wenn du nun im PersonVM OpenInSecondView = True setzt wird das PersonView2 geladen in welchem die Properties Größe, Schule und Beruf angezeigt werden. Beide Views verwenden das selbe ViewModel. Ich habe auch einen Savecommand reingepackt, dieser kann von BEIDEN Views angestoßen werden.

    Möglich macht dies ein Trigger. In der Application.xaml wo beschrieben ist das das PersonVM mal mit dem Control ChildWndowContentHolderView gerendert werden soll. Das habe ich erstellt.
    Und in diesem ist ein ContentPresenter welcher dann steuert welches Control innerhalb dieses Views in dessen Content geladen wird.

    XML-Quellcode

    1. <UserControl.Resources>
    2. <DataTemplate x:Key="Person1Template">
    3. <local:PersonView1 DataContext="{Binding}"/>
    4. </DataTemplate>
    5. <DataTemplate x:Key="Person2Template">
    6. <local:PersonView2 DataContext="{Binding}"/>
    7. </DataTemplate>
    8. </UserControl.Resources>
    9. <Grid>
    10. <ContentControl Content="{Binding}">
    11. <ContentControl.Style>
    12. <Style TargetType="ContentControl">
    13. <Style.Triggers>
    14. <DataTrigger Binding="{Binding OpenInSecondView}" Value="False">
    15. <Setter Property="ContentTemplate" Value="{StaticResource Person1Template}" />
    16. </DataTrigger>
    17. <DataTrigger Binding="{Binding OpenInSecondView}" Value="True">
    18. <Setter Property="ContentTemplate" Value="{StaticResource Person2Template}" />
    19. </DataTrigger>
    20. </Style.Triggers>
    21. </Style>
    22. </ContentControl.Style>
    23. </ContentControl>
    24. </Grid>


    Das ist doch das was du wolltest oder? Und das ganze ohne jetzt das ViewModel zu verunstalten. Alles was du die WPF machen lassen kannst lass sie machen. Die macht das nicht schlecht.

    PS: Wenn du das noch weiter verbessern willst oder fragen hast mach am besten einen neuen Thread auf, ich werde dir auch dort helfen. Finde es toll (obwohl es ein Privates Projekt wo es nicht wichtig ist) das du versuchst hier dein Projekt aufzubessern. Ich weis, das Thema MVVM ist nicht leicht in Erfahrung zu bringen, es gibt soooo viele Ansätze und soooo viele Beispiele im Netz, jedes etwas anders und auf solche Probleme geht niemand richtig ein. Ich tat mir auch echt schwer.

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

    ​Ah ich verstehe nun was du meinst. Ja genau so habe ich mir es vorgestellt, dass es funktioniert. Ich arbeite es mal ein und schau was passiert, wenn ich den Rest der Fenster und Dialoge anpasse.

    Joa, ich denke es schadet nicht, wenn man sich mit einer Programmiersprache und einer Art von Oberflächen auskennt, wenn man sich mit kleinen Programmen das leben leichter machen kann :) Leider ist das WPF Forum hier wie ausgestorben. Die Hürde für den Einstieg im Gegensatz zu WinForms ist halt doch etwas höher.

    Gruß
    Hallo,

    ​freut mich das es das war was du brauchtest.

    Ja, die Lernkurve ist etwas flach wenn man WPF lernt. Aber es lohnt sich. Alleine durch die ganze Templates bist so sooo viel flexibler als bei Winforms.
    ​Wen ich nur zurückdenke wenn ein Control von der Optik her nicht passte, und man im OnPaint das ganze zeichnen musste. Horror!!!

    ​Ich arbeite es mal ein und schau was passiert, wenn ich den Rest der Fenster und Dialoge anpasse.

    ​Das passt so. gibt natürlich noch mehr Wege, du kannst da mit Triggern ziemlich kreativ werden. Kann einiges.

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