Skip to main content

Simple F# REPL in WPF - part 4

This is the final post in this mini series, I'm going to show the finished UI user control and how simple it is to host inside a WPF app. The code is available on gitHub and the published binaries are available via nuGet (supports .Net version 4.0+).

Before I show the finished UI, lets look at the F# Interactive in Visual Studio, this loads, queries & displays the results from an external assembly:
What does this look like in my implementation?
It's looks pretty familiar right? :)

The major difference is I've output the working folder for the F# interactive process when the process starts:
I've made this configurable in code, so I thought it would be a good idea to tell the end user where they could put any assemblies they want to reference.

How can the user access the working folder?

Simply, a right click menu:
All the menu options should be obvious, the working folder for the above example is shown below, you can see it has the assembly referenced above:
For completeness the types used in the above query are shown below:
How is the user control being used in code?

The user control obviously has an XAML representation - ReplEngine. I've tried to keep the using of this as simple as possible, the following screen shot shows the control being used in an MVVM implementation with a specific theme being applied:
The control's DataContext is bound to specific view model supplied as part of the assembly. In fact if your going use the control in an MVVM application there are 3 classes you'll need to know about and use:

ReplEngine - as described above the UI representation of the REPL engine to be included in XAML,

ReplEngineController - coordinates communication between the UI and the actual REPL engine implementation, backed by an interface - IReplEngineController,

ReplEngineViewModel - contains all the UI concerns, bindable properties & commands, backed by an interface IReplEngineViewModel and accessed from the controller.

The view model (FSharpReplViewModel) used is shown below and as you can see it's using both the controller & view model, nothing complicated just simple dependency injection and exposure of the view model as the Content property:
The IoC registrations for the controller & view model are easy, as you can see there are couple of parameters, these are optional, this is where you'd configure the working folder and the script to run automatically when the UI is first rendered:
As you can see, it's really quick & simple to use in an MVVM scenario, but;

What if you're not using MVVM, what if you're using a code-behind approach?

This is catered for as well in the form of a user control called ReplWindow. This wraps the ReplEngine user control, the controller & the view model, meaning you don't have to bind any properties. The StartupScript & WorkingDirectory are exposed as dependency properties:
That's it from a hosting point of view, the only thing left to describe is the theme support, not so much describe but show a hideous green example and the supporting XAML:
The theme styles the buttons, border, text & terminal controls, if a theme is not defined it will default to the current windows theme:

Loading gist ....

The example app used above is from the Simple.Wpf.Composition repo available on gitHub.

Comments

Popular posts from this blog

WPF tips & tricks: Dispatcher thread performance

Not blogged for an age, and I received an email last week which provoked me back to life. It was a job spec for a WPF contract where they want help sorting out the performance of their app especially around grids and tabular data. I thought I'd shared some tips & tricks I've picked up along the way, these aren't probably going to solve any issues you might be having directly, but they might point you in the right direction when trying to find and resolve performance issues with a WPF app. First off, performance is something you shouldn't try and improve without evidence, and this means having evidence proving you've improved the performance - before & after metrics for example. Without this you're basically pissing into the wind, which can be fun from a developer point of view but bad for a project :) So, what do I mean by ' Dispatcher thread performance '? The 'dispatcher thread' or the 'UI thread' is probably the most

Showing a message box from a ViewModel in MVVM

I was doing a code review with a client last week for a WPF app using MVVM and they asked ' How can I show a message from the ViewModel? '. What follows is how I would (and have) solved the problem in the past. When I hear the words ' show a message... ' I instantly think you mean show a transient modal message box that requires the user input before continuing ' with something else ' - once the user has interacted with the message box it will disappear. The following solution only applies to this scenario. The first solution is the easiest but is very wrong from a separation perspective. It violates the ideas behind the Model-View-Controller pattern because it places View concerns inside the ViewModel - the ViewModel now knows about the type of the View and specifically it knows how to show a message box window: The second approach addresses this concern by introducing the idea of messaging\events between the ViewModel and the View. In the example below

Implementing a busy indicator using a visual overlay in MVVM

This is a technique we use at work to lock the UI whilst some long running process is happening - preventing the user clicking on stuff whilst it's retrieving or rendering data. Now we could have done this by launching a child dialog window but that feels rather out of date and clumsy, we wanted a more modern pattern similar to the way <div> overlays are done on the web. Imagine we have the following simple WPF app and when 'Click' is pressed a busy waiting overlay is shown for the duration entered into the text box. What I'm interested in here is not the actual UI element of the busy indicator but how I go about getting this to show & hide from when using MVVM. The actual UI elements are the standard Busy Indicator coming from the WPF Toolkit : The XAML behind this window is very simple, the important part is the ViewHost. As you can see the ViewHost uses a ContentPresenter element which is bound to the view model, IMainViewModel, it contains 3 child v