Dare un comando a View in MVVM

Immaginiamo di avere qualche controllo da parte dell’utente. Il controllo utente ha alcune windows figlio. E l’utente del controllo utente desidera chiudere le windows secondarie di qualche tipo. C’è un metodo nel codice di controllo dell’utente dietro:

public void CloseChildWindows(ChildWindowType type) { ... } 

Ma non posso chiamare questo metodo perché non ho accesso diretto alla vista.

Un’altra soluzione a cui penso è in qualche modo esporre il controllo utente ViewModel come una delle sue proprietà (quindi posso associarlo e dare il comando direttamente a ViewModel). Ma non voglio che gli utenti del controllo utente sappiano nulla sul controllo utente ViewModel.

Allora, qual è il modo giusto per risolvere questo problema?

Mi sembra di aver appena trovato una soluzione MVVM piuttosto carina a questo problema. Ho scritto un comportamento che espone una proprietà type WindowType e una proprietà booleana Open . DataBinding quest’ultimo consente al ViewModel di aprire e chiudere facilmente le windows, senza sapere nulla sulla vista.

Devo amare i comportamenti … 🙂

inserisci la descrizione dell'immagine qui

xaml:

            5                        

YellowWindow (Nero / Viola allo stesso modo):

    

ViewModel, ActionCommand:

 using System; using System.ComponentModel; using System.Windows.Input; namespace WpfApplication1 { public class ViewModel : INotifyPropertyChanged { public event PropertyChangedEventHandler PropertyChanged; private void OnPropertyChanged(string propertyName) { if (this.PropertyChanged != null) PropertyChanged(this, new PropertyChangedEventArgs(propertyName)); } private bool _blackOpen; public bool BlackOpen { get { return _blackOpen; } set { _blackOpen = value; OnPropertyChanged("BlackOpen"); } } private bool _yellowOpen; public bool YellowOpen { get { return _yellowOpen; } set { _yellowOpen = value; OnPropertyChanged("YellowOpen"); } } private bool _purpleOpen; public bool PurpleOpen { get { return _purpleOpen; } set { _purpleOpen = value; OnPropertyChanged("PurpleOpen"); } } public ICommand OpenBlackCommand { get; private set; } public ICommand OpenYellowCommand { get; private set; } public ICommand OpenPurpleCommand { get; private set; } public ViewModel() { this.OpenBlackCommand = new ActionCommand(OpenBlack); this.OpenYellowCommand = new ActionCommand(OpenYellow); this.OpenPurpleCommand = new ActionCommand(OpenPurple); } private void OpenBlack(bool open) { this.BlackOpen = open; } private void OpenYellow(bool open) { this.YellowOpen = open; } private void OpenPurple(bool open) { this.PurpleOpen = open; } } public class ActionCommand : ICommand { public event EventHandler CanExecuteChanged; private Action _action; public ActionCommand(Action action) { _action = action; } public bool CanExecute(object parameter) { return true; } public void Execute(object parameter) { if (_action != null) { var castParameter = (T)Convert.ChangeType(parameter, typeof(T)); _action(castParameter); } } } } 

OpenCloseWindowBehavior:

 using System; using System.Windows; using System.Windows.Controls; using System.Windows.Interactivity; namespace WpfApplication1 { public class OpenCloseWindowBehavior : Behavior { private Window _windowInstance; public Type WindowType { get { return (Type)GetValue(WindowTypeProperty); } set { SetValue(WindowTypeProperty, value); } } public static readonly DependencyProperty WindowTypeProperty = DependencyProperty.Register("WindowType", typeof(Type), typeof(OpenCloseWindowBehavior), new PropertyMetadata(null)); public bool Open { get { return (bool)GetValue(OpenProperty); } set { SetValue(OpenProperty, value); } } public static readonly DependencyProperty OpenProperty = DependencyProperty.Register("Open", typeof(bool), typeof(OpenCloseWindowBehavior), new PropertyMetadata(false, OnOpenChanged)); ///  /// Opens or closes a window of type 'WindowType'. ///  private static void OnOpenChanged(DependencyObject d, DependencyPropertyChangedEventArgs e) { var me = (OpenCloseWindowBehavior)d; if ((bool)e.NewValue) { object instance = Activator.CreateInstance(me.WindowType); if (instance is Window) { Window window = (Window)instance; window.Closing += (s, ev) => { if (me.Open) // window closed directly by user { me._windowInstance = null; // prevents repeated Close call me.Open = false; // set to false, so next time Open is set to true, OnOpenChanged is triggered again } }; window.Show(); me._windowInstance = window; } else { // could check this already in PropertyChangedCallback of WindowType - but doesn't matter until someone actually tries to open it. throw new ArgumentException(string.Format("Type '{0}' does not derive from System.Windows.Window.", me.WindowType)); } } else { if (me._windowInstance != null) me._windowInstance.Close(); // closed by viewmodel } } } } 

Ho gestito questo tipo di situazione in passato introducendo il concetto di WindowManager , che è un nome orribile per questo, quindi accoppiamolo a un WindowViewModel , che è solo leggermente meno orribile – ma l’idea di base è:

 public class WindowManager { public WindowManager() { VisibleWindows = new ObservableCollection(); VisibleWindows.CollectionChanged += OnVisibleWindowsChanged; } public ObservableCollection VisibleWindows {get; private set;} private void OnVisibleWindowsChanged(object sender, NotifyCollectionChangedEventArgs args) { // process changes, close any removed windows, open any added windows, etc. } } public class WindowViewModel : INotifyPropertyChanged { private bool _isOpen; private WindowManager _manager; public WindowViewModel(WindowManager manager) { _manager = manager; } public bool IsOpen { get { return _isOpen; } set { if(_isOpen && !value) { _manager.VisibleWindows.Remove(this); } if(value && !_isOpen) { _manager.VisibleWindows.Add(this); } _isOpen = value; OnPropertyChanged("IsOpen"); } } public event PropertyChangedEventHandler PropertyChanged = delegate {}; private void OnPropertyChanged(string name) { PropertyChanged(this, new PropertyChangedEventArgs(name)); } } 

nota: sto solo lanciando tutto questo a casaccio; ovviamente vorresti sintonizzare questa idea per le tue esigenze specifiche.

Tuttavia, la premessa di base è che i tuoi comandi possono funzionare sugli oggetti WindowViewModel , triggersre il flag IsOpen appropriato e la class manager gestisce l’apertura / chiusura di qualsiasi nuova finestra. Ci sono dozzine di possibili modi per farlo, ma ha funzionato per me in passato (quando effettivamente implementato e non gettato insieme sul mio telefono, cioè)

Un modo ragionevole per i puristi è la creazione di un servizio che gestisca la tua navigazione. Breve sumrio: crea un NavigationService, registra la tua vista sul NavigationService e usa NavigationService all’interno del modello di vista per navigare.

Esempio:

 class NavigationService { private Window _a; public void RegisterViewA(Window a) { _a = a; } public void CloseWindowA() { a.Close(); } } 

Per ottenere un riferimento a NavigationService, è ansible creare un’astrazione (ad esempio INavigationService) e registrarlo / scaricarlo tramite un IoC. Più appropriatamente si potrebbero anche fare due astrazioni, una che contiene i metodi di registrazione (usati dalla vista) e una che contiene gli attuatori (usati dal modello di vista).

Per un esempio più dettagliato è ansible verificare l’implementazione di Gill Cleeren che dipende fortemente da IoC:

http://www.silverlightshow.net/video/Applied-MVVM-in-Win8-Webinar.aspx inizia alle 00:36:30

Un modo per ottenere ciò sarebbe che il modello di visualizzazione richieda la chiusura delle windows secondarie:

 public class ExampleUserControl_ViewModel { public Action ChildWindowsCloseRequested; ... } 

La vista quindi aderirebbe all’evento del suo modello di visualizzazione e si occuperà di chiudere le windows quando viene triggersto.

 public class ExampleUserControl : UserControl { public ExampleUserControl() { var viewModel = new ExampleUserControl_ViewModel(); viewModel.ChildWindowsCloseRequested += OnChildWindowsCloseRequested; DataContext = viewModel; } private void OnChildWindowsCloseRequested() { // ... close child windows } ... } 

Quindi qui il modello di vista può garantire che le windows figlio siano chiuse senza avere alcuna conoscenza della vista.

La maggior parte delle risposte a questa domanda riguardano una variabile di stato controllata dal ViewModel e la vista agisce sulle modifiche a questa variabile. Questo è utile per comandi di stato come l’apertura o la chiusura di una finestra, o semplicemente mostrando o nascondendo alcuni controlli. Tuttavia, non funziona bene per i comandi di eventi stateless . È ansible triggersre un’azione sul fronte di salita del segnale, ma è necessario impostare nuovamente il segnale su basso (falso) o non si innescherà mai più.

Ho scritto un articolo sul pattern ViewCommand che risolve questo problema. È fondamentalmente la direzione inversa dei normali comandi che vanno dalla vista al ViewModel corrente. Implica un’interfaccia che ogni ViewModel può implementare per inviare comandi a tutte le viste attualmente connesse. Una vista può essere estesa per registrarsi con ciascun ViewModel assegnato quando la sua proprietà DataContext cambia. Questa registrazione aggiunge la vista all’elenco delle viste nel ViewModel. Ogni volta che ViewModel deve eseguire un comando in una vista, passa a tutte le viste registrate e esegue il comando su di esse se esiste. Questo fa uso della riflessione per trovare i metodi ViewCommand nella class View, ma anche Binding nella direzione opposta.

Il metodo ViewCommand nella class View:

 public partial class TextItemView : UserControl { [ViewCommand] public void FocusText() { MyTextBox.Focus(); } } 

Questo è chiamato da un ViewModel:

 private void OnAddText() { ViewCommandManager.Invoke("FocusText"); } 

L’articolo è disponibile sul mio sito Web e in una versione precedente su CodeProject .

Il codice incluso (licenza BSD) fornisce misure per consentire i metodi di ridenominazione durante l’offuscamento del codice.