Wechsel zwischen den Ansichten mithilfe von MVVM mit PRISMA

Dies ist eine gute Frage - ich hatte ähnliche Fragen, als ich anfing mit MVVM. Ich benutze nur die Prism/CAL-Bibliotheken von FRAU

Ich glaube was du suchst ist die Idee von einer Region, in CAL. Es ist im Grunde ein benannter container-Steuerelement, das stellt die Dinge. Im Grunde, you name einer region in eine top-level-UI-Stück, wie Sie Ihre Haupt-Fenster. Ihre app hat wahrscheinlich eine kleine Anzahl von diesen: vielleicht eine Kopfzeile, eine Fußzeile und Hauptfenster Regionen. (Das ist, wie ich es getan habe sowieso.). Dann aus dem code hinter die Sie zugreifen können, die region durch ein region-manager, deaktivieren Sie es, und löschen Sie in Ihrem ViewModel. Das ViewModel abgebildet werden, um es in den entsprechenden Anzeigen und voila die neue Ansicht wird angezeigt.

Von einer Kodierung Standpunkt, ich habe in der Regel gesehen, wie er gebrochen wie diese:
Sie haben eine Art von einem NavigationController, die eine Methode hat oder zwei aus dem clearing der region und zeigt eine neue ViewModel->Ansicht und hat auch Methoden wie GoToPageX(). Diese Zusammenfassungen der region-manager. Dann hast du ein ViewModel für jede Seite und eine Ansicht für jede Seite. Jedes ViewModel dauert in der NavigationController über dependency injection (aber Sie können auch neue erstellen, wenn Sie nicht mit DI). Dann auf dem ViewModel, macht es einen Befehl bekommt, zugeordnet zu der Taste, und fordert den NavigationController.

Irgendwo Sie haben auch zu registrieren, die ViewModels mit den Ansichten verwendet, um Ihnen zu zeigen.

Hier ist ein Beispiel für einen NavigationController:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Microsoft.Practices.Prism.Regions;
using Microsoft.Practices.Unity;
using KSheets.CoreModule.Presenter;
using Zephyr.Core.Logging;
using KSheets.CoreSheets.Sheet;
using System.IO;

namespace KSheets.CoreModule.Switch
{
    public class Switchboard : ISwitchboard
    {
        private ILoggingService<ISwitchboard> m_Logger;
        private IRegionManager m_RegionManager;
        private IUnityContainer m_UnityContainer;

        public Switchboard(
            ILoggingService<ISwitchboard> loggingService,
            IRegionManager regionManager,
            IUnityContainer unityContainer
            )
        {
            if (loggingService == null) throw new ArgumentNullException("loggingService");
            if (regionManager == null) throw new ArgumentNullException("regionManager");
            if (unityContainer == null) throw new ArgumentNullException("unityContainer");

            m_RegionManager = regionManager;
            m_UnityContainer = unityContainer;
            m_Logger = loggingService;
        }

        public void GoHome()
        {
            m_Logger.Log("Going home");

            var worksheetEditor = m_UnityContainer.Resolve<IWorksheetEditor>();
            worksheetEditor.Initialize();
            LoadView(RegionNames.EditorRegion, worksheetEditor);

            var batchExporter = m_UnityContainer.Resolve<IExportBatchPresenter>();
            LoadView(RegionNames.ExporterRegion, batchExporter);
        }

        private void LoadView(string regionName, object newView)
        {
            var region = m_RegionManager.Regions[regionName]; 
            var oldViews = region.Views;
            foreach (var oldView in oldViews)
                region.Remove(oldView);
            region.Add(newView);
            region.Activate(newView);
        }
    }
}

Hier ist ein Beispiel für das registrieren einer Ansicht mit einem ViewModel programmgesteuert. Viele Leute tun dies in XAML, aber Sie können es auch tun, im code der IMO funktioniert besser, wenn Sie sich mit dependency injection, wie Sie sich anmelden können, Ihre Ansichten und dependency injection Sachen alle zur gleichen Zeit, wenn das Modul geladen.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows;

namespace Zephyr.WPF.Utils
{
    public static class ResourceUtils
    {
        public static void RegisterView<T, U>()
        {
            DataTemplate template = new DataTemplate();
            FrameworkElementFactory factory = new FrameworkElementFactory(typeof(U));
            template.DataType = typeof(T).FullName;
            template.VisualTree = factory;
            Application.Current.Resources.Add(new DataTemplateKey(typeof(T)), template);
        }
    }
}

        private void RegisterViews()
        {
            ResourceUtils.RegisterView<WorksheetDisplay, WorksheetDisplayView>();
            ResourceUtils.RegisterView<ProblemSelector, ProblemSelectorView>();
            ResourceUtils.RegisterView<WorksheetEditor, WorksheetEditorView>();
            ResourceUtils.RegisterView<ExportBatchPresenter, ExportBatchView>();
        }

Am Ende des Tages, müssen Sie ein kleines bisschen code, UI-bewusst (oder ein UI-Steuerelement, das hört Nachrichten, die von nicht-UI-code, der weiß, ein kleine etwas über die UI-wie die region-Namen) und ermöglicht es Ihnen, zu kleben die ViewModel-in Platz. Jedoch dieser code ist in der Regel super minimal und erfordert definitiv kein code-behind-außer für die out-of-box-Komponenten. MVVM ist eine Art, eine Menge zu nehmen in, wenn Sie tatsächlich haben, um die Implementierung in WPF die erste Zeit, eine steile Lernkurve für eine einfache app und läuft.