WPF MVVM Verständnisfrage für Dialog Workflow

  • WPF

Es gibt 22 Antworten in diesem Thema. Der letzte Beitrag () ist von Mika2828.

    WPF MVVM Verständnisfrage für Dialog Workflow

    Guten Tag,

    ich bin relativ neu in der Programmierung von WPF mit dem MVVM Pattern und bin derzeit auf ein Problem gestoßen.

    Ich habe ein Programm, indem die Einstellungen von zuvor angelegten Archiven geändert werden können.
    Eine weitere Anforderung ist es, ein neues Archiv anlegen zu können.
    Ich möchte also ein Dialog Workflow erstellen, indem Seite für Seite/Dialog für Dialog die voreinstellungen dieses neuen Archives gesetzt werden.
    Bedeutet wenn alle voreinstellungen gesetzt wurden, wird der Dialog beendet und das Archiv hinzugefügt.

    Normalerweise würde ich ein neues Window erstellen wobei der Rückgabewert das fertige Archiv ist. Allerdings düfte das ja nicht dem MVVM gerecht werden.

    Ich hoffe Ihr könnt mir helfen.

    MfG Michael

    Erstmal danke für deine Antwort!
    Ich versuche das ganze ein wenig einfacher und deutlicher zu erklären.

    Ich habe ein TreeView mit verschiedenen Gruppen. Diese Gruppen besitzen Einstellungen.
    Ich möchte nun neue Gruppen hinzufügen können.
    Das hinzufügen soll mit einem Dialog Workflow geschehen. Bedeutet es soll sich ein neues Window öffnen und es soll Seite für Seite /Dialog für Dialog die Einstellungen dieser Gruppe gesetzt werden. Quasi wie ein Setup.

    Die Gruppen stehen in einer komplexen Objektstruktur, das Treeview ist an dieser Gebindet.
    Das funktioniert auch alles.

    Meine Frage ist wie man diesen Dialog Workflow/Hinzufügen Setup in WPF am klügsten/einfachsten löst. Bzw würde mich interessieren wie Ihr das löst oder lösen würdet.
    Ich hoffe es ist jetzt verständlicher.

    Danke
    MfG Michael

    Hi,

    ich starte einfach ein neues Window aus dem ViewModel oder Model wenn es sein muss, auch wenn das nicht MVVM konform ist. Eine MVVM konforme Lösung finde ich in diesem Fall einfach nur schlecht. Nur weil man das MVVM Pattern konsequent anwendet wird der Code nicht automatisch besser, in meinen Augen kehrt sich das ganze irgendwann um. Keep It Simple and Stupid!
    Gruß
    Christoph

    ich täte denken, zunächst braucht man ein Datenmodell mit diesen Gruppen und Einstellungen und Pipapo.

    Und dann eben ganz normal ein Treeview dran anbinden.

    Ich glaube aber, du hast noch kein Datenmodell, Weil "Gruppen" bedeutet iwie garnix.
    Kategorien und Gruppen könnte ich verstehen, da kämen die Kategorien in die oberste TV-Ebene, und die Gruppen in die Kats hineingeschachtelt, und dann macht man noch einen DetailView dran, um die Eigenschaften einer Gruppe zu präsentieren.
    Im Grunde alles in verschiedenen Tuts im Wpf-Tut-Bereich abgehandelt. Meine Wpf-Tuts habich die grundlegenden mit "Grundlagen" gekennzeichnet. Auch zu das mit einem Edit-Dialog ist iwo abgehandelt, vlt. bei "Anwendungsstruktur".

    Du könntest auch mal deine "Gruppe"-Klasse, und dein "Kategorie"-Klasse posten, ob das Datenmodell iwie aufgehen kann.

    Nein ich denke nicht das dass ein Fachbegriff ist ^^

    Also ich versuche es nochmal zu Erklären. Tut mir leid wenn ich das ganze sehr undeutlich formuliert habe.

    Es soll sich ein Window öffnen, im ersten schritt fordert das Fenster z.b die Eingabe eines Namen und eine Beschreibung der neuen Gruppe.
    Unten rechts in dem Window gibt es 2 Buttons, zurück und weiter. Drückt man weiter, wird eine neue View angezeigt. Diese verlangt die Eingabe von weiteren, anderen Eigenschaften. usw..

    Derzeit habe ich das ganze so gelöst:

    Ich habe ein Window, auf diesem Window liegt ein ContentControl. dieses ContentControl ist an eine List<UserControl> gebunden. Die Liste wird mit den Views gefüllt.

    Danke für eure Mühe

    mfg Michael

    Ah - ein Assistent!
    Aber das ist eine ganz andere Baustelle als was was mit einem Treeview zu tun hätte - ist klar, oder?
    Also einen Assistenten kannst du datenmodellmässig auffassen als eine List(Of Object), und in der kann man sich vor- und zurück-bewegen. Die einzelnen Objecte sollten dabei verschiedene Viewmodels sein. Dann kannst du mit DataTemplates für jedes Object die entsprechende View konstruiren.
    Kennst du das mit DataTemplates?
    Einfasch für verschiedene ViewmodelTypen je eines basteln und in die Resourcen schmeissen.
    Dann eine ContentControls Content auf die Objekt-Liste.Current setzen, und das ContentControl wendet automatisch das DAtatemplate an, passend zum Typ des aktuellen Objekts.

    Danke erstmal für deine Hilfe!

    Also ich habe nun ein AssistentWindow erstellt.
    Im Xaml Code habe ich mehrere DataTemplate für die verschiedenen ViewModels der Seiten definiert.
    Aktuell gibt es das AllgemeinViewModel und das DatenbankViewModel.
    Für jedes dieser ViewModels habe ich außerdem Views erstellt. AllgemeinView und DatenbankView.
    In den verschiedenen DataTemplates rufe ich das dazugehörige View auf.

    Soll ich für das Window auch ein ViewModel erstellen indem ich dann die List<> für die ViewModels definiere ?
    Oder macht man das im Backcode des AssistenWindow?

    mfg Michael

    Bis jetzt habe ich es, soweit wie ich es richtig verstanden habe, so wie du gesagt hattest umgesetzt.

    Wenn ich das ohne CodeBehind lösen kann, brauche ich für das AssistentWindow auch ein ViewModel.
    Dann fehlt mir allerdings das Verständnis, wie ich 1. den Assistenten aufrufe und 2. wie ich das Fertige Objekt, dessen Eigenschaften auf allen ViewModels verstreut liegt an das
    MainViewModel des Programms zurück gebe.

    wie gesagt: so abstrakt kann ich sowas garnet verhandeln. Da kann ich nur Banlitäten von mir geben, wie:
    "Ein Window ruft man mit Window.Show() auf"

    Und warum das Fertige Objekt iwie verteilt sein soll verstehe ich auch nicht, und wüsste auch nicht, warum es "zurückgegeben" werden müsste. Es ist doch garnet weggegeben worden, sondern es ist doch nur ein Assistenten-Window dran gebunden worden.

    Ich bin leider noch nicht 100% mit WPF vertraut. Das hast du wahrscheinlich schon gemerkt.
    Hast du eine Idee wie ich dir/euch das besser verdeutlichen kann?

    Im Endeffekt soll das AssistentWindow per Command von dem MainViewModel des Programms aufgerufen werden.
    Als Rückgabe Wert dient das Fertige Objekt.

    C#-Quellcode

    1. Archiv neuesArchiv = AssistentWindow.ShowAssistent();//Rückgabewert das im Assistent behandelte Archiv. Wird per Command im MainViewModel des Programms aufgerufen.
    3. pulic Archiv ShowAssistent()//Im Codebehind des AssistentWindow
    4. {
    5. Archiv neuesArchiv = new Archiv();
    6. AssistentWindow assistent = new AssistentWindow();
    7. assistent.ShowDialog();
    8. return neuesArchiv;
    9. }

    So sieht das ganze in meiner Vorstellung aus.
    Im Xaml Code sind wie du gesagt hast DataTemplates definiert.

    XML-Quellcode

    1. <Window.Resources> <!--Xaml Code des AssistentWindow-->
    2. <DataTemplate DataType="ViewModel:Allgemein">
    3. <local:AllgemeinView></local:AllgemeinView>
    4. </DataTemplate>
    5. <DataTemplate DataType="ViewModel:Datenbank">
    6. <local:DatenbankView></local:DatenbankView>
    7. </DataTemplate>
    8. </Window.Resources>

    Und ein ContentControll.

    XML-Quellcode

    1. <Grid>
    2. <ContentControl > <!--Xaml Code des AssistentWindow Noch nicht fertig.-->
    4. </ContentControl>
    5. </Grid>

    ich bin mir nicht sicher, ob das richtiges MVVM ist von mir, aber ich würde den Assistenten nicht im CodeBehind des MainWindows öffnen, sondern im Viewmodel des MainWindows.
    Sowas kann man mit einem gebundenem RelayCommand (alias "DelegateCommand") bewerkstelligen.

    Widersinnig kommt mir vor - wenn ich dein pseudoCode recht verstehe, dass du im AssistentenWindow ein DataTemplate für das MainWindow in den Resourcen hast. Was soll der Assistent mit einem Mainmodel-DataTemplate?

    Ahh, die Information ist Gold wert.

    Man ruft per AssistentWindowViewModel das AssistentWindow auf.
    Jetzt wird schon mal einiges klarer!

    Wo genau siehst du ein DataTemplate für das MainWindow?
    Es gibt derzeit 2 DataTemplates.

    Einmal für das AllgemeinViewModel.
    und für das DatenbankViewModel.

    Das AllgemeinViewModel soll später die erste Seite des Assistenten sein.
    Danach folgt als zweite Seite das DatenbankViewModel.

    MfG Michael

    jo, ich hab "AllgemeinViewmodel" als "MainViewmodel" aufgefasst - vom Namen her.
    Wohl falsch verstanden.

    versuchma, präzise zu formulieren

    Mika2828 schrieb:

    Man ruft per AssistentWindowViewModel das AssistentWindow auf.
    Dassis Quatsch, und habich nie gesagt.
    "per AssistentViewmodel" ein Window aufrufen geht ja garnet.

    Ich hab gesagt - schon in post#16: Ein Window öffnet man mit Window.Show(), oder in diesem Falle sogar besser mit: Window.ShowDialog()
    Wenn es ein AssistentenWindow ist, dann kann man ihm auch ein AssistentenViewmodel als DataContext zuweisen.
    Und nachdem es geschlossen wurde, - und .ShowDialog() zurückkehrt, kann man das AssistentenViewmodel auch auswerten - daran hat der User dann ja (via Bindings) allerlei Änderungen vorgenommen.


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

Facebook
Telefonspende