Hallo

Ich hab dir mal ein einfach zu verstehendes Beispiel gebaut.
Du hast mir noch nicht beantwortet wie deine Kenntnisse in etwa aussehen. Interface, Vererbung usw. sitzen?

Das Kommentieren des Quellcodes habe ich mal gelassen. Stattdessen würde ich sagen das du am besten Nachfragst wenn du was nicht verstehst.
Ich empfehle dir das Projekt so wie es ist nachzumachen. Also baue es dir nach, nur so kannst du dann wissen ob du alles verstanden hast.

Besonderen Augenmerk solltest du auf folgende Files legen:

Im Hauptprojekt: Application.vb, Application.xaml, WindowService.vb
Im View-Projekt: SPSWindow.xaml und SPSWindow.vb
Im ViewModel: IWindowService.vb, ServiceContainer.vb

Das Model-Projekt ist in diesem Beispiel leer weil es nicht benötigt wird.

Grüße
Sascha

Super, dann schau dir das mal in ruhe an und bei Fragen meldest dich eben einfach, wichtig ist das du es verstehst. also nicht einfach "oh, ich mach da das hin und dort das und dann funzt das, warum weis ich nicht aber es tut".
Das bringt dir auf lange sicht nix, wenn du es verstehst kannst du später auch komplexere Services implementieren.

Grüße
Sascha

Nur nicht so schnell aufgeben. Es ist nicht so komplex wie es auf den ersten Blick scheint. Es sind nur ein paar Dinge zusätzlich drinnen um das ganze auch komfortabel zu machen. Also um kontrolle über das Fenster und wie es genau aufgemacht wird. Was genau verstehst du denn nicht?

Im Grunde hast du ein Interface (IWindowService) und eine Klasse die die Funktionalität implementiert. (WindowService)
Wenn du das nicht hin bekommst dann brauchst du MVVM nicht anfassen weil unter MVVM das eines der Grundbausteine ist.

Grüße
Sascha

Dann musst Du Dich mit MVVM beschäftigen, denn ohne Interfaces und Services ist es kein MVVM.
Du kannst auch erstmal mit Codebehind dein Fenster öffnen.
Auch wenn Du keine Fenster hast sondern nur Views hin und her schalten willst brauchst du ein Interface, einen Service und eine Klasse die das Interface implementiert.
ich könnte Dir dazu auch ein Beispiel machen, aber das Demo von @Nofear23m ist eigentlich schon super und vor allem kurz und verständlich. Einfacher geht es fast kaum.
Ich arbeite in meinen MVVM Projekten mit Dependency Injection, das wäre dann nochmal komplizierter am Anfang.

Aber die Dialoge sind echt ein schweres Thema

Eigentlich nicht. Ist auch nix anderes wie Daten aus ner DB zu holen oder rein zu schreiben. Dazu brauchst auch ein Interface und nen Service.

Die DataTemplate sind dazu da das die WPF weis wenn ein Fenster angezeigt werden soll, welches ViewModel dazu gehört.

OK, wenn du es dennoch versuchen willst versuche ich mal Licht ins dunkel zu bringen. Denn dein voriger Post hat das irgendwie nicht impliziert.

Amro schrieb:

Die klasse WindowService wird schon etwas Komlexer.

Naja, im Grunde öffnet die Klasse ja nur das Fenster. Gut, ich habe die Methode so definiert das man etwas mehr komfort hat und gewisse "Dinge" einstellen kann.
Das sollte aber vom Code her verständlich sein, sonst frag bitte einfach nach wenn du eine Zeile nicht verstehst.
Die Methode CloseDialog sucht das "richtige" Fenster um es wieder Schliessen zu können. Warum? Weil es vom Service im Grunde, egal wie viele Fenster du offen hast nur eine Instanz gibt/geben kann.
Also muss man Anhand des DataContext das richtig Fenster finden. Ist also Komfort. Denn.... wenn du vom ViewModel aus ja nicht auf die UI zugreifen kannst/darfst, wie willst du ein Fenster denn wieder schliessen? Dieser Code ermöglicht dies.

Amro schrieb:

Und wie komm ich jetzt an das Fenster ?

Genau um das geht es ja. Im Grunde immer über den DatenKontext. Man könnte es auch so steuern das du ein Fenster über den Namen steuern kannst. Ich entschied mich für diese Variante. Aber viele Wege führen nach Rom.

Amro schrieb:

Du hast jetzt Templates in der Application.xaml.
Die Nutzt du wiederum um das SPSWindow mit Inhalt zu füllen.

Genau, hier kommt eine der stärken der WPF zum Einsatz. DataTemplates. Du sagst der WPF das du das "SubViewModel" wie folgt Rendern willst. In diesem Fall mit dem UserControl "uclSub".
Im SPSWindow gibt es einen ContentPresenter. Wenn das SPSWindow also als DataContext ein SubViewModel bekommt bekommt der ContentPresenter diesen auch vererbt. Die WPF geht her und schaut nach ob es ein DataTemplate für "SubViewModel" gibt und wird in der "Application.vb" fündig und rendert dieses. Das ist übrigend auch in meiner Tutorialreihe zu finden. Stichwort "DataTemplates". Ist in der WPF eines der wichtigsten Dinge. Nur so am Rande.

Amro schrieb:

In der Startupmethode verbindest du das ganze irgendwie.
Mit den Commands auch nochmal.

Nicht irgendwie. Ich erstelle eine Instanz eines ViewModels und öffne über das Service ein Window welchem ich eben dieses ViewModel als DatenKontext übergebe. In der Implementierung von WindowService erstelle ich dann eine Instanz vom SPSWindow und übergebe das ViewModel als DatanKontext. Und nun passiert die Magie mit den DataTemplates wie oben Beschrieben.
Das SPSWindow ist einfach eine Optimierte Version um eben wieder mehr Komfort zu haben und alles ein wenig besser Steuern zu können. Du könntest auch ein normales Fenster anstatt des SPSWindow öffnen.
Es verstecken sich im SPSWindow aber ein paar praktische Codezeilen

Amro schrieb:

Ohne UserControls nur mit Fenstern.

Nene, vergiss Fenster. Du brauchst UserControls, Fenster können nicht in DataTemplates angegeben werden. Du hast im Gunrde nur EIN Fenster (in meinem Fall das SPSWindow) und dieses dient als "Container" für alles was du anzeigen willst, In der Regel UserControls. Du kannst natürlich auch direkt im DataTemplate alle deine Controls schachteln, aber das macht wenig spass da du hier keinen Designer zur Verfügung hast.

Ich hoffe das war verständlich. Bei weiteren Fragen versuche ich gern nochmal/anders zu erklären.

Versuchs einfach nachzumachen. Wenn es nicht hinhaut stells hier Online und ich sehe gern nach wo der Fehler liegt. Man muss nur dran bleiben, wirst sehen, dann macht "klick" und du hast es raus.

Grüße
Sascha

Hallo nochmal

Nur zum Verständnis, ich hätte in dem Beispiel einfach zeigen können wie man ein Fenster öffnet. Ist weniger Code.
Aber die nächste Frage wäre dann gewesen wie man es wieder öffnet oder wie man denn dann den DatenKontext festlegt.
Und die nächste dann wie man den Titel dann dynamisch bestimmen kann
....
.....
....

Ich hoffe nun verstehst du warum ich nicht nur einfach das öffnen im Demo implementiert hatte.

Grüße
Sascha

Amro schrieb:

Muss ich mich von diesem Ansatz befreien um das zu verstehen
oder ist das jetzt nur in diesem speziellen Fall so?

Jep. Da die WPF anders funktioniert. Das ist auch eines der Gründe warum mit WinForms MVVM erst überhaupt nicht möglich ist.

Amro schrieb:

Was macht die zweite Klammer und Wo kommt TServiceContract her?

Ich erklähre es mal simpel. Der "Contract" ist ein "Vertrag". Du schmeißt mit "AddService" also einen "Vertrag" in einen Conteiner und dort ist der dann drinnen und kann dann immer aufgerufen werden.

Das ist etwas das musst du nicht unbedingt komplett verstehen. Wichtig ist das du weist das du einen Service erstmal in den Topf werfen musst um später auf diesen Zugreifen zu können.

Grüße
Sascha

Gerne, wie gesagt, probier ruig ein wenig rum.

Wenn es soweit läuft geb z.b. das WindowService nicht in den Container und schau was passiert. Oder öffne mehrere Fenster und versuche ein bestimmtes zu schliessen, setze einen Haltepunkt und schau was passiert.
Da lernt man echt viel wenn man im Einzelschritt durchgeht.

Grüße