I did a recent post on implementing WPF with F#. Today I would like to expand on this posting to give a simple implementation of the MVVM pattern in F#. A good read about this topic can also be found on Dean Chalk’s blog although my example of the pattern is possibly simpler. With the MVVM pattern one typically has 3 segments, the view, viewmodel and model. With the beauty of WPF binding one is able to link the state based viewmodel to the view. In my implementation I have kept the same principles. I have a view (MainView.xaml), and and a ViewModel (MainViewModel.fs). What I would really like to illustrate in this posting is the binding between the View and the ViewModel so I am going to jump to that… In Program.fs I have the following code… module Program
open System
open System.Windows
open System.Windows.Controls
open System.Windows.Markup
open myViewModels
// Create the View and bind it to the View Model
let myView = Application.LoadComponent(new System.Uri("/FSharpWPF;component/MainView.xaml", System.UriKind.Relative)) :?> Window
myView.DataContext <- new MainViewModel() :> obj
// Application Entry point
[<STAThread>]
[<EntryPoint>]
let main(_) = (new Application()).Run(myView)
You can see that I have simply created the view (myView) and then created an instance of my viewmodel (MainViewModel) and then bound it to the data context with the code…
myView.DataContext <-
new MainViewModel() :> obj
If I have a look at my viewmodel (MainViewModel) it looks like this…
module myViewModels
open System
open System.Windows
open System.Windows.Input
open System.ComponentModel
open ViewModelBase
type MainViewModel() =
// private variables
let mutable _title = "Bound Data to Textbox"
// public properties
member x.Title
with get() =
_title
and set(v) =
_title <- v
// public commands
member x.MyCommand =
new FuncCommand
(
(fun d -> true),
(fun e -> x.ShowMessage)
)
// public methods
member public x.ShowMessage =
let msg = MessageBox.Show(x.Title)
()
I have exposed a few things, namely a property called Title that is mutable, a command and a method called ShowMessage that simply pops up a message box when called.
If I then look at my view which I have created in xaml (MainView.xaml) it looks as follows…
<Window xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
Title="F# WPF MVVM" Height="350" Width="525">
<Grid>
<Grid.RowDefinitions>
<RowDefinition Height="Auto"/>
<RowDefinition Height="Auto"/>
<RowDefinition Height="*"/>
</Grid.RowDefinitions>
<TextBox Text="{Binding Path=Title, Mode=TwoWay}" Grid.Row="0"/>
<Button Command="{Binding MyCommand}" Grid.Row="1">
<TextBlock Text="Click Me"/>
</Button>
</Grid>
</Window>
It is also very simple. It has a button that’s command is bound to the MyCommand and a textbox that has its text bound to the Title property.
One other module that I have created is my ViewModelBase. Right now it is used to store my commanding function but I would look to expand on it at a later stage to implement other commonly used functions…
module ViewModelBase
open System
open System.Windows
open System.Windows.Input
open System.ComponentModel
type FuncCommand (canExec:(obj -> bool),doExec:(obj -> unit)) =
let cecEvent = new DelegateEvent<EventHandler>()
interface ICommand with
[<CLIEvent>]
member x.CanExecuteChanged = cecEvent.Publish
member x.CanExecute arg = canExec(arg)
member x.Execute arg = doExec(arg)
Put this all together and you have a basic project that implements the MVVM pattern in F#.
For me this is quite exciting as it turned out to be a lot simpler to do than I originally thought possible. Also because I have my view in XAML I can use the XAML designer to design forms in F# which I believe is a much cleaner way to go rather than implementing it all in code. Finally if I look at my viewmodel code, it is actually quite clean and compact…
