Nella mia ultima azienda, nella gestione dei comandi di visualizzazione, in ViewModelBase esisteva un comando centrale implementato, come
public ICommand ToolCommand { get; set; }
E nel ViewModelBase, è stato inizializzato e tutti i pulsanti collegati a questo comando sono stati differenziati dal suo parametro di comando:
public ViewModelBase()
{
ToolCommand = new RelayCommand<String>(Execute, CanExecute);
}
Nel modello di visualizzazione delle basi, le funzioni Execute e CanExecute erano virtuali (implementando comandi generici come Close e così via) e nelle classi derivate, la funzione Execute e CanExecute era un grande interruttore, estendendo la funzionalità di base, sembrava più o meno così:
public void Execute(String parameter)
{
switch (parameter)
{
case "Refresh":
RefreshGrid();
break;
case "OtherStuff":
Other();
break;
default:
base.Execute(parameter);
}
}
In questi casi, quando abbiamo aggiunto un pulsante, abbiamo aggiunto un altro caso di switch nei modelli di visualizzazione appropriati.
Tuttavia, nella mia attuale azienda, la regola è che ogni pulsante ha una specifica proprietà del comando, come
public ICommand RefreshCommand { get; set; }
public ICommand OtherStuffCommand { get; set; }
, e avviato uno per uno:
RefreshCommand = new RelayCommand<String>(RefreshGrid(), _canRefresh);
OtherStuffCommand = new RelayCommand<String>(OtherStuff(), _canDoOther);
In ufficio non possiamo concordare quale sia il migliore in termini di compattezza, bellezza, debugabilità. Sicuramente non riscriveremo le parti di lavoro a causa dei suoi costi, ma considerando nuovi progetti che troviamo difficili da discutere e che ha più vantaggi.
Quale e perché di questi due approcci è meglio?