Qual è il modo corretto di gestire con View e ViewModel in WPF?

Question

Attualmente sto creando un editor con pattern MVVM in WPF. L'editor prende semplicemente un'istanza di un tipo specifico come riferimento e la modifica. Il codice seguente è l'utilizzo previsto al termine dello sviluppo dell'editor.

MyEditor myEditor = new MyEditor();
myEditor.Show();
myEditor.Edit(myDataInstance1); // Bind myDataInstance1 to the editor and edit it.
myEditor.Edit(myDataInstance2);
myEditor.Clear();
myEditor.Close();
... and so on ...

Quindi, ho prima diviso il programma in Model, ViewModel e View. Ma qui è sorta una domanda. Dove devo dichiarare i metodi Show (), Edit (), Clear (), Close ()? E come dovrebbero essere gestite ogni classe View e ViewModel? Ci ho pensato in questo modo, ma non ho trovato una buona alternativa.

• Nel costruttore View, impostare ViewModel su DataContext, creare un'istanza di View e accedere al DataContext di View e chiamare il metodo ViewModel ...
• Accesso diretto ai metodi ViewModel. (View e ViewModel devono essere gestiti separatamente)
• Crea una classe indipendente chiamata MyEditor per gestire View e ViewModel e connetti i metodi di ViewModel e i metodi di MyEditor. Gli utenti utilizzano il metodo di MyEditor.

Dei metodi che pensavo, il terzo metodo è il più probabile, ma non ne sono sicuro. La composizione dell'editor non è molto semplice. Fondamentalmente, l'Editor è composto in gran parte da View, ViewModel e Model, ma all'interno del ViewModel, devo anche gestire le viste secondarie per vari MyChildTypes che possono essere modificati. (Esistono diverse classi MyChildType che ereditano la classe MyBaseType e ogni MyChildType ha la propria vista modificabile.) Quindi, se passo un'istanza di MyChildType all'Editor, l'Editor dovrebbe mostrare una vista modificabile adatta a quel tipo. Il controllo del tipo e la sostituzione della vista secondaria sono facili, ma non conosco un modo corretto per impostare l'istanza di MyChildType nell'editor. Per favore consigliami.

Answer 1

In genere l'approccio MMVM richiede che la vista venga creata staticamente tramite XAML.

Quando hai viste che esistono dinamicamente, modifica il tuo codice in modo che invece esistano sempre e siano visibili dinamicamente.

Quindi nel tuo caso avresti qualcosa di simile

<MainWindow>
    <MyEditor ViewModel={Binding EditorViewModel}/>
</MainWindow>

e sotto il tuo controllo ...

<MyEditor>
   <Panel Visible={Binding IsVisible}>
    .... actual stuff...
   </Panel>
</MyEditor>

dove EditorViewModel.IsVisibleè inizialmente falso (e ha un'associazione appropriata)

Puoi quindi avere EditorViewModel.Load (data) .Clear () .Show () .Hide () ecc ecc

Answer 2

Dai un'occhiata a caliburn micro

È un framework basato su convenzioni, quindi se hai un viewmodel mostrerà automaticamente la vista per quel modello. Quindi puoi cambiare la vista semplicemente cambiando l'istanza viewmodel.

Puoi dare un'occhiata al mio software open source qui che fa questo

https://github.com/AndersMalmgren/FreePIE

Se non si utilizza uno strumento basato su convenzione come caliburn, è possibile esaminare il modello ICommand di WPF

modifica: ecco un esempio, abbiamo una proprietà ViewModel di classe base

https://github.com/AndersMalmgren/FreePIE/blob/4e51cae1816e3eee915a9629503cb7c188579550/FreePIE.GUI/Views/Plugin/PluginPropertyViewModel.cs#L35

public ValueViewModel Value  { get; set; }

Nella vista essere vincolati a questo per convenzione

https://github.com/AndersMalmgren/FreePIE/blob/4e51cae1816e3eee915a9629503cb7c188579550/FreePIE.GUI/Views/Plugin/PluginPropertyView.xaml#L11

 <ContentControl x:Name="Value"></ContentControl>

Qualsiasi modello di visualizzazione a cui fai riferimento, verrà visualizzato la visualizzazione corretta.