WPF MVVM应用程序的设计

Question

I have been doing tons of research using MVVM (Model View ViewModel) with WPF. I am developing a desktop application. This application consists of a main window. This main window has some buttons which do something. Also, there is a button that opens a OpenFileDialog box.

Currently, this is my ViewModel to which the main window binds to:

MainWindowPresenter Class

namespace BMSVM_Simulator.ViewModel
{
    class MainWindowPresenter : ObservableObject
    {
        private bool logLoaded; // true if a log is currently loaded, false otherwise

        public MainWindowPresenter()
        {
            logLoaded = true;
        }

        public ICommand load_data_button_pressed
        {
            get { return new DelegateCommand(doLoadData);  }
        }

        private void doLoadData()
        {
            // DO LOAD DATA COMMANDS
        }

        public ICommand exit_button_pressed
        {
            get { return new DelegateCommand(doExit); }
        }

        private void doExit()
        {
            // DO EXIT COMMANDS
        }
    }
}

QUESTION 1 : I am concerned that this is the "wrong" implementation. Is it correct (per MVVM) for each button to have a property of type ICommand and then a corresponding method implementing the functionality? A main window with a lot of buttons would have a very large ViewModel class, no?

QUESTION 2 : If one of the buttons was a File->Open File button. So, in that case it would open up a new OpenFileDialog window. Would this be done in the same way I previously done it above (ie have a public ICommand open_file_dialog_button_pressed property and a corresponding public void doOpenFileDialog() method? This seems like I am mixing the "view" of the open file dialog into the ViewModel, although the view is already defined by the built in wpf OpenFileDialog class.

QUESTION 3 : Is it true that each "view" of our application should have only a single "presenter" class (which is part of the ViewModel) to which that view binds to? In the example above, my main window view binds to only the MainWindowPresenter class. If I were to make another view (say a graph generated with Microsoft's Dynamic Data Display library in it's own popout window), I would need an additional "presenter" class in my ViewModel, correct?

Thank you very much! Rich

For reference, I've included these classes, but they may not be useful:

DelegateCommand Class

namespace BMSVM_Simulator.ViewModel
{
    public class DelegateCommand : ICommand
    {
        private readonly Action _action;

        public DelegateCommand(Action action)
        {
            _action = action;
        }

        public void Execute(object parameter)
        {
            _action();
        }

        public bool CanExecute(object parameter)
        {
            return true;
        }

#pragma warning disable 67
        public event EventHandler CanExecuteChanged;
#pragma warning restore 67
    }
}

ObservableObject Class

namespace BMSVM_Simulator.ViewModel
{
    class ObservableObject : INotifyPropertyChanged
    {
        public event PropertyChangedEventHandler PropertyChanged;

        //basic ViewModelBase
        internal void RaisePropertyChanged(string prop)
        {
            if (PropertyChanged != null) { PropertyChanged(this, new PropertyChangedEventArgs(prop)); }
        }
    }
}

Answer 1

1) Yes that's correct. You need to create a command property for each command. But thanks to your relay command you don't need to implement it directly. To prevent your ViewModel from busting i would recommend to move all commands into a separate CommandsViewModel serving as command source. Your View then binds to it.

2) Opening the Dialog can be achieved in XAML via routed commands using the CommandBinding property. So the tasks remains in the view. You basically try to avoid the dependency on any view related object. .NET provides some ready to use commands for common purposes ( MSDN - ApplicationCommands )

3) You can share ViewModels among Views of course. That's one reason you structure your implementation into Model View ViewModel to be independent from changes and for reusability. It can become critical when more than one view is updating the same source simultaneously.