I'm working on making my first game using C# and XAML for Windows 8. I'm still learning the core concepts and best practices, and MVVM has been a hurdle. I'll attempt to ask the question in two parts.
Background
The game I'm making is Sudoku. Sudoku has a board that contains a 9x9 grid of tiles. I have three models - Game
, Board
, and Tile
. When a Game
is created, it automatically creates a Board
, and when the Board
is created, it creates 81 (9x9) Tiles
.
1. With a hierarchy of views, how are corresponding view models created?
To match the hierarchy of models, I would like to have a hierarchy of views (GameView
contains a BoardView
which contains 81 TileViews
). In XAML, it's pretty easy to create this hierarchy of views with user controls, but I don't understand how the view models get created.
In the examples I've seen, the data context of a user control is often set to the view model (using the ViewModelLocator
as a source) which creates a fresh instance of the view model. This seems to work well if you have a flat view, but also seems like it gets messy when you have a hierarchy. Does the GameView
create a GameViewModel
and leave it up to its BoardView
child to create a BoardViewModel
? If so, how does the GameViewModel
communicate with the BoardViewModel
? Can the BoardViewModel
communicate back up the hierarchy to the GameViewModel
?
2. How does a view model get model data?
In iOS, I would start by using a service to fetch a Game
model that was pre-populated with data. I would then create a GameViewController
view controller (which was in charge of creating the view) and pass the Game
to it. In MVVM, I see the value in having a view be in charge of creating its own view model (ideally using a ViewModelLocator
), but I don't understand how that view model gets the model.
In all of the examples I've found online, the view model uses some service to fetch its own data. But I haven't come across any example that accepts constructor params or params passed from a higher level of navigation. How is this done?
I don't want to use an application resource or some other kind of singleton storage method for my model because, not that I do, but what if I wanted to display multiple puzzles on the screen at once? Each GameView
should contain its own Game
.
Not only does the GameViewModel
need a reference to the Game
model, but the BoardViewModel
that was created somehow (see question 1) needs a reference to the Board
model that belongs to the Game
model. The same goes for all the Tiles
. How is all this information passed down the chain? Can I do this much heavy lifting entirely within XAML, or am I going to have to do some sort of binding or other initialization in code?
Phew!
I appreciate any advice you can give, even if it's not a full answer. I'm also keen to find any examples of MVVM projects that share similar challenges to my own. Thanks a ton!
Model View View-Model (MVVM) is basically a UI Based Design Pattern. The main object of MVVM is to provide a rich UI, testability features, code more reusability and complex data binding. It helps to improve the separation of the business and presentation layers without any direct communication between each other.
Model — View — ViewModel (MVVM) is the industry-recognized software architecture pattern that overcomes all drawbacks of MVP and MVC design patterns. MVVM suggests separating the data presentation logic(Views or UI) from the core business logic part of the application.
The ViewModel class is designed to store and manage UI-related data in a lifecycle conscious way. The ViewModel class allows data to survive configuration changes such as screen rotations.
I would start by creating a class to begin the application with. Typically I call that class something like ApplicationViewModel
or ShellViewModel
, even though technically it can abide by different rules than what I would typically use for a ViewModel
This class gets instantiated at startup, and is the DataContext
for the ShellView
or ApplicationView
// App.xaml.cs
private void OnStartup(object sender, StartupEventArgs e)
{
var shellVM = new ShellViewModel();
var shellView = new ShellView();
shellView.DataContext = shellVM;
shellView.Show();
}
This is usually the only place I set a DataContext
for a UI component directly. From this point on, your ViewModels are the application. Its important to keep this in mind when working with MVVM. Your Views are simply a user friendly interface that allows users to interact with the ViewModels. They're not actually considered part of the application code.
For example, your ShellViewModel
may contain:
BoardViewModel CurrentBoard
UserViewModel CurrentUser
ICommand NewGameCommand
ICommand ExitCommand
and your ShellView
might contain something like this:
<DockPanel>
<Button Command="{Binding NewGameCommand}"
Content="New Game" DockPanel.Dock="Top" />
<ContentControl Content="{Binding CurrentBoard}" />
</DockPanel>
This will actually render your BoardViewModel
object into the UI as the ContentControl.Content
. To specify how to draw your BoardViewModel
, you can either specify a DataTemplate
in ContentControl.ContentTemplate
, or use implicit DataTemplates
.
An implicit DataTemplate is simply a DataTemplate
for a class that doesn't have an x:Key
associated with it. WPF will use this template anytime it encounters an object of the specified class in the UI.
So using
<Window.Resources>
<DataTemplate DataType="{x:Type local:BoardViewModel}">
<local:BoardView />
</DataTemplate>
</Window.Resources>
will mean that instead of drawing
<ContentControl>
BoardViewModel
</ContentControl>
it will draw
<ContentControl>
<local:BoardView />
</ContentControl>
Now the BoardView
could contain something like
<ItemsControl ItemsSource="{Binding Squares}">
<ItemsControl.ItemTemplate>
<ItemsPanelTemplate>
<UniformGrid Rows="3" Columns="3" />
</ItemsPanelTemplate>
<ItemsControl.ItemTemplate>
</ItemsControl>
and it would draw a board using a 3x3 UniformGrid
, with each cell containing the contents of your Squares
array. If your BoardViewModel.Squares
property happened to be an array of TileModel
objects, then each grid cell would contain a TileModel
, and you could again use an implicit DataTemplate
to tell WPF how to draw each TileModel
Now as for how your ViewModel
gets its actual data objects, that's up to you. I prefer to abstract all data access behind a class such as a Repository
, and have my ViewModel
simply call something like SodokuRepository.GetSavedGame(gameId);
. It makes the application easy to test and maintain.
However you get your data, keep in mind that the ViewModel
and Models
are your application, so they should be responsible for getting data. Don't do that in the View
. Personally I like keeping my Model
layer for plain objects that hold data only, so only ever perform data access operations from my ViewModels.
For communication between ViewModels
, I actually have an article on my blog about that. To summarize, use a messaging system such as Microsoft Prism's EventAggregator
or MVVM Light's Messenger
. They work like a kind of paging system: any class can subscribe to receive messages of a specific type, and any class can broadcast messages.
For example, your ShellViewModel
might subscribe to receive ExitProgram
messages and close the application when it hears one, and you can broadcast an ExitProgram
message from anywhere in your application.
I suppose another method would be to just attach handlers from one class to another, such as calling CurrentBoardViewModel.ExitCommand += Exit;
from the ShellViewModel
, but I find that messy and prefer using a messaging system.
Anyways, I hope that answers some of your questions and will point you in the right direction. Goodluck with your project :)
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With