[WpfNote2] Mehrschichtanwendungen mit MVVM und Generischem Repository mittels EF Core

    • XAML: WPF
    • .NET 4.5

    Es gibt 35 Antworten in diesem Thema. Der letzte Beitrag () ist von MichaHo.

      Hallo

      Naja, im Grunde einfach. Du lässt ja nur eine Schicht weg.

      Benötigst also in der Businesslogic (dein Namespace ist falsch geschrieben) einen Verweis auf das EntityFramework.
      Ich habe zum Testen (da ich keinen MySQL habe) einfach den InMemory-Provider genommen.

      Als erstes komme ich zu dem was ich am Projekt verändert habe. Model.Protocol hatte kein Property ProtocolId. Auch wenn du es in diesem Moment noch nicht benötigst. Mach die Model immer fertig dann musst du die DB nicht X mal erstellen lassen. In der BusinessLogic habe ich erstmal alle Klasse rausgeworfen. Erstelle am besten Klassen immer erst wenn du diese wirklich benötigst. Ich habe gesehen du hast für jede Entität (also jede Modelklasse) eine Klasse in der BL erstellt. Klar, das erscheint ermal logisch. du hast Models und für jedes Model ein ViewModel. Also muss das sicher in der BL auch so sein. Naja, wenn man will ja, ich handhabe das so das ich die BL in Bereiche eingliedere. Beispiel: Die App öffnet sich und der User muss sich einloggen. Da habe ich keine UserBl und eine ProtokollBl und sonst was. Ne, ich habe eine LoginBl. Alles was zum Login gehört ist da drinnen.

      Eine Methode die mit zurückgibt ob es den User gibt, eine die mir zurückgibt ob sein Passwort korrekt ist. Vieleicht eine Mehtode LoginUser(). Diese prüft vieleicht nochmals und loggt den User ein, schreibt ein Protokoll usw. und wenn alles geklappt hat gibt diese Tru zurück und im ViewModel öffne ich das nächste Fenster. Ich weis aber immer das die Logik für Login genau dort drinnen ist.

      Gut. Ich habe mal eine Basisklasse für die BL erstellt.

      Die hat zwei Konstruktoren und ein Property Context. Dieses Property hält die EF Core Contextinstanz. Weiters implementiert die Basisklasse Dispose damit der Context auch immer brav entsorgt werden kann.
      Reichst du aber eine Contextinstanz hinein (weil du z.b. vom der LoginBl auf eine andere BL zugreifst und hier die selbe Instanz nutzen willst - wegen changeTracking) wird diese nicht zerstört.
      Achja, und wichtig ist das das Property Context und die Konstruktoren internal sind. Warum? Weil du den DBContext sonst nach außen reichst und du somit im ViewModel einen Verweis auf das EF Core benötigen würdest. Das wollen wir ja nicht wenn wir "clean" bleiben wollen. Genau, ich konfiguriere in der basisklasse auch gleich den Context für NoTracking als Default da ich das immer zwecks Performance mache.

      Ja, und der Code im MainBl ist dann wieder ganz normaler code zum speichern oder abrufen von Daten.
      Im ViewModel rufst du die Methoden einfach nur noch auf und dein ViewModel bleibt sauber, übersichlich und du hast wirklich nur noch den Code vor der Nase den du brauchst.


      Zum Thema Asyncrone Methoden. Müssen nicht Asyncron sein. Ich empfehle es aber. So bleibt deine GUI nicht hängen. EF Core bietet so viele Async-Methoden an, wäre schade wenn man sie nicht nützt.
      Wenn du Fragen hast immer nur her damit. Wenn man es mal versteht ist es echt nicht schwer und verdammt übersichtlich. Fragen - EF core spezifisch aber bitte in einem neuen Thread. (Und die werden kommen ;-))

      Grüße
      Sascha
      Dateien
      • MusicManager.zip

        (839,26 kB, 6 mal heruntergeladen, zuletzt: )
      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. ##

      Hallo,

      vielen Dank für deine Hilfe, jetzt ist mir einiges klarer!

      Nofear23m schrieb:

      (Und die werden kommen ;-))

      Das denke ich auch....

      Ich hänge nämlich schon wieder, mache aber dazu einen eigenen Thread auf.
      Da geht es noch mal genau um die BI und wie mann den jetzt anfängt.

      Viele Grüße
      Florian
      Meine Website
      Mein Projekt: SnippetLibrary
      Hallo,
      ich hätte hier auch noch 1-2 Fragen zum Projekt.
      Bin gerade dabei mein Dojo Projekt auf diese Struktur anzupassen.
      Nun verwende ich in meinen anderen Projekten immer das NugetPaket Ninject damit ich einen IoC Container habe.
      Wenn ich den Aufbau des Projektes richtig verstehe, sollte dies ja der InstanceHolder, die Services und der Messenger genauso tun.

      Normalerweise würde ich in einem Projekt nun hingehen und im IoC ein ApplicationViewModel binden sodass beim Starten der Anwendung immer eine Instanz des Application Viewmodel da ist.
      Im Application Viewmodel halte ich immer Properties, die ich überall benötige, wie zum Beispiel den aktuell angemeldeten Benutzer, eine Liste von zum Beispiel den Graduierungen.
      Da ich viel mit Pages arbeite, hält das Appviewmodel auch die CurrentPage, also die Seite, die aktuell angezeigt wird und das aktuelle ViewModel dazu.

      Kannst Du Sascha ( @Nofear23m ) kurz erklären, wofür der InstanceHolder da ist?

      Danke Dir
      "Hier könnte Ihre Werbung stehen..."
      Hallo und guten Morgen

      Wie du richtig erkannt hast verwende ich kein MVVM Framework. Ganz einfach aus dem Grund das es garnicht notwendig ist, hat man sich erstemal alles aufgebaut kann man es eh in jedem Projekt nutzen und ich habe zum einen den Vorteil das ich einfach die Kontrolle habe und wenn was schiefgeht ich selbst den Fehler beheben kann ohne auf einen drittentwickler warten zu müssen, und zum anderen lernt man so wie MVVM eigentlich funktioniert.

      Was von meinen Klassen nun genau den Klassen deines Frameworks entspricht kann ich dir nicht sagen da ich das Framework nicht kenne. Aber ja, der InstanceHolder hält als Signleton Klasse einfach gewisse Daten welche ich immer und überall benötige und da es pro App-Instanz auch nur diese eine Instanz des InstanceHolders geben kann, kann ich von überall aus darauf zugreifen. Wenn ich das richtig verstanden habe entspircht der InstanceHolder somit deinem ApplicationViewModel. Die Services steuern über DependencyInjection dinge wie MessageBox, Dialoge, Fenster, Mauszeiger usw., also alles was die View betrifft. Dies muss über DependencyInjection passieren damit man zum einen die View nicht ins ViewModel holen muss und zum anderen sogenannte Fakes für UnitTest erstellen kann. So kann das ViewModel dann auch getestet werden ohne das eine Messagebox aufgehen würde, was ja bei automatisierten Tests nicht geht. Und selbst wenn, wer würde dort auf einen Button drücken. Deshalb schreibt man Fakes.

      Solltest du noch Fragen habe dann einfach her damit.

      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. ##

      Fragen hab ich viele :D

      Konkret geht es mir jetzt erstmal um den InstanceHolder, Servies und Messages.
      Vielleicht, damit es klarer wird hier mal die typische IoC Klasse die ich verwende:

      C#-Quellcode

      1. /// <summary>
      2. /// Inversion of Control Container dieser Anwendung
      3. /// </summary>
      4. public class IoC
      5. {
      6. #region Public Properties
      7. /// <summary>
      8. /// der Kernel für den IoC Container
      9. /// </summary>
      10. public static IKernel Kernel { get; private set; } = new StandardKernel();
      11. /// <summary>
      12. /// Eine Verknüpfung für den Zugriff auf den <see cref="IUIManager" />
      13. /// </ summary>
      14. public static IUIManager UI => IoC.Get<IUIManager>();
      15. /// <summary>
      16. /// Eine Verknüpfung für den Zugriff auf <see cref = "ApplicationViewModel" />
      17. /// </ summary>
      18. public static ApplicationViewModel Application => IoC.Get<ApplicationViewModel>();
      19. /// <summary>
      20. /// Eine Verknüpfung für den Zugriff auf <see cref = "SettingsViewModel" />
      21. /// </ summary>
      22. public static SettingsViewModel Settings => IoC.Get<SettingsViewModel>();
      23. #endregion
      24. #region Construction
      25. /// <summary>
      26. /// Richtet den IoC-Container ein, bindet alle erforderlichen Informationen und ist einsatzbereit
      27. /// ACHTUNG: Muss aufgerufen werden, sobald die Anwendung gestartet wird, um zu gewährleisten
      28. /// das alle Services gefunden werden können (am besten in App.xaml.cs.StartUp)
      29. /// </ summary>
      30. public static void Setup()
      31. {
      32. BindViewModels();
      33. }
      34. /// <summary>
      35. /// Bindet alle Singelton ViewModels
      36. /// </summary>
      37. private static void BindViewModels()
      38. {
      39. Kernel.Bind<ApplicationViewModel>().ToConstant(new ApplicationViewModel());
      40. Kernel.Bind<SettingsViewModel>().ToConstant(new SettingsViewModel());
      41. }
      42. #endregion
      43. /// <summary>
      44. /// einen Dienst mit dem angegeben Typ vom IoC abrufen
      45. /// </ summary>
      46. /// <typeparam name = "T"> Der abzurufende Typ </ typeparam>
      47. /// <returns> </ returns>
      48. public static T Get<T>()
      49. {
      50. return Kernel.Get<T>();
      51. }
      52. }


      Im Grunde wird in der App.xaml das Setup aufgerufen, sodass ich dann Programmweit zugriff auf das ApplicationViewModel und auf das Settingsviewmodel habe.
      im ApplicationViewmodel hab ich eine Methode GoToPage:

      C#-Quellcode

      1. public void GoToPage(ApplicationPageEnum page, ViewModelBase viewModel = null)
      2. {
      3. CurrentViewModel = viewModel;
      4. CurrentPage = page;
      5. OnPropertyChanged(nameof(CurrentPage));
      6. }


      Nix wildes und könnte ich ja auch so umsetzen. Allerdings gibt es ja in der View noch das Gegenstück, nämlich die Basisklasse aller Pages und eine Generische Klasse für die ViewModel Unterstützung:
      Spoiler anzeigen

      C#-Quellcode

      1. public class BasePage : UserControl
      2. {
      3. #region Private Member
      4. /// <summary>
      5. /// das mit dieser Seite verknüpfte ViewModel
      6. /// </ summary>
      7. private object _viewModel;
      8. #endregion
      9. #region Public Properties
      10. /// <summary>
      11. /// die animation beim laden der seite
      12. /// </ summary>
      13. public PageAnimationEnum PageLoadAnimation { get; set; } = PageAnimationEnum.SlideAndFadeInFromRight;
      14. /// <summary>
      15. /// die animation beim entladen der seite
      16. /// </ summary>
      17. public PageAnimationEnum PageUnloadAnimation { get; set; } = PageAnimationEnum.SlideAndFadeOutToLeft;
      18. /// <summary>
      19. /// die Zeit, die jde animation benötigt
      20. /// </summary>
      21. public float SlideSeconds { get; set; } = 0.8f;
      22. /// <summary>
      23. /// ein Flag, das angibt, ob diese Seite beim Laden animiert werden soll
      24. /// nützlich, wenn wir die Seite in einen anderen Frame verschieben
      25. /// </ summary>
      26. public bool ShouldAnimateOut { get; set; }
      27. /// <summary>
      28. /// das mit dieser Seite verknüpfte ViewModel
      29. /// </ summary>
      30. public object ViewModelObject
      31. {
      32. get => _viewModel;
      33. set
      34. {
      35. if (_viewModel == value)
      36. return;
      37. _viewModel = value;
      38. DataContext = _viewModel;
      39. }
      40. }
      41. #endregion
      42. #region Constructor
      43. public BasePage()
      44. {
      45. //im Designmode wird nicht animiert
      46. if (DesignerProperties.GetIsInDesignMode(this)) return;
      47. if (PageLoadAnimation != PageAnimationEnum.None)
      48. Visibility = Visibility.Collapsed;
      49. Loaded += BasePage_LoadedAsync;
      50. }
      51. #endregion
      52. #region Animation Load / Unload
      53. /// <summary>
      54. /// Sobald die Seite geladen ist, führen wir alle erforderlichen Animationen durch
      55. /// </ summary>
      56. /// <param name = "sender"> </ param>
      57. /// <param name = "e"> </ param>
      58. private async void BasePage_LoadedAsync(object sender, System.Windows.RoutedEventArgs e)
      59. {
      60. if (ShouldAnimateOut)
      61. await AnimateOutAsync();
      62. else
      63. await AnimateInAsync();
      64. }
      65. /// <summary>
      66. /// animiert die Seite ein
      67. /// </summary>
      68. /// <returns></returns>
      69. public async Task AnimateInAsync()
      70. {
      71. if (PageLoadAnimation == PageAnimationEnum.None) return;
      72. switch (PageLoadAnimation)
      73. {
      74. case PageAnimationEnum.SlideAndFadeInFromRight:
      75. await this.SlideAndFadeInAsync(AnimationSlideInDirectionEnum.Right, false, SlideSeconds, size: (int)Application.Current.MainWindow.Width);
      76. break;
      77. default:
      78. break;
      79. }
      80. }
      81. /// <summary>
      82. /// animiert die Seite aus
      83. /// </summary>
      84. /// <returns></returns>
      85. public async Task AnimateOutAsync()
      86. {
      87. if (PageUnloadAnimation == PageAnimationEnum.None) return;
      88. switch (PageUnloadAnimation)
      89. {
      90. case PageAnimationEnum.SlideAndFadeOutToLeft:
      91. await this.SlideAndFadeOutAsync(AnimationSlideInDirectionEnum.Left, SlideSeconds);
      92. break;
      93. default:
      94. break;
      95. }
      96. }
      97. #endregion
      98. }
      99. /// <summary>
      100. /// Eine Basisseite mit zusätzlicher ViewModel-Unterstützung
      101. /// </ summary>
      102. public class BasePage<VM> : BasePage
      103. where VM : ViewModelBase, new()
      104. {
      105. #region Public Properties
      106. public VM ViewModel
      107. {
      108. get => (VM)ViewModelObject;
      109. set => ViewModelObject = value;
      110. }
      111. #endregion
      112. #region Constructor
      113. /// <summary>
      114. /// default constructor
      115. /// </summary>
      116. public BasePage() : base()
      117. {
      118. ViewModel = IoC.Get<VM>();
      119. }
      120. /// <summary>
      121. /// Konstruktor mit spezifischem ViewModel
      122. /// </ summary>
      123. /// <param name = "specificViewModel"> das zu verwendende spezifische ViewModel </ param>
      124. public BasePage(VM specificViewModel = null) : base()
      125. {
      126. if (specificViewModel != null)
      127. ViewModel = specificViewModel;
      128. else
      129. ViewModel = IoC.Get<VM>();
      130. }
      131. #endregion
      132. }


      Und eben in der generischen BasePage hole ich mir dann über IoC das ViewModel.

      Hier hänge ich jetzt gerade, das auf den InstanceHolder und Services/Messages umzubauen.
      Ich vermute, ich benötige einen Service, der mir das richtige ViewModel holt, so wie bei Dir das IDialogWindowService ein Fenster öffnet, brauch ich hier vermutlich ein IGetViewModelService oder gar ein IGoToPageService.
      Nur wie... da steh ich grad aufm Schlauch...

      Den InstanceHolder hab ich soweit verstanden, hier könnte ich ja auch zum Beispiel ein bool Propertie rein machen, was ich schalten kann ob ein Seitenmenü angezeigt werden soll oder nicht, das hatte ich sonst auch im ApplicationViewModel.
      "Hier könnte Ihre Werbung stehen..."

      MichaHo schrieb:

      Im Grunde wird in der App.xaml das Setup aufgerufen

      Und bei mir wird der Serivce-Container initial erstellt. Ich glaube InjectServices heisst die Methode.

      Ich weis nicht wie das bei dir mit dem Pages funktioniert und wie das geregelt ist aber bei meinen Services läuft im Grunde alles so wie wenn man CodeBehind hätte.
      Also wenn ich einen Dialog öffnen will dann spreche ich das IDialogWindowService an und wenn ich eine MessageBox zeigen will dann das IMessageboxService.
      Ich hole mir also aus dem Servicecontainer die richtige Instanz und rufe die passende Methode auf.

      Es gibt immer ein Interface für ein Service (Im ViewModel-Projekt) und dann die Implementierung des Services in der App selbst. Würdest du z.b. das selbe ViewModel auch für eine HandyApp verwenden wollen hätest du in dieser App auch implementierungen des Services. Denn dort gibt es keine Dialoge, dort heißt das glaube ich Popup.

      MichaHo schrieb:

      Den InstanceHolder hab ich soweit verstanden, hier könnte ich ja auch zum Beispiel ein bool Propertie rein machen, was ich schalten kann ob ein Seitenmenü angezeigt werden soll oder nicht, das hatte ich sonst auch im ApplicationViewModel.

      Naja, nur wenn du von überall daruaf zugreifen müsstest. Was ich in diesem Fall nicht glaube. Das Property interessiert doch im Grunde nur das ViewModel in welchem sich das Menü befindet oder?

      PS: Den InstanceHolder versuche ich auch immer "sauber" zu halten, also keinerlei Abhängigkeiten auf irgendwas zu haben, wie z.b. auf ein Model. Deshalb verwende ich dort immer nur "primitive" Datentypen.

      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. ##

      OK, das ist mir soweit klar, allerdings bekomme ich den Bogen zu meiner Page hinUndHer schalterei nicht hin.

      Ich hab deshalb mal schnell ein Beispielprojekt mit 2 Pages gemacht und verwende erstmal IoC über Ninject Projekt.
      Vielleicht können wir zusammen das auf InstanzHolder und Services umbauen, ist sicher auch für andere Interessant.
      Die Animation hab ich jetzt erstmal auskommentiert.
      Dateien
      • PagesTest.zip

        (19,78 kB, 3 mal heruntergeladen, zuletzt: )
      "Hier könnte Ihre Werbung stehen..."
      Hallo

      Also ich würde sagen wir fangen mal ganz unten an.
      Am Rohzustand eines MVVM Projekts. Denn was hier alles so benötigt wird bei diesem MVVM Framework ist der Hammer. Ich hab ja schon einiges gesehen aber das ist mal krass.

      Änderung der CodeBehind und des XAML das UserControls als Pages erkannt werden, diverse Klassen und herumfummelein, wenn du da mal Hilfe brauchst kann dir da niemand Helfen weil man ja nicht mal mit den "normalen" UserControls arbeitet. Wer weis wie es da mit DataTemplate und der gleichen aussieht. Schlimm. Ich weis garnicht genau wieviele Klassen ich jetzt gelöscht habe, aber es waren viele. Gut, weiter.

      Diese "Page" herumgeschalte, ich bin ja kein Freund davon. Ich lass lieber nen Dialog aufgehen oder habe einen Workspace in welchem ich den Content austausche. Genau das habe ich dir mal eingebaut. Denn, und siehe da, es benötigt hierfür nicht mal irgendwas. Kein MVVM Framework, keine Services, keine Messages, nichts drumherum. Für das umschalten des Inhalts benötigt es das alles nichtmal. Das geht alles mit den Builtin Features von WPF.

      Ich habe mal ein ganz einfaches Beispiel ähnlich deinem daraus gemacht ohne es unnötig komplex zu gestallten. Die Hintergrundmagie basiert lediglich auf DataTemplates in der App.xaml.
      Nicht mehr, nicht weniger. Ohne irgendwas drumherum.
      Wenn du das mal soweit durch hast und alle Fragen geklärt sind gehen wir weiter und fangen mal mit einem einfachen Service an und nähern uns hier Stück für Stück, denn man soll ja auch verstehen was sich da nun wo genau tut.

      Grüße
      Sascha
      Dateien
      • PagesTest.zip

        (466,32 kB, 7 mal heruntergeladen, zuletzt: )
      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. ##

      Hi Sascha,
      also das mit den Pages sieht recht einfach aus... muss jetzt nur noch schauen, wie ich die Animation da rein packe, denn es sieht einfach besser aus wenn die neue Seite irgendwie von der Seite rein und raus rutscht.
      Bei mir ist es auch meist so, das ich keine einzelne Hauptseite habe, die die ganzen unterseiten steuert. Meist hab ich eine Login/Register Seite die dann zur Hauptseite wechselt wenn erfolgreich...
      Mal schauen, erst muss ich jetzt mal das Dojo Programm fertig stellen, da lieg ich aber dank Deiner Hilfe in den letzten Zügen. Dann steht das Inventory Programm an, dort versuche ich dann die Page steuerung anders zu machen...
      Services und Messages interessiert mich aber dennoch, vielleicht kann ich dann wirklich auf Ninject verzichten wenn ich es kapiert habe...
      "Hier könnte Ihre Werbung stehen..."

      MichaHo schrieb:

      muss jetzt nur noch schauen, wie ich die Animation da rein packe

      Das ist einfach. Bau dir einfach 1x ein Animiertes ContentControl. Das Packst du ins Hauptfenster und bindest es. Fertig.
      Schau mal hier: codeproject.com/Articles/13678…n-Animated-ContentControl

      Das können wir ja gerne weiter durchgehen, wir können ja einfach das vorige Beispiel "ausbauen" und um z.b. einen Dialog und eine Messagebox erweitern.

      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. ##

      Nofear23m schrieb:

      Das können wir ja gerne weiter durchgehen, wir können ja einfach das vorige Beispiel "ausbauen" und um z.b. einen Dialog und eine Messagebox erweitern.

      Finde ich eine sehr schöne Idee - interessiert bestimmt noch viele andere - unter anderem auch mich...

      Viele Grüße
      Florian
      Meine Website
      Mein Projekt: SnippetLibrary
      Hi,

      So, hab mich nochmal an die PagesTest gemacht und die Animation eingebaut.
      Funktioniert eigentlich ganz schnuggelig....aber.... das Raus animieren klappt noch nicht.
      Ich habs mit einem Dependency Property versucht, was aber leider nicht klappt.
      Im Grunde wollte ich, das wenn die Page sich wechselt, das dann ausanimiert wird. Reinanimieren funktioniert.
      Ich vermute ich brauch doch einen PageHost, so wie im ersten Projekt.
      Dateien
      • PagesTest.zip

        (381,09 kB, 1 mal heruntergeladen, zuletzt: )
      "Hier könnte Ihre Werbung stehen..."
      Naja, so ganz trivial ist das dann nicht mehr wenn auch rausanimiert werden soll.

      Sobald du den Content wechselst ist der "alte" content ja weg. Willst du also den "alten" Content raus-animieren während der neue Content bereit kommt muss du ja beide halten.
      Sprich, du musst dir ein eigenes Control machen welche zwei ContentControls beherbergen kann. Wechselst du den Content musst du nun intern im Control den Inhalt aufrecht erhalten bis die Animation abgelaufen ist. und Anschließend dann umschalten. Weis nicht wie ich das jetzt erklären soll und ist vermutlich ein Thema für einen eigenen Thread. Wie gesagt, nicht so trivial aber dennoch sehr interessant.
      Auch wenn ich mit sowas persönlich nicht viel anfangen kann finde ich es von der machbarkeit her ganz interessant. Ich kann ja am Wochenende (falls ich kurz Zeit finde) mal versuchen ein solches Controls zu erstellen, rein weil es mich interessiert.

      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. ##

      Also im Grunde eigentlich genauso, wie in dem ersten Anhang oben.
      Nur eben ohne ViewModellocator und IOC.

      Ziel ist es ja auch, die Seiten von allen Seiten aus zu schalten, man hat ja nicht immer zwangsläufig ein Menü, oder ein Seitenmenü (bei Login und/oder Register zum Beispiel).

      Ich bin halt kein Freund von Dialogen, ich mag dialoge nicht... nur als Hinweis Dialog, ansonsten habe ich halt gerne Pages...
      Ich bau mal ein neues PagesTest Projekt und bau die Sachen mal so ein, wie ich mir das Denke, wie es funktionieren kann ohne Fremd Packages...
      Mache dann aber dazu ein neues Thema auf, hat ja hiermit eigentlich nichts mehr zu tun...

      Danke Dir
      "Hier könnte Ihre Werbung stehen..."