PsAccelerator

Creating real world WPF applications with Prism 5 and F# (part 2 - MEF)

2014-06-23T21:07:00.001+02:00

In the previous post I explained how you could port the Hello World example from the Quick Starts of Prism 5. There was one issue. The Shell had knowledge op the module. This could be solved in different ways, for instance with configuration files.

I prefer a pluggable solution. Just by dropping dlls into a directory and everything should work fine. Microsoft has a framework that supports this way of working: Managed Extensibility Framework (MEF).

In this post I will show you how you can move the Hello World example from Unity to MEF.

I start from scratch and highlight the MEF changes You could also rework the Unity solution.

Create a empty solution, and add a project called Shell.

Next add:

FsXaml in case you don’t want to use the Xaml Type provider

Prism
the Prism.MEFExtensions.

If needed add the required references

In this case we added also System.ComponentModel.Components to get access to MEF.

Make sure it is a Windows application:

Next remove, add or rename the files

and be sure the xaml file has Resource as build action and contains the following content.

<Window 
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:cal="http://www.codeplex.com/prism"
    Title="Hello World" Height="300" Width="300">
    <ItemsControl Name="MainRegion" cal:RegionManager.RegionName="MainRegion" />
</Window>

We have done all the preparation. So we add the app class and the boodstrapper to the App.fs file.

module MainApp

open System
open System.IO
open System.Windows
open System.ComponentModel.Composition
open System.ComponentModel.Composition.Hosting
open System.Windows.Controls
open Microsoft.Practices.Prism.Modularity
open Microsoft.Practices.Prism.MefExtensions
open FsXaml

type Shell = XAML<"Shell.xaml">

type App() =
    inherit Application()
        override x.OnStartup(e) =
            base.OnStartup(e)
            let bootstrapper = new Bootstrapper() 
            bootstrapper.Run()

and Bootstrapper() =
    inherit MefBootstrapper()
        override x.CreateShell() = 
            let window = Shell()
            window.CreateRoot() :> DependencyObject
        override x.InitializeShell() =
            base.InitializeShell()
            App.Current.MainWindow <- x.Shell :?> Window
            App.Current.MainWindow.Show()
        override x.ConfigureAggregateCatalog() =
            let path = @"..\..\..\DirectoryModules"
            let dir = new DirectoryInfo(path);
            if not dir.Exists then dir.Create()
            let catalog = new DirectoryCatalog(path)
            x.AggregateCatalog.Catalogs.Add(catalog)

[<STAThread>]
(new App()).Run()|> ignore

Let’s compare this with Unity file from the previous post. First I have added or renamed some namespaces.

The app class did not change.

The bootstrapper now derives from MefBootstrapper. In this case we override the ConfigureAggregegateCatalog. We add a DirectoryModules directory in case it did not exists. This will prevent the creation of an exception by the DirectoryCatalog in case the directory id not exist. Next we add the catalog to the AggegateCatalog. Mef and Prism are now able to handle dll’s that are put into DirectoryModules directory.

F5 and everything works fine

and we have created the directory.

Next we create the Hello World Module again by taking the same steps as we did with the Shell. Except this time we create a dll.

The xaml of the HelloWorldView is the same as in the Unity example:

<UserControl
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
    <Grid>
        <TextBlock Text="Hello World" Foreground="Green" HorizontalAlignment="Center" VerticalAlignment="Center" FontFamily="Calibri" FontSize="24" FontWeight="Bold"></TextBlock>
    </Grid>
</UserControl>

Next step is to create the module:

namespace HelloWorldModule

open System
open System.Windows
open System.Windows.Controls
open System.ComponentModel.Composition

open Microsoft.Practices.Prism.Modularity
open Microsoft.Practices.Prism.Regions
open Microsoft.Practices.Prism.Mvvm
open Microsoft.Practices.Prism.MefExtensions.Modularity

open FsXaml

type HelloWorldXaml = XAML<"HelloWorldView.xaml">

[<ModuleExport(typeof<HelloWorldModule>)>]
type HelloWorldModule =
    val regionViewRegistry: IRegionViewRegistry
    interface IModule with
        member x.Initialize() = x.regionViewRegistry.RegisterViewWithRegion("MainRegion", fun _ -> HelloWorldXaml():> obj)
    [<ImportingConstructor>]
    new (regionViewRegistry) = {regionViewRegistry = regionViewRegistry}

Some of the namespaces were renamed or added.

This time we need to handle the MEF requirements. We need to add attributes. The class has the ModuleExport attribute. This attribute is provided by Prism:

and take care of the registration of the module.

This time we can’t use the default constructor because we need to add the ImportingConstructor attribute to the constructor.

There is no way in F# to add an attribute to the primary constructor.

So we need to transfer the constructor and add the attribute to this constructor with the keyword new and use an explicit field regionViewRegistry with the val keyword. In this way MEF is able handle the construction of the class by providing a value for regionViewRegistry.

Now we are ready to test the program. If we run it we don’t get the green Hello World. We need to copy

to the DirectoryModules.

The dll was dynamically loaded and added to the Shell.

If you don’t like to copy the dll by hand every time you change it, you could add a post-build event

copy /y "$(TargetPath)" "..\..\..\DirectoryModules"

and forcing to build the module.

When we change the color of Hello World to red, recompilation will show us the result in the correct color.

Next time we will have a look at MVVM by adding functionality to the view and the new Prism 5 ViewModelLocationProvider.

Creating real world WPF applications with F# and Prism 5 (part 1)

2014-06-16T21:08:00.001+02:00

F#

The designer tools of the Visual Studio should support F#. This would be critical for the adoption of F#. This is what I thought.

Last year I joined a large and complex project. The created system consists of several loosely coupled C# applications. Some components, the clients, have a WPF user interface. Some of the requirements are: easy to configure, extensibility and customization of the clients. It was decided to use modern design patterns like MVVM. It was also decided to create a composite clients. We could have created our own framework, but we decided to use one of the available frameworks: Prism 4.2 of Microsoft.

I learned that Visual Studio UI-designers are not essential for most of the development work. Blend is used by our UI-designers and the number of lines of code in the code behind code files is nearly zero. When implementing modern patterns like MV* (MVVM, MVC, MVP, etc. ), the tools should be great at designing UI’s and should have minimal integration with the code behind.

This leads to the conclusion that designer support of F# in not essential.

Prism 5

This year Prism 5 is released. As an experiment I want to build a real world application that consists of: Prism 5, XAML and F# an no C# code.

This application consists of 5 projects:

The shell, this is the container of the application.
Infrastructure, this is used to contain shared functionality between projects. It contains:
- Base classes
- Interfaces
- Internal services
and 3 modules:
- The Hello World module says hello to the world
- The Prime module to determine the primeness of input
- The message display module to show the results of the other modules

Components in Prism are called modules and these modules are not related to F# modules.

The final result looks like this:

Of course this is not really a real world application. It does not contain any really useful functionality and in a real world situations you could choose other ways to solve issues. I just kept it simple. I want to show how you could use Prism 5, its features together with F#.

Prism is a framework created by Microsoft patterns & practices. Prism is composite application framework. One of advantages of using a composite application is the reduction of complexity by separating concerns into functional components. Complexity increases linear with the number of components instead of quadratic and problems can simply be isolated. The details of Prism can be found at: Developer's Guide to Microsoft Prism Library 5.0 for WPF.

Prism 5 was released in April 2014. It replaces version 4.2. In the new release:

The dependency on Silverlight were removed.
Prism was modularized
Contains portable projects
Some components were replaced (the event aggregator) or a new (the ViewModelLocationProvider)

All the details of the changes can be found at: What's New in Prism Library 5.0 for WPF.

Hello World

In this first post I will port the Hello World from the Quickstarts of Prism to F#.

17: Getting Started Using the Prism Library 5.0 for WPF Hands-on Lab.

I will explain some details of the operation of Prism. Prism does contain a very detailed documentation, the missing details can be found over there. I will also discuss some F# language features. Prism is a framework created in c#, so we have to look at .NET classes, interfaces and inheritance.

Starting point of our port is the F# empty windows app (WPF) template. This template is created by Daniel Mohl:

F# Empty Windows App (WPF)

This template will enable us to use the XAML Type provider and it provides us the required assembly references.

After installing the VS template we use it to create a solution and a new project.

This project will contain the shell. The shell is the main component in a Prism solution. The shell does what it promises to do: it is a container and like most containers it is a simple box. It should have no knowledge of the content so the aim is to keep the shell as agnostic of its content as possible.

The Prism shell consists of three parts:

The view, this is UI part of the shell and is defined is XAML.
The app, this is the WPF functionality to manage the life time of the application.
The bootstrapper, this is the prism functionality to create the infrastructure so the modules can live.

Then we install the required Prism libraries from nugget:

Prism requires the use of dependency injection framework. It does not implements its own framework, provides two integrations:

One with Unity: https://unity.codeplex.com/
One with MEF (Managed Extensibility Framework): Managed Extensibility Framework (MEF)

Both are provided by Microsoft.

It is possible to build an integration with your own favorite dependency injection framework.

The Hello World Quickstart uses Unity.

Next we remove the ApplicationResources.xaml file and rename the MainWindow.xaml file to Shell.xaml.

The Shell.xaml is a simple:

<Window 
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:cal="http://www.codeplex.com/prism"
    Title="Hello World" Height="300" Width="300">
    <ItemsControl Name="MainRegion" cal:RegionManager.RegionName="MainRegion" />
</Window>

The XAML contains two Prism element:

The prism name space
A placeholder so modules can present their content and functionality.

Next we delete all content of the app file.

First we add the module name and the name spaces:

module MainApp

open System
open System.Windows
open System.Windows.Controls
open Microsoft.Practices.Prism.Modularity
open Microsoft.Practices.Prism.UnityExtensions
open FSharpx

Next we make the Shell view available as a type:

type Shell = XAML<"Shell.xaml">

Now we need to create two classes that reference each other. In F# we have to define these classes at the same time by adding and:

App inherits from the Application class, the WPF class manages the lifetime of the application and provide the WPF functionality.

In the derived class we override the OnStartUp method and create a new instance of the Bootstrapper and call the Run method.

The bootstrapper derives from the UnityBootstrapper which derives from the abstract Bootstrapper both part of Prism. The abstract Bootstrappper provides the generic functionality from Prism, the UnityBootstrapper implements the Unity specific functionality.

The bootstrapper has serveral methods that can be overwritten to adjust the bootstrapper. We start with overwriting CreateShell method and InitializeShell;

type App() =
    inherit Application()
        override x.OnStartup(e) =
            base.OnStartup(e)
            let bootstrapper = new DemoBootstrapper() 
            bootstrapper.Run()

and DemoBootstrapper() =
    inherit UnityBootstrapper()
    override x.CreateShell() = 
        let window = Shell()
        window.Root :> DependencyObject
    override x.InitializeShell() =
        base.InitializeShell()
        App.Current.MainWindow <- x.Shell :?> Window
        App.Current.MainWindow.Show()
    override x.ConfigureModuleCatalog() = 
        base.ConfigureModuleCatalog()
        let moduleCatalog = x.ModuleCatalog :?> ModuleCatalog
        moduleCatalog.AddModule(typeof<HelloWorldModule.HelloWorldModule>) |> ignore

We end with the start method:

[<STAThread>]
(new App()).Run()|> ignore

When we compile and run the application an empty shell is presented.

Next task: create a module that can be shown in the shell.

Create a new project of type F# Empty Windows App (WPF) and change the project output type to class library. One could start with a library project, in that case all required references have to be added by hand. Call the project HelloWorldModule.

Again we remove the ApplicationResources.xaml file and rename the MainWindow.xaml file. In this case to HelloWorldView.xaml.

Next we add references to the Prism dlls.

Again the XAML is very simple:

<UserControl
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
    <Grid>
        <TextBlock Text="Hello World" Foreground="Green" HorizontalAlignment="Center" VerticalAlignment="Center" FontFamily="Calibri" FontSize="24" FontWeight="Bold"></TextBlock>
    </Grid>
</UserControl>

It will show the green text: “Hello World”.

Again we remove all code from the App file. We add the name space and open the required namespaces

namespace HelloWorldModule

open System
open System.Windows
open System.Windows.Controls

open Microsoft.Practices.Prism.Modularity
open Microsoft.Practices.Prism.Regions
open Microsoft.Practices.Prism.Mvvm

open FSharpx

Next we add the XAML of the view as a type.

type HelloWorldXaml = XAML<"HelloWorldView.xaml">

Now we create the main object of the module: the HelloWordModuel. This is a class that implements the IModule interface of Prism. The interface has one method, Initialize. This method does all the work to make the module available.

In our case we need register the view and add it to the “MainRegion”. This is the region we defined in the shell. To be able to register the view, the module needs access the RegionViewRegistry. It gets this by receiving a reference from the constructor.

type HelloWorldModule(registry:IRegionViewRegistry) =
    let mutable regionViewRegistry = registry
    interface IModule with
        member x.Initialize() = regionViewRegistry.RegisterViewWithRegion("MainRegion", fun _ -> HelloWorldXaml().Root:> obj)

The module is ready for use. The last activity is to tell the shell the module exits. This can be done is several ways. The Hello World implementation takes to easy way by adapting the bootstrapper. We add an extra override to the boostrapper. This time we override ConfigureModuleCatalog by adding our HelloWorldModule. The module catalog contains all available modules.

type App() =
    inherit Application()
        override x.OnStartup(e) =
            base.OnStartup(e)
            let bootstrapper = new DemoBootstrapper() 
            bootstrapper.Run()

and DemoBootstrapper() =
    inherit UnityBootstrapper()
    override x.CreateShell() = 
        let window = Shell()
        window.Root :> DependencyObject
    override x.InitializeShell() =
        base.InitializeShell()
        App.Current.MainWindow <- x.Shell :?> Window
        App.Current.MainWindow.Show()
    override x.ConfigureModuleCatalog() = 
        base.ConfigureModuleCatalog()
        let moduleCatalog = x.ModuleCatalog :?> ModuleCatalog
        moduleCatalog.AddModule(typeof<HelloWorldModule.HelloWorldModule>) |> ignore

When we compile and run the application the Hello World Module is present, the green Hello World Text is shown.

This completes the port of the Hello World from the Quickstarts of Prism 5 to F#.

There is at least one problem with the Hello World implementation. The Shell has to have knowledge of the HelloWorldModule.

Next time we have a look how we can fix this. There are other ways to configure Module Catalog. If we use Managed Extensibility Framework (MEF) as the dependency injection framework we can even can reduce the configuration to copying module dlls into directory.

Updates:

I got a tweet from Reed Copsey (@ReedCopsey). He suggested to use FsXaml. By getting a version via Nuget:

replace the namespaces:

open FsXaml

and adjusting the creation of the view:

and DemoBootstrapper() =
    inherit UnityBootstrapper()
    override x.CreateShell() = 
        Shell().CreateRoot() :> DependencyObject
    override x.InitializeShell() =
        base.InitializeShell()
        App.Current.MainWindow <- x.Shell :?> Window
        App.Current.MainWindow.Show()
    override x.ConfigureModuleCatalog() = 
        base.ConfigureModuleCatalog()
        let moduleCatalog = x.ModuleCatalog :?> ModuleCatalog
        moduleCatalog.AddModule(typeof<HelloWorldModule.HelloWorldModule>) |> ignore

it works again.

I have posted the source code add FSharpPrism5.

Increase your productivity with F# scripts (part 2)

2013-06-17T15:46:00.001+02:00

Last post we discussed a real world problem, cleanup your test environment after a complex integration test. We used a F# script to do the work.

This time we look add more advanced scenario’s and solutions. First we want to split our script file into two files. One containing the scenario related code and one containing a library of facade function we want to reuse.

We start by creating a new script file in the Scripts directory calling it Lib.fsx and open the file with a text editor. Next we open also the script file we created last time and add the following lines of code:

#load "Lib.fsx"
open Lib

The first line links the script file to the newly created Lib file. The second line opens the namespace “Lib”, the default namespace of the functions in the Lib script file.

Next we move the facade functions (including the reference to the namespaces) to the Lib file.

After this refactoring everything still works the way it used to work.

Next want to create a startup script. Every time we start the laptop we want start with a clean log directory, we like a clean machine and second we want open a Visual Studio Solution so we can start coding immediately.

We start by creating a new script file called Startup.fsx and the following code:

#load "Lib.fsx"
open Lib

["E:\\Log"] |> List.iter(deleteContentOfDirectory)

Again we connect to Lib file and reuse the deleteContentOfDirectory function we created last time to clean the Log directory.

Next we create a new shortcut like we did the last time:

This time linking it to the Startup script.

After testing the script we move the shortcut to the following directory:

C:\Users\YourAccountName\AppData\Roaming\Microsoft\Windows\Start Menu\Programs\Startup

After we restart our machine, the Log directory is cleaned.

There are other ways to associate scripts with the startup. You can use the group policy if your version of Windows has access to it (gpedit.msc):

Next step is to open the Visual studio solution.

We add the following facade function to Lib.fsx

let startProcess fileName =
    let newProcess = new Process()
    newProcess.StartInfo.FileName <- fileName
    newProcess.Start() |> ignore

and the following line to the StartUp script

startProcess @"E:\VS\Test\Test.sln"

the next time you start up the log directory is clean and your Solution will be directly available.

Adding extra functionality to the scripts is now a trivial activity.

My Lib files contains, for example, exception handling and some reporting:

This will not stop the script in case a file can not be deleted. The exception will be reported to the console.

There are a lot of activities that can be automated, I have scripts that:

Start programs like a mail client.
Creating zipped backups of source code.
…

In this way I can improve my productivity with F# scripting. How can F# scripting increase your productivity?

Increase your productivity with F# scripts (part 1)

2013-06-13T16:23:00.001+02:00

One of the many nice features of F# is its scripting capability. There are other scripting languages like PowerShell to improve your productivity on a Windows system. In this case you need to learn a new language and a new environment to automate some basic tasks. When you know F# and .NET you can leverage your skills, so let’s look at F# scripting.

A simple real-world problem

I once was responsible for integration testing a complex set of applications. After completing the test several applications were still running so these processes had to be stopped with the Task Manager and several directories had to be cleaned. How could F# help me to be more productive?

Let’s start by creating a directory called Scripts, add a new text file and rename it to EndIntegrationTest.fsx.

open the file with your favorite text editor, I use Notepad++ in this case and

add the line:

System.Diagnostics.Process.GetProcessesByName("app1") |> Seq.iter(fun x -> x.Kill())

This will “kill” all programs that are called app1 by first looking for all processes called app1 and next kill them one by one.

I have set the Language menu to Caml to get some syntax highlighting.

Next we change the program associated with the file extension, right click:

Look for another app on this PC (this is Windows 8) and look for the following directory:

C:\Program Files (x86)\Microsoft SDKs\F#\3.0\Framework\v4.0

and select fsi.exe.

To test the script I created a C# console app and called it app1, start the executable in the debug directory

Open the script file and app1 will be killed (R.I.P. app1).

This scripting solution has some drawbacks which we will discuss later, but it works. It matches the first rule of scripting:

Keep your scripts as simple as possible.

Scripts should increase your productivity and you should not spend much time on debugging or creating functionality you do not need (YAGNI –> You aren't gonna need it).

In case I want to kill app1 I have to go to the scripting directory. I can become more productive if I add a shortcut to my desk

rename it “Shortcut_EndIntegrationTest” and move it to the desktop.

The next step is to change some of the properties of the shortcut, Shortcut key and Run,

After these changes all I have to do is press CRTL + ALT + 1 after the test is completed and the script runs without showing a console.

One of the drawbacks of the the created solution is that we have associated the .fsx extension with the fsi.exe. In this way we can run an F# script by accident when we just want to edit a file. With great power, comes great responsibility. We can fix this when associate the .fsx files with a text editor program and repair the shortcut. Also from a security perspective this is a better solution.

Go to General tab and associate .fsx with an editor

After apply the shortcut and all .fsx file will start the text editor.

Next change he target line to:

"C:\Program Files (x86)\Microsoft SDKs\F#\3.0\Framework\v4.0\Fsi.exe" "E:\Blog\Scripts\EndIntegrationTest.fsx”

and the shortcut will kill app1 again (you need to repair the shortcut key and the run mode).

This script does not solve all our problems, we have to be able to kill multiple applications and we have to clean all polluted directories.

We could copy the line that killed the application and change the name of the app, but there is a second scripting rule:

Do not repeat yourself (DRY).

So we create a facade function killProcesses:

open System.Diagnostics

let killProcesses processNames =
    Process.GetProcesses()
    |> Seq.filter(fun p ->
        processNames|> List.exists (fun name -> name = p.ProcessName))
    |> Seq.iter(fun x -> x.Kill())

and call it with a list of application name:

killProcesses ["app1"; "app2"]

this replaces the initial code.

CTRL + ALT + 1

and all are processes are killed.

Next we add the facade function to clean the directories:

let deleteContentOfDirectory path =
   Directory.EnumerateDirectories(path) |> Seq.iter(fun dir -> Directory.Delete(dir, true))
   Directory.EnumerateFiles(path) |> Seq.iter(File.Delete)

We enumerate through all content in the directory, sub directories and files and delete them all. We use the facade function to clean all required directories:

["E:\\CleanUpTest1"; "E:\\CleanUpTest2"] |> List.iter(deleteContentOfDirectory)

Before:

After:

So we have solved our real-world problem.

Next time we improve our solution by putting the facade functions in a library and we look at startup scripts.

Update:At a windows machine not containing F# Script (REPL), you can add it yourself. Here are all the details: A step by step guide to installing an F# REPL environment on Windows by Matthew Adams.

Windows Store Apps with F# (part 4) : Collections

2013-01-29T14:05:00.001+01:00

In the previous post we were introduced to data binding and MVVM. We dealt with one object. How can we deal with more than one object, a collection of objects?
This time we want to show a sequence of primes:

The first number is the sequence number, the second is the value of the prime. We want to show this sequence in a Windows Store App. We create again a new blank Windows Store App and add a F# Portable Library. We rename the F# file to Lib.fs. Let’s follow MVVM. We start with the Model. Add the IsPrime function to Lib.fs:

module MathLib
let IsPrime n =
     if n < 2L then
            false
        else
            seq{2L..n - 1L}
            |> Seq.exists(fun x -> n % x = 0L)
            |> not

Next we create an object to represent an element in the sequence:

type Element(sequenceNumber:int, value:int64) =
    member x.SequenceNumber = sequenceNumber
    member x.Value          = value

Now it is possible to create a function that will determine the next element in the sequence of primes: let rec nextPrime (element:Element) =
    if IsPrime (element.Value + 1L) then
            Element(element.SequenceNumber + 1, element.Value + 1L)
        else
            Element(element.SequenceNumber, element.Value + 1L) |> nextPrime

Next we create a sequence of all primes (details at page 320 of Real-World Functional Programming by Tomas Petricek and with Jon Skeet, buy this book!!):

let rec primeSequence =
    seq { yield Element(1,  2L)
          for e in primeSequence do yield e |> nextPrime }

and test the model by adding a test to the Script.fsx file.

#load "Lib.fs"
MathLib.primeSequence |> Seq.take 5 |> Seq.iter( fun r -> (printfn "%d. %d" r.SequenceNumber r.Value))

When we run the code in F# Interactive we get the expected result:

Compile the project and add a reference from the C# project to the F# project.

Next step: the Model. We contact the UI designer and he sends us the following XAML:

<GridView ItemsSource="{Binding}" >
    <GridView.ItemTemplate>
        <DataTemplate>
            <Grid>
                <Grid.ColumnDefinitions>
                    <ColumnDefinition />
                    <ColumnDefinition />
                    <ColumnDefinition />
                </Grid.ColumnDefinitions>

                <TextBlock Grid.Column="0"  Text="{Binding SequenceNumber}"/>
                <TextBlock Grid.Column="1"  Text="->"/>
                <TextBlock Grid.Column="2" Text="{Binding Value}"/>
            </Grid>
        </DataTemplate>
    </GridView.ItemTemplate>
</GridView>

We past it in the Grid of the MainPage. Gridview is one of the Windows Store App controls that can display collections.

Next we update the MainPage code behind:

using System.Collections.ObjectModel;

and

 public sealed partial class MainPage : Page
    {
        private ObservableCollection<MathLib.Element> Collection;
        
        public MainPage()
        {
            this.InitializeComponent();

            Collection = new ObservableCollection<MathLib.Element>()
                {
                    new MathLib.Element(1, 2),
                    new MathLib.Element(2, 3),
                    new MathLib.Element(3, 5),
                    new MathLib.Element(4, 7),
                    new MathLib.Element(5, 11)
                };

            this.DataContext = Collection;
        }

We have created an ObservableCollection class called Collection and added some elements so we can see the result of the binding.

F5:

It works as expected but it does not look good.

So we contact our designer again. This is the code he sends us:

<Grid Background="{StaticResource ApplicationPageBackgroundThemeBrush}">
    <TextBlock Text="Primes" HorizontalAlignment="Left" VerticalAlignment="Top" FontSize="42" Margin="80,40,0,0" />
    <GridView x:Name="ItemListView" ItemsSource="{Binding}" Margin="80, 100, 80, 80">
        <GridView.ItemsPanel>
            <ItemsPanelTemplate>
                <WrapGrid />
            </ItemsPanelTemplate>
        </GridView.ItemsPanel>
        <GridView.ItemTemplate>
            <DataTemplate>
                <Grid Width="200" Height="60" Background="Green">
                    <Grid.ColumnDefinitions>
                        <ColumnDefinition Width="60"/>
                        <ColumnDefinition Width="20"/>
                        <ColumnDefinition Width="120"/>
                    </Grid.ColumnDefinitions>

                    <TextBlock Grid.Column="0"  Text="{Binding SequenceNumber}"  HorizontalAlignment="Left"
                        VerticalAlignment="Top"
                        FontSize="15"
                        Foreground="Black"
                        Margin="5,5,5,5" />
                    <TextBlock Grid.Column="2" Text="{Binding Value}"  HorizontalAlignment="Left"
                        VerticalAlignment="Top"
                        FontSize="24"
                        Foreground="White"
                        Margin="5,5,5,5"/>
                </Grid>
            </DataTemplate>
        </GridView.ItemTemplate>
    </GridView>
</Grid>

and the result looks like this (replace the XAML and press F5):

We accept this design.

Remark: there are better ways to deal with design data in XAML: [WPF / MVVM] How to get data in “design time” ?

Now it is time to glue the Model and the View together, we will add the View Model code.

First we change the initialization of the Collection:

  Collection = new ObservableCollection<MathLib.Element>();

and add a new F# file to the F# project called ViewModel.

We add the following code:

module ViewModel
open System.Collections.ObjectModel
let addElements(collection:ObservableCollection<MathLib.Element>) =
    collection.Clear()
    MathLib.primeSequence |> Seq.iter collection.Add

Build the solution and add the following code to event handler OnNavigatedTo of the MainPage:

protected override void OnNavigatedTo(NavigationEventArgs e)
{
    ViewModel.addElements(this.Collection);
}

F5 and the application never shows the Main Page:

When we reduce the number of elements to 100

let addElements(collection:ObservableCollection<MathLib.Element>) =
    collection.Clear()
    MathLib.primeSequence|> Seq.take 100 |> Seq.iter collection.Add

we get the expected result.

This solution will not work when we want to display a very large number of primes.

So we go the async/await way again.

protected async override void OnNavigatedTo(NavigationEventArgs e)
{
    await ViewModel.addElementsTask(this.Collection);
}

and change the ViewModel

module ViewModel
open System.Collections.ObjectModelopen System.Threading.Tasks
let addElements(collection:ObservableCollection<MathLib.Element>) =
    MathLib.primeSequence|> Seq.iter collection.Add

let addElementsTask(collection:ObservableCollection<MathLib.Element>) =
     collection.Clear()

Task.Factory.StartNew(fun _ -> addElements collection);

This time we get error messages:

The C# project needs a reference to the F# library. We will not go that way, we solve the issue by creating a Task of int and add a dummy return value.

module ViewModel
open System.Collections.ObjectModelopen System.Threading.Tasks
let addElements(collection:ObservableCollection<MathLib.Element>) = 
    MathLib.primeSequence |> Seq.iter collection.Add

let addElementsTask(collection:ObservableCollection<MathLib.Element>) =
     collection.Clear()
     Task<int>.Factory.StartNew(fun _ ->
                                addElements(collection)
                                0)

F5 again. This time we get an context exception.

So we add the context to the functions.

 protected async override void OnNavigatedTo(NavigationEventArgs e)
        {
            await ViewModel.addElementsTask(this.Collection, System.Threading.SynchronizationContext.Current);
        }

and

module ViewModel
open System.Collections.ObjectModelopen System.Threadingopen System.Threading.Tasks
let addElements(collection:ObservableCollection<MathLib.Element>, context:SynchronizationContext) =
     MathLib.primeSequence |> Seq.iter(fun x -> context.Post((fun _ -> collection.Add(x)) ,null))
let addElementsTask(collection:ObservableCollection<MathLib.Element>, context:SynchronizationContext) =
     collection.Clear()
     Task<int>.Factory.StartNew(fun _ ->
                                addElements(collection,context)
                                0)

and we get the desired result:

We end with two small remarks:

In this post we used the ObservableCollection, this is a .NET solution. The WinRT way is to use IObservableVector<T>.

We can replace addElementsTask by

let addElementsTaskMutable (collection:ObservableCollection<MathLib.Element>, synchronizationContext:SynchronizationContext) =
    collection.Clear()
    Task<int>.Factory.StartNew(
        fun _ -> 
        let mutable e = MathLib.Element(0,  1L)
        while true do
            e <- MathLib.nextPrime e
            let x = e  //make the result immutable
            synchronizationContext.Post((fun _ -> collection.Add(x)) ,null)
        0       
        )

This seems to improve the performance of the application quit a lot.

Windows Store Apps with F# (part 3) : Data Binding and MVVM

2013-01-28T10:07:00.001+01:00

In this series of posts we investigate the interoperability between WinRT and F#. In the previous post we solved some issues by adding input checking and async event handling. Our code still contained C# code. We can ride of some of the C# code by data binding.
Data binding connects XAML code directly with .NET objects. Let’s create a simple example.
Open the project we have created in part 1 and updated in part 2 and add a F# file called Process. We add the namespace MathLib and create an object Process.

namespace MathLib
type Process() =
    let mutable _output = "output"

    member x.Output
        with get() = _output
        and set(v) =
            _output <- v

and rebuild the project so the Process object becomes available in the C# project.

To the C# code of the MainPage we add a process variable, create a new Process object. We add it to the DataContext of the MainPage:

Process process;
public MainPage()
{
    this.InitializeComponent();
    process = new Process();
    this.DataContext = process;
}

and change the MainPage.xaml: Text="{Binding Output}"

<TextBlock Grid.Row="3" Grid.Column="1" Grid.ColumnSpan="3"  
            x:Name="result" 
            Style="{StaticResource FSharp}" 
            Text="{Binding Output}"
            />

F5 and this is the result.

The initial value of the Process object (“output”) is shown at the location of the result TextBlock.

Next we at an extra property to Process object.

namespace MathLib
type Process() =
    let mutable _input = "input"
    let mutable _output = "output"

    member x.Input
        with get() = _input
        and set(v) =
            _input <- v

    member x.Output
        with get() = _output
        and set(v) =
            _output <- v

And add a Execute method.

     member x.Execute() = 
        x.Output <- _input |> MathLib.Wrapper.IsPrimeText

And change the XAML of the TextBox

<TextBox Grid.Row="1" Grid.Column="3"                  
            x:Name="inputValue"                 
            FontFamily="Verdana" 
            FontSize="32"
            Text="{Binding Path=Input, Mode=TwoWay}"
            />

We change the code of the event handler:

private void OnClick(object sender, RoutedEventArgs e)
{
    process.Execute();
    result.Text = process.Output;
}

and test the result by entering “12” as input and click the button.

So by adding “Mode=TwoWay” the input value of the TextBox is transferred back to the Input property of the Process object.

Let’s change the event handler, let’s remove the last line:

private void OnClick(object sender, RoutedEventArgs e)
{
    process.Execute();
}

and test again.

This time the result is not updated. We have to notify the XAML that things have changed.

We can tell the XAML that things have changed by implementing the INotifyPropertyChanged interface. This is a simple interface, it has one method: PropertyChanged.

We could write this code ourselves, or we could leverage what is already available (standing on the shoulders of giants). So let’s enter MVVM (Model View ViewModel).

There are several related architectural patterns MVP, MVC, MVVM. They all prescribe the way separation of concerns is implemented a rich user interface application.

So the main theme is separation of concerns. In the case of MVVM we have:

Model. This is all the code that does not care about the presentation. It contains all code that is unaware of users interacting with the system, so we could create several ways of presenting the model to the user: WPF, Windows Store App, internet website, etc., in all cases the model stays the same. So the model could contain:
- all business logic
- all persistence related logic
In our example the model is managed by a mathematician. He is the domain expert and knows everything about primes.
View. This is the presentation layer. It describes the look and feel of the application. The aim is to create declarative code like XAML and reduce the code in the code behind as much as possible.
In our example the view is managed by a UI designer. He has chosen the red color and the font.
View Model. This is the bridge between the model and view. Imaging the model and view are already available. We know what it the App looks like and all business and persistence logic is created. All code required to make the application complete will be part of the View Model.

This is where we are right know in our example. To complete the application we have to create View Model code. We could write this code ourselves, or we could leverage what is already available.

There are several MVVM frame works available: MVVVM Frameworks.

Of course we go for the F# option: FSharpWpfMvvmTemplate by Dan Mohl. This template was not created with WinRT in mind, so we have to be careful.

Create a new base class in the F# project called “ViewModelBase.fs” and copy the code for the template project:

//https://github.com/dmohl/FSharpWpfMvvmTemplate
namespace FSharpWpfMvvmTemplate.ViewModel
open Systemopen System.Windowsopen System.Windows.Inputopen System.ComponentModel
type ViewModelBase() =
    let propertyChangedEvent = new DelegateEvent<PropertyChangedEventHandler>()
    interface INotifyPropertyChanged with
        [<CLIEvent>]
        member x.PropertyChanged = propertyChangedEvent.Publish
    member x.OnPropertyChanged propertyName = 
        propertyChangedEvent.Trigger([| x; new PropertyChangedEventArgs(propertyName) |])

And change the code of the Process class:

namespace MathLib
open  FSharpWpfMvvmTemplate.ViewModel
type Process() =
    inherit ViewModelBase()
    let mutable _input = "input"
    let mutable _output = "output"

    member x.Input
        with get() = _input
        and set(v) =
            _input <- v
            x.OnPropertyChanged("Input")

    member x.Output
        with get() = _output
        and set(v) =
            _output <- v
            x.OnPropertyChanged("Output")

     member x.Execute() =
        x.Output <- MathLib.Wrapper.IsPrimeText _input

we derive the Process class from the ViewModelBase class and raise the OnPropertyChanged event when the value of one of the properties is changed.

We have to move the Process file to it’s correct place in the project to let it compile:

The result:

So it works. We have now two issues to solve:

The code we created can not deal with log running calculations. Just enter 756771235126757131 and the UI freezes.
We still have an event handler, the button click. Is there a better way to deal with this so we can write the what happen after we click the button with F# code?

We solve the second issue first. Again MVVM comes to the rescue. We can bind a Command to the button. A Command is a class that implements the ICommand interface. We copy again from FSharpWpfMvvmTemplate. Create a new F# file and call it RelayCommand and copy the code:

//https://github.com/dmohl/FSharpWpfMvvmTemplatenamespace FSharpWpfMvvmTemplate.ViewModel
open Systemopen System.Windowsopen System.Windows.Inputopen System.ComponentModel
type RelayCommand (canExecute:(obj -> bool), action:(obj -> unit)) =
    let event = new DelegateEvent<EventHandler>()
    interface ICommand with
        [<CLIEvent>]
        member x.CanExecuteChanged = event.Publish
        member x.CanExecute arg = canExecute(arg)
        member x.Execute arg = action(arg)

Replace the Execute method Process file by the ExecuteCommand:

     member x.ExcecuteCommand = 
            new RelayCommand ((fun canExecute -> true), 
                (fun action -> 
                    x.Output <- x.Input |> Wrapper.IsPrimeText ))

Remove the event handler in the code behind and change the XAML of the button into:

<Button Grid.Row="2" Grid.Column="1" Grid.ColumnSpan="3" 
        Content="Is it a prime?"
        x:Name="calculate" 
        HorizontalAlignment="Center" VerticalAlignment="Center" 
        Foreground="#FFE68484" FontFamily="Verdana" FontSize="32" 
        Command="{Binding ExcecuteCommand}"/>

We deleted the Click handler and add the binding of the Command.

F5 and the app works the way it worked, this time without the C# event handler and with F# Command.

To solve the first issue, dealing with long running calculations we change the code of the Command:

     member x.ExcecuteCommand = 
            new RelayCommand ((fun canExecute -> true), 
                (fun action -> 
                    let task = x.Input |> Wrapper.IsPrimeTask 
                    x.Output <- task.Result))

in this case task wrapper to perform the code asynchronous.

So everything works fine again.

Let’s end with two remarks, the first is related with MVVM, the second with F# async.

From our solution it is not clear how we dealt with separation of concerns.

In our case we have a very small model, it contains just the IsPrime function. The View is the C# project and so the remaining F# code has to be the View Model: the wrappers, the Process class, the ViewModelBase and the RelayCommand are all part of the glue we needed to make the IsPrime function available for the user interface. In a real world project we have to make the structure explicate.

In stead of using a Task we could use the F# async workflow. So let’s replace the ExecuteCommand by

     member x.ExcecuteCommand = 
            new RelayCommand ((fun canExecute -> true), 
                 (fun action ->
                    let execute = 
                        async { 
                            x.Output <-Wrapper.IsPrimeText(x.Input)
                         }
                    execute |> Async.Start
                        ))

F5 and enter a value un the TextBox. We get an exception:

The Dutch inner exception message tell us that we used the wrong thread to update the UI.

We can fix this changing the ViewModelBase. We capture the context at initialization and Post at the context.

type ViewModelBase() =
    //capture the context of the UI
    let context = System.Threading.SynchronizationContext.Current
    let propertyChangedEvent = new DelegateEvent<PropertyChangedEventHandler>()
    interface INotifyPropertyChanged with
        [<CLIEvent>]
        member x.PropertyChanged = propertyChangedEvent.Publish
    member x.OnPropertyChanged propertyName = 
        //Post at the right thread
        context.Post(( fun _ -> propertyChangedEvent.Trigger([| x; new PropertyChangedEventArgs(propertyName) |])), null)

After the fix everything works fine again.

The next post we discuss dealing with collections from a XAML F# perspective.

Windows Store Apps with F# (part 2) : async/await

2013-01-24T16:35:00.001+01:00

In my last post we created an windows apps and discussed the F# and C#/XAML interoperability. We discovered two issue:

Long running calculations made the UI frees.
The improper handling of the input made the app crash.

The way we deal with issues is an architectural decision. One can choose to have a slim F# library. The only responsibility is to handle the business logic, nothing else. In our case this is a math library. There is nothing wrong with decision, the other concerns are handled at the C#/XAML site by C# developers and XAML designers. We could resolve the first issue by wrapping the calculation in a task and await it. We could solve the input issues by writing a handler that will handle TextBox TextChanged event.
If this is your decision the post ends here.
Or we could decide to minimize the C# code and solve all issues at the F# site. That is the way we will continue.
We start by where we left last time.
We first fix the second issue.
We delete in the MainPage XAML the last two TextBlocks and add a new one:

<TextBlock Grid.Row="3" Grid.Column="1" Grid.ColumnSpan="3"  x:Name="result" Style="{StaticResource FSharp}" />

and add a text wrapper function to a new F# file called Wrapper.

module MathLib.Wrapper
open System
let IsPrimeText text = 
    let success, number = Int64.TryParse(text)
    if success then 
        if Prime.IsPrime number then
                number.ToString() + " is a prime number"
            else
                number.ToString() + " is not a prime number"
     else
            text + " is not a valid number"

Now we can change the OnClick event handler in

private void OnClick(object sender, RoutedEventArgs e)
{
    result.Text = Wrapper.IsPrimeText(inputValue.Text);
}

All the code to handle the text input and displaying the result are now in the wrapper. Text input does not crash the app.

In a real project we could put more logic to del with input in the wrapper functions.

Next we have to deal with long running calculations. The new C# way is to use async/await. so we add async to the OnClick handler. We get a warning.

The warning tells us that we need to await something, and this should be a Task.

So we create a second F# wrapper:

open System.Threading.Tasks
let IsPrimeTask text =
    Task<string>.Factory.StartNew(fun _ -> IsPrimeText text)

And call this function with await:

private async void OnClick(object sender, RoutedEventArgs e)
{
    result.Text = "start";
    result.Text = await Wrapper.IsPrimeTask(inputValue.Text);
}

When we start the application and check 756771235126757131.

The task is started and we can still update the UI. So the issues are solved.

Remark: This works because it is .NET interoperability. One should use the WinRT the interface IAsyncOperation<string>.

private async void OnClick(object sender, RoutedEventArgs e)
{
    result.Text = "start";
    IAsyncOperation<string> operation = Wrapper.IsPrimeTask(inputValue.Text).AsAsyncOperation<string>();


    result.Text = await operation;
}

This interface does not seem to be available in the F# library. Fortunately we can not reference a F# Portable Library in a JavaScript App:

So this is not an issue at the moment.

Next time we will look for ways to get ride op the event handling code by looking at data binding and MVVM.

Windows Store Apps with F# (part 1) : Make things as simple as possible, but not simpler.

2013-01-23T20:32:00.001+01:00

During the initial phase of the Windows 8 beta period it was not possible to integrate F# code in a Windows 8 store app. After the final release of Visual Studio 2012 it is possible to create hybrid projects. In this series of posts I want to show you some of the projects I use to experiment with F# and Windows App Store integration.
I will focus on the interoperability and assume that you are able to find resources to learn the details of XAML, Windows 8 store apps and F#.

In the first example we create a simple solution and just add some F# code.
The F# code will determine if a number is a prime number. The App UI should have a text box to enter a value, a button to start the check and a text block to display the result.
We start by creating a blank windows store app:

Open the created main page

and start designing the layout of the page.

    <Page.Resources>
        <Style x:Key="FSharp" TargetType="TextBlock" BasedOn="{StaticResource BasicTextStyle}">
            <Setter Property="FontFamily" Value="Verdana"/>
            <Setter Property="FontSize" Value="32"/>
        </Style>
    </Page.Resources>

Next we change the color of the grid and add some columns and rows:

 <Grid Background="#FF8F0A0A">
        <Grid.ColumnDefinitions>
            <ColumnDefinition Width="10*"/>
            <ColumnDefinition Width="200"/>
            <ColumnDefinition Width="100"/>
            <ColumnDefinition Width="300"/>
            <ColumnDefinition Width="20*"/>
        </Grid.ColumnDefinitions>
        <Grid.RowDefinitions>
            <RowDefinition Height="10*"/>
            <RowDefinition Height="50"/>
            <RowDefinition Height="100"/>
            <RowDefinition Height="50"/>
            <RowDefinition Height="20*"/>
        </Grid.RowDefinitions>

And finally add the controls to the grid:

  <TextBlock Grid.Row="1" Grid.Column="1"
                   Text="Input value:" 
                   Style="{StaticResource FSharp}"/>

        <TextBox Grid.Row="1" Grid.Column="3" 
                 x:Name="inputValue" 
                 FontFamily="Verdana" FontSize="32" />

        <Button Grid.Row="2" Grid.Column="1"
                Grid.ColumnSpan="3"
                Content="Is it a prime?" x:Name="calculate"
                HorizontalAlignment="Center" VerticalAlignment="Center"
                Foreground="#FFE68484"
                FontFamily="Verdana" FontSize="32"/>
        
        <TextBlock Grid.Row="3" Grid.Column="1"
                   Text="Result:"
                   Style="{StaticResource FSharp}"/>
        
        <TextBlock Grid.Row="3" Grid.Column="3"
                   x:Name="result"
                   Style="{StaticResource FSharp}" />

This is page in de designer:

Now is time to add the F# code. We add an F# Portable Library call “MathLib” to the solution.

Rename PortableLibrary1 to Lib and delete the Script file.

And add the F# code to the Lib file:

module MathLib.Prime
let IsPrime n =
     if n < 2L then
            false
        else
            seq { 2L .. n - 1L}
            |> Seq.exists(fun x -> n % x = 0L)
            |> not

This is not the most sophisticated prime check but it will do for our projects.

We have created a module we can use MathLib is the namespace, Prime is a static class and IsPrime is a static function.

The code i in line with the definition of a prime number: A prime number (or a prime) is a natural number greater than 1 that has no positive divisors other than 1 and itself.

Now we have to create interoperability. We add a reference to the MathLib project:

and build the solution. This will make the meta data of the MathLib project available for the WinRTFSharpSimple project.

Next we create add a button click event:

 <Button Grid.Row="2" Grid.Column="1"
                Grid.ColumnSpan="3"
                Content="Is it a prime?" x:Name="calculate"
                HorizontalAlignment="Center" VerticalAlignment="Center"
                Foreground="#FFE68484"
                FontFamily="Verdana" FontSize="32" Click="OnClick"/>

and add an handler at the code behind:

private voidOnClick(objectsender,RoutedEventArgs e)
{
result.Text =Prime.IsPrime(Convert.ToInt64(inputValue.Text)).ToString();
}

and add a namespace:

Time to test the app, F5:

This looks fine.

In case we enter 756771235126757131

the app freezes and we can not interact with the app (issue 1).

In case we enter “abc” the app crashes (issue 2).

How could we solve these issues?

We can fix them at the C# site or we could fix the at F# site, both are possible. In the next post I will discuss a solution at the F# site.

Update of the F# reading list

2012-09-30T19:08:00.001+02:00

I have updated the F# list at http://www.amazon.co.uk/: http://www.amazon.co.uk/F-and-functional-programming/lm/R14JYBWI11LWQS/ref=cm_srch_res_rpli_alt_3.

There is two new books:

F# for C# Developers by Tao Liu, an engineer on the F# team
Functional Programming in F# by Tomas Petricek and Jan Stoklasa

and 2 updated versions:

Programming F# 3.0 by Chris Smith (http://www.amazon.com/Programming-F-3-0-Chris-Smith/dp/1449320295/ref=pd_sim_sbs_b_1)
Expert F# 3.0 by Don Syme, Adam Granicz, Antonio Cisternino (http://www.amazon.com/Expert-F-3-0-Don-Syme/dp/1430246502/ref=pd_bxgy_b_img_y)

Dutch article: Monads voor de .NET-ontwikkelaar is available at the SDN site

2012-01-30T21:11:00.001+01:00

I have written an article for the Dutch developer magazine of SDN (Magazine 111). It is titled: “Monads voor de .NET-ontwikkelaar”. It is now on line: http://www.sdn.nl/SDN/Artikelen/tabid/58/view/View/ArticleID/3206/Monads-voor-de-NET-ontwikkelaar.aspx.

I have tried to read the English version by Google translate. This is not a very good translation. I do not recommend to read it this translation. The German version is even worse. It contains Engels words that are not part of the Dutch version.

BCL Team Blog provides more information on code reuse (Portable Libraries part 4)

2011-10-04T11:41:00.001+02:00

Today the BCL Team Blog addressed the issue of code reuse: Porting existing .NET code to Metro style apps

"One of the things we know people want to do is reuse existing .NET code but due to the constraints on Metro style apps it is not possible to directly reuse existing .NET class libraries nor is it always possible to simply recompile existing code. We realize this is going to be a pain point for many current .NET developers so we are working on a guide at the .NET for Metro style apps overview page which will assist developers in translating their existing .NET skill set into the Metro style apps world.”

Bringing existing managed code into Metro style apps" by Daniel Plaisted is a recommended resource.

Daniel ports a windows phone app to a Metro app. Most of presentation is mainly about porting the UI.

Some slides from the presentation:

Getting the pictures from a local folder.

There is no database access.

.NET portability is not an afterthought (adding another layer of indirection - Portable Libraries part 3)

2011-09-28T11:40:00.001+02:00

Before //build/ I was not aware of the Portable Class Libraries Project. The origin of the project is the notion that the number of platform that provide .NET support has increased from one to four and that this number will increase in the future. Making .NET available on more platforms is the future of .NET.

The Portable Class Libraries Project was the first attempt of solving the portability issue but it ran into some constraints. One of them was the increasing complexity: “Portability is an afterthought”.

After watching some of the presentation at //build/ and experimenting with Visual Studio Express for Windows Developer Preview I thought that the whole purpose of creating a portable library was to bridge the gap between .NET and the WinRT.

This is not the case. Yesterday I watched .NET 4.5: Portable Libraries by David Kean and Mircea Trofin at Channel 9. It all made more sense to me.

The show:

The first 15 minutes explains portability and the first version of the Portable Class Libraries Project.
15:00 whiteboard time.
Explaining the first way to solve portability problem:
Explaining the problems with System.NET
22:00 the new solution: one portable library by design.
Portability is not an afterthought
28:00
- You program against a contract
- It is up to the platform to implement the contract
- Type forwarding:
- You program against the exposed api.
- And the GAC will forward to dll that implements the actual code.
- 33:00 Portability is a first class citizen
35:00 It is about granularity a method is too small a dll is too big.
36:00
- Q: Are there two gacs in the Windows 8 world?
- A: there is one gac. The metro mode is under “us”.
37:00 breaking changes:
- Type
45:00 Close and Dispose. Close is disposed, no more closing just disposing.
They reference: A .NET developer's view of Windows 8 app development by Krzysztof Cwalina
50:00 .NET has a great future with portability in mind.

So it makes sense to fix and recompile your legacy libraries. You can port them to all platforms that will have .NET available.

Reuse of legacy software by WinRT and Metro (Windows 8) (Portable Libraries part 2)

2011-09-22T11:22:00.002+02:00

This is a follow up to my previous post Create a Metro App in F# (NOT).

Things become quit complex if you want to reuse your windows legacy software. In this case legacy has a positive connotation. Legacy software is an asset of you and/or your company.

Suppose one want to reuse it and make it available for a Metro app on Windows 8 what are your options? After watching some of the build presentations:

Windows Runtime internals: understanding "Hello World" by Matt Merry
Being pragmatic by leveraging existing code in Metro style apps by Jason Olson
A .NET developer's view of Windows 8 app development by Krzysztof Cwalina
Ten Tips When Writing a Hybrid Language Metro style Application by Brent Rector
Using the Windows Runtime from C# and Visual Basic by Harry Pierson and Jesse Kaplan

I came up with the following flow chart:

So:

You can reuse html, css and JavaScript.
I am not an expert on C++, COM, etc. so I do not know.
If you have only a dll you cannot use it.
If you have source code that references a language dll (like F#) or have no options today. This will change when the final product becomes available.
If you want to create a Metro Style project in C++ or JavaScript you can reuse your components code by fixing issues and recompile it to a WinMD file (WinRT component). Some issues can be exposing:
- non WinRT types
- non sealed classes
- non system provided generic types
If you want to create a Metro Style project and this is one of the .NET languages you can reuse your components code by fixing issues and recompile it to a dll. Some issues can be:
- Streams

Disclaimer: This is my current understanding, based on the presentations I viewed. If you have other information available please leave a note in the comments.

Create a Metro App in F# (NOT) (Portable Libraries part 1)

2011-09-21T01:54:00.001+02:00

update January 24, 2013: you are now able to create “Metro apps”: Windows Store Apps with F# (part 1) : Make things as simple as possible, but not simpler.

Today you can follow the all-F# approach (Build MVVM Applications in F#). This is not the easiest way to build a solution, it is not the preferred way, but it is an option.
Don Syme presented last Friday in his build talk the following slide.

When he explained this it was not completely clear to me what this meant.
Does this tell us that we cannot create a F# Metro front-end today but we will when F# 3.0 is ready? Or does this mean that you cannot create a F# 3.0 project and reference it from a C# or a VB Metro front-end app in one solution?
Today I watched some other presentations of day 4 of build:
Windows Runtime internals: understanding "Hello World" by Matt Merry
Being pragmatic by leveraging existing code in Metro style apps by Jason Olson
A .NET developer's view of Windows 8 app development by Krzysztof Cwalina
Ten Tips When Writing a Hybrid Language Metro style Application by Brent Rector
Using the Windows Runtime from C# and Visual Basic by Harry Pierson and Jesse Kaplan
and experimented with Visual Studio 11 (Developer Preview and Express for Windows Developer Preview).
It became clear to me that you cannot create a Metro style solution that references a project that references .NET dll's that are not part of the .NET Profile for Metro style apps.

The F# dll is one of them today. So creating a Metro app in C#/VB/C++/JavaScript that references a F# project is not possible.
This should be possible when F# 3.0 becomes available. Will it be possible to create an all-F# Metro app in the F# 3.0 time frame? For me, this is still an unanswered question.

Another consequence of this approach: when you intend to reuse your .NET dll's you have to recompile your code as WinMD files. So you need to own the source code.
This are the restrictions:

Update(September 21, 2011):

F# type providers: oData from NuGet

2011-09-15T10:39:00.001+02:00

Yesterday F# 3.0 Developer Preview became available at the MSDN Site. It will be general available on Friday.

One of the new features is the type provider.

This little snippet shows how easy it is to query a site that provides oData. NuGet is an example of a site that provides oData.

Code Snippet
 #r "FSharp.Data.TypeProviders.dll"  
#r "System.Data.Services.Client.dll"  
  
open Microsoft.FSharp.Data.TypeProviders  
  
[<Generate>]  
type NuGet = ODataService<"http://packages.nuget.org/v1/FeedService.svc/">  
  
let dbNuGet = NuGet.GetDataContext()  
let packages = dbNuGet.Packages  
  
let nuGetQuery =  
    query { for package in packages do  
            where (package.Tags.Contains("fsharp") && package.IsLatestVersion)  
            select package }  
  
let printPackage (package:NuGet.ServiceTypes.PublishedPackage) =  
    printfn "- - - - - - - - - - - - - - - - - - - -"  
    printfn "Title: %s" package.Title  
    printfn "Authors: %s" package.Authors  
    printfn "Description: %s" package.Description  
  
       
nuGetQuery |> Seq.iter printPackage 

This is the result:

One of the nice features of type providers is intellisense for the available types.

It is possible to create your own type provider.

More information will be available on Friday. Don Syme will present all the details at build: http://channel9.msdn.com/events/BUILD/BUILD2011/SAC-904T

update: Writing F# Type Providers with the F# 3.0 Developer Preview - An Introductory Guide and Samples

Monads for .NET developers

2011-09-01T14:27:00.001+02:00

I have written an article for the Dutch developer magazine of SDN (Magazine 111). It is titled: “Monads voor de .NET-ontwikkelaar”.

In this post I will list some of the available resources on monads for .NET developers:

C# resources

Books:

Tomas Petricek & Jon Skeet: Real World Functional Programming: With Examples in F# and C#, website
Oliver Sturm: Functional Programming in C#: Classic Programming Techniques for Modern Projects, website

Web:

Wes Dyer: The marvels of monads
Mike Hadlow: Monads in C#–1. Introduction.
Derick Bailey: Monads in C#: Which Part Is The Monad?
Matthew Podwysocki: Functional .NET - LINQ or Language Integrated Monads?
Tomas Petricek: Beyond the Monad fashion (I.): Writing idioms in LINQ
Mauricio Scheffer: Refactoring to monadic C#
Erik Meijer: The World According to LINQ

F# resources

Computation Expressions are addressed in most of the available F# books (Professional F# 2.0 does not): F# and functional programming

The newbie feeling

2011-08-22T13:42:00.001+02:00

I read a blog post:http://blog.recursivity.com/post/9204470867/the-problem-with-the-scala-community that triggered me to write this post.

I do not know the Scala community so I can not agree or disagree with the conclusion:

“I love the Scala community and the eco-system around the language, but quite frankly, to foster the continued growth of the community, we need to call out the small minority of bullies on their bullshit whenever it occurs: being able to confuse and intellectually intimidate newbies to the language and community is not proving your supposed “intellectual superiority”, it is merely a reflection of an insecure ego and social incompetence.”

I do think that as a person we can not know everything of everything and even if we could one moment in time the world will change and we have to learn the new thing.

So we have two option: stick with what we know or accept the newbie feeling.

When you are a newbie you will make mistakes. My grant parents had the following text on a tile:”The only man who never makes mistakes is the man who never does anything.” I just found out it is a quote from Theodore Roosevelt (thanks Google).

So if we want to progress we have to accept the newbie feeling, accept the insecurity and make mistakes.

When we want to progress we have several options, one option is to learn it all by yourself, another is to accept the support of the community.

The community can support you in two ways:

one is provide knowledge
the other to provide mentorship

I think a programming language community is able to provide knowledge, that is nature of the community. To provide mentorship is something else and it is very hard to provide it on line.

So as a newbie look for knowledge on line and find mentorship somewhere else.

The difference between SelectMany and Select in LINQ

2011-08-07T15:20:00.001+02:00

This is follow up on my previous blog post:Adding xml strings in C# using LINQ.

In the previous post I showed that LINQ can be used to to manipulate XElements and strings. LINQ managed the transformation between the classes.

XElement result =
  from x1 in el1
  from x2 in el2
  select x1.Substring(0, x1.LastIndexOf("<")) + x2.Substring(x2.IndexOf(">") + 1);

el1, el2 and the result are XElements and x1, x2 and the object before select are strings.

In the example there are two XElements and the compiler requires that we implement SelectMany. If delete SelectMany we get the following error:

In case we have one XElement we expect that the following will compile:

private static XElement ToUpper(XElement el)
{
  XElement result =
  from x in el
  select x.ToUpper();

  return result;
}

It does not: “'System.Xml.Linq.XElement' does not contain a definition for 'Select'”

So we implement Select:

public static XElement Select(this XElement el, Func<string, XElement> f)
{
  return SelectMany(el, f, (x, y) => y);
}

Again it does not compile: “Cannot implicitly convert type 'string' to 'System.Xml.Linq.XElement'”

So we add an extra conversion:

private static XElement ToUpper(XElement el)
{
  XElement result =
  from x in el
  select XElement.Parse(x.ToUpper());

  return result;
}

This time it works:

var el = XElement.Parse("<a><b>1</b><b>2</b></a>");
Console.WriteLine(string.Format("ToUpper: {0}", ToUpper(el)));

Results in:

as expected.

Another way to solve the issue is to add a dummy line and use SelectMany:

private static XElement ToUpper(XElement el)
{
  XElement result =
  from x in el
  from dummy in XElement.Parse("<dummy></dummy>")
  select x.ToUpper();

  return result;
}

with the same result.

Update: more information at: http://msdn.microsoft.com/en-us/library/bb546168.aspx

Adding xml strings in C# using LINQ

2011-08-07T14:40:00.001+02:00

This is follow up on my previous blog post:Adding xml strings in F# using computation expressions. The text is nearly identical, the language is C# instead of F#.

In some cases classes are enhanced wrappers of simple classes. For instance in .NET:

DateTime is a point in time and provides, among others things, extra functionality related to representing date and time formats.
XElement is an xml string and provides, among others things, checks to determine the validity of the xml string.
Option can contain a value and can tell you if there is value available.

Sometimes you have to deal with underling class and reuse some of the functionality of the wrapper. In this case you could consider using LINQ. We first define the Return, Bind and SelectMany functions to create the required functions.

For details more details see:

All excellent resources.

public static classXmlMonad
{
//monad
public staticXElement Return(this stringtext)
{
    try
   {
      returnXElement.Parse(text);
    }
    catch(XmlException exc)
    {
      returnXElement.Parse(String.Format("<XmlException>{0}</XmlException>", exc.Message));
    }
}

public staticXElement Bind(thisXElement el, Func<string, XElement> f)
{
    try
   {
      returnf(el.ToString());
    }
    catch(XmlException exc)
    {
      returnXElement.Parse(String.Format("<XmlException>{0}</XmlException>", exc.Message));
    }
}

public staticXElement SelectMany(thisXElement el, Func<string, XElement> f, Func<string, string, string> select)
{
    returnel.Bind(text => f(text).Bind(x => select(text, x).Return()));
}
}

We can now define a add function that will xml elements by using a string manipulation:

private static XElement Add(XElement el1, XElement el2)
{
  XElement result =
  from x1 in el1
  from x2 in el2
  select x1.Substring(0, x1.LastIndexOf("<")) + x2.Substring(x2.IndexOf(">") + 1);

  return result;
}

Add in action:

var el1 = XElement.Parse("<a><b>1</b><b>2</b></a>");
var el2 = XElement.Parse("<a><b>3</b><b>4</b></a>");

Console.WriteLine(string.Format("Add: {0}", Add(el1,el2)));

Results in:

When we change the xml into:

var el2 = XElement.Parse("<c><b>3</b><b>4</b></c>");

The result is:

Adding xml strings in F# using computation expressions

2011-08-04T15:19:00.001+02:00

In some cases types are enhanced wrappers of simple types. For instance in .NET:

DateTime is a point in time and provides, among others things, extra functionality related to representing date and time formats.
XElement is an xml string and provides, among others things, checks to determine the validity of the xml string.
Option can contain a value and can tell you if there is value available.

Sometimes you have to deal with underling type and reuse some of the functionality of the wrapper. In this case you could consider using computation expressions.

This is a simple xml example. We create a xmlBuilder and reuse the validation logic of XElement:

open System
open System.Xml
open System.Xml.Linq

type xmlBuilder()=
    member x.Bind(el:XElement,(f:string -> XElement)) =
        try
            f(el.ToString())
        with
            | :? XmlException as exc -> XElement.Parse(String.Format("<XmlException>{0}</XmlException>", exc.Message))
    member x.Return(text) = 
        try
            XElement.Parse(text)
        with
            | :? XmlException as exc -> XElement.Parse(String.Format("<XmlException>{0}</XmlException>", exc.Message))

The string “123” creates an error:

let xml = new xmlBuilder()

let error =
    xml { 
            return "123"
        }

val error : XElement = <XmlException>Data at the root level is invalid. Line 1, position 1.</XmlException>

The expression can now be used to reuse sting functions:

let toUpper el =
    xml { 
            let! x = el
            return x.ToUpper()
        }

let el = XElement.Parse("<a><b>1</b><b>2</b></a>")
let result1 = el |> toUpper 

val result1 : XElement = <A>
  <B>1</B>
  <B>2</B>
</A>

In the same way we can define a simple add function for xml:

let (+) (el1:XElement) (el2:XElement) =
    xml { 
            let! x1 = el1
            let! x2 = el2
            return x1.Substring(0, x1.LastIndexOf("<")) + x2.Substring(x2.IndexOf(">") + 1)
        }

let el1 = XElement.Parse("<a><b>1</b><b>2</b></a>")
let el2 = XElement.Parse("<a><b>3</b><b>4</b></a>")
let result2 = el1 + el2

val result2 : XElement =
  <a>
  <b>1</b>
  <b>2</b>
  <b>3</b>
  <b>4</b>
</a>

let el3 = XElement.Parse("<c><b>3</b><b>4</b></c>")
let result3 = el1 + el3

val result3 : XElement = <XmlException>The 'a' start tag on line 1 position 2 does not match the end tag of 'c'. Line 7, position 3.</XmlException>

This may not be in line with the concept of information hiding, but it can help you in case you have to deal with the simple type to get the work done.

What is the USP of the monad?

2011-07-14T15:05:00.001+02:00

I am preparing an introductory article on monads for a Dutch software magazine. It is intended for .NET developers. I have to restrict myself so I am looking for the Unique Selling Point (USP) of the monad.

This is the list of selling points I could find. I left out selling points of specific monads and used the formulation of Wikipedia:

Monads are a kind of abstract data type constructor that encapsulate program logic instead of data in the domain model.
Control structure/inspection.
Hiding complexity with syntactic sugar.
Composition : monads chain actions together to build a pipeline.
To express input/output (I/O) operations and changes in state without using language features that introduce side effects.

I put them in the order of most favorite to least favorite.

My remarks:

1. Monads are a kind of abstract data type constructor that encapsulate program logic instead of data in the domain model.

This point can be split into two aspects of monads:

The monadic type is a wrapper of a data type (If M is the name of the monad and t is a data type, then "M t" is the corresponding type in the monad).
The functions: read (unit) and bind.

I think that the ability to have both access to the functionality of the wrapper and the original data type and a way to transform solution between the two is the most valuable selling point.

2. Control structure/inspection.

The monad is an excellent way to encapsulate inspection logic. Most monad tutorials start with the maybe monad because it is a simple example. It also shows the value of the monadic approach by hiding inspection plumbing.

3. Hiding complexity with syntactic sugar.

I think that the popularity of LINQ in C# and VB.NET is a proof that hiding complexity with syntactic sugar has its value.

4. Composition: monads chain actions together to build a pipeline.

In F# computation expressions or monads are also described as workflows. So this could be the USP. Sequence expression are a proof of the value of composition.

5. To express input/output (I/O) operations and changes in state without using language features that introduce side effects.

This is the least relevant point for a .NET developer. I do understand that this the most relevant one for a developer in a pure language or one that want to reduce the number of side effects.

Please feel free to add a command in case I missed a selling point or you have a better way to order the them.

WTF is a Monad by Robert C. Martin in F#

2011-06-28T19:59:00.001+02:00

I have read some material describing Computation Expressions and knew computation expressions are the F# implementation of monads, but I did know why one should use a monad.

A few days ago saw the video of presentation by Robert C. Martin (Uncle Bob) at the Norwegian Developers Conference called “WTF is a Monad” and now it makes sense to me.

It is a proven way of solving problems. If you:

have a problem in one domain
you can transform it to another domain
solve the problem in the other domain
and can transform it back

you have a solution.

I have translated some of the code of the presentation to F#. I tried to stay as close to the original code as possible and did not do much refactoring. I skipped the last two examples (distributions an state).

Update: ~~I did not implement the examples that required lift. I have not figured out how to do that.~~ I have created the lift myself (details: http://bugsquash.blogspot.com/2010/12/notes-on-haskell-functors-and-f.html)

I like to thank Robert for the permission to share the code. Feel free to add improvements in the comments.

//Non-Monadic dots

let dotsToN (d:string) =
    d.Length

let result1 = dotsToN "....."

let nToDots (n:int) =
    new string('.', n)

let result2 = nToDots 5

let addDots da db =
    let a = dotsToN da
    let b = dotsToN db
    nToDots (a+b)

let result3 = addDots "..." "..."

//Monadic dots

let dotResult = nToDots

let dotBind d (f:int -> string) =
    d |> dotsToN |> f

let addDots' da db =
    dotBind da (fun a ->
        dotBind db (fun b ->
            dotResult (a + b)))
    
let result4= addDots' "..." "..."

//dot-Monad
type dotBuilder()=
    member x.Bind(d,(f:int -> string)) = d |> dotsToN |> f
    member x.Return(n) = new string('.', n)

let dot = new dotBuilder()

let addDots'' da db =
    dot { let! x = da
          let! y = db
          return x + y
        }

let result5= addDots'' "..." "..."

let multiplyDots da db =
    dot { let! x = da
          let! y = db
          return x*y
        }

let result6= multiplyDots "..." "..."

let dcd dt du =
    dot { let! tens = dt
          let! units = du
          return (10 * tens + units)
        }

let result7= dcd "..." "....."

// In Clojure the monad gets the lift for free
// In F# we have to create it ourselves
// More info: http://bugsquash.blogspot.com/2010/12/notes-on-haskell-functors-and-f.html --
//

let liftDots_1 f a1 = 
    dot { 
            let! x1 = a1 
            return f x1 
        }

let liftDots_2 f a1 a2 = 
    dot { 
            let! x1 = a1
            let! x2 = a2
            return f x1 x2
        }

let liftDots_4 f a1 a2 a3 a4 = 
    dot { 
            let! x1 = a1
            let! x2 = a2
            let! x3 = a3
            let! x4 = a4
            return f x1 x2 x3 x4
        }

let substractDots = liftDots_2 (-)

let result7a= substractDots "....." ".."

let mean4 a b c d = (a+b+c+d)/4

let dmean4 = liftDots_4 mean4

let result7b= dmean4 "..." ".." "..." "...."

//
//complex number (inspection)
//

open System.Numerics

let c_0 = Complex.Zero
let c_1 = Complex.One
let c_i = Complex.ImaginaryOne

type complexBuilder()=
    member b.Return(x:float) = new Complex(x,0.0) 
    member b.Bind((c:Complex),(f:float -> Complex)) = 
        if c.Imaginary = 0.0 then
            f c.Real
        else 
            failwithf "Imaginary"
   
let complex = new complexBuilder()

let addComplex c1 c2 =
    complex { let! x = c1
              let! y = c2
              return x + y
            }

let result8= addComplex c_1 c_1;;
let result9= addComplex c_1 c_i;; //System.Exception: Imaginary
let result10= addComplex c_i c_i;; //System.Exception: Imaginary

//null

type noNullBuilder()=
    member b.Return(mv) = mv 
    member b.Bind(mv,f) = if (mv = null) then null else f mv

let nuNull = new noNullBuilder()

// int can not be null in .Net

let fragile (a:string) (b:string) (c:string) =
    if (a= null||b=null||c=null)
    then
        "CRASH"
    else
        a + b + c

let result11 = fragile "a" "b" "c"
let result12 = fragile "a" null "c" //"CRASH"

let safeFragile (a:string) (b:string) (c:string) =
    nuNull { let! x = a
             let! y = b
             let! z = c
             return x + y + z
            }

let result13 = safeFragile "a" "b" "c"
let result14 = safeFragile "a" null "c" //val result14 : string = null

//List
let l_a = [1;2;3]
let l_b = [4;5;6]

let addList = seq {for a in l_a do
                    for b in l_b do 
                    yield a+b
                  }|> Seq.toList

let multList = seq {for a in l_a do
                    for b in l_b do 
                    yield a*b
                  }|> Seq.toList

//helper for the demo
let flatten l = 
    let rec flatten' l result =
        match l with 
        |[] -> result
        |h::t -> flatten' t (h@result)
    flatten' (l|>List.rev) []

let result15 = flatten [[1;2;3];[7;8;9]]

type listBuilder()=
    member b.Return(v) = [v]
    member b.Bind(mv,f) = mv |> List.map f |> flatten

let list = new listBuilder()

let addList' a b = list {
                       let! x = a
                       let! y = b
                       return x + y 
                    }

let result16 = addList' l_a l_b

let multList' a b = list {
                       let! x = a
                       let! y = b
                       return x * y 
                    }

let result17 = multList' l_a l_b

//distribution example see Expert F# of Don Syme page 239..244
//state http://fsharpcode.blogspot.com/2008/12/f-state-monad-type-state-state-state-of.html

LINQ to XML, when lazy is too lazy in F# (and C# )

2011-06-22T23:24:00.003+02:00

Today a F# program did not work as expected. This is a small example I created:

let xml ="<a><b>1</b><b>2</b></a>"
let doc = XDocument.Parse(xml)

let getXElements_b (doc:XDocument) =
let els = doc.Root.Elements(XName.Get("b"))
els

//test
let result1 = doc |> getXElements_b |> Seq.toList
//val result1 : XElement list = [<b>1</b>; <b>2</b>]
//the expected result


let proces (el:XElement) =
XElement(XName.Get("c")) |> el.ReplaceWith

doc |> getXElements_b |> Seq.iter proces

let result2 =  doc.ToString();;
//val result2 : string = "<a>
//  <c />
//  <b>2</b>
//</a>"

This is not the expected result. I expected:

val result2 : string = "<a>
<c />
<c />
</a>"

I can fix it by changing the getXElements_b function:

let getXElements_b (doc:XDocument) =
let els = doc.Root.Elements(XName.Get("b")) |> Seq.toList
els

With this adjustment everything works fine. It seems that I have to force the the computation.

This is a problem in C# too.

private void GetXml()
{
var xml = "<a><b>1</b><b>2</b></a>";
var doc = XDocument.Parse(xml);
var els = doc.Root.Elements(XName.Get("b"));

foreach (var el in els)
{
el.ReplaceWith(new XElement(XName.Get("c")));
}

txtResult.Text = doc.ToString();
}

produces:

When I step with the debuger through the code the foreach is only one time triggered.

With support of Google I found the following document:

http://msdn.microsoft.com/en-us/library/bb308960.aspx

You can learn something new everyday.

Interesting links:

The "Halloween Problem" for XML APIs:

http://blogs.msdn.com/b/mikechampion/archive/2006/07/20/672208.aspx

Query Composition using Functional Programming Techniques in C# 3.0:

http://blogs.msdn.com/b/ericwhite/archive/2006/10/04/fp-tutorial.aspx

Update an open XML word document in F#

2011-06-20T22:13:00.002+02:00

I have created a small function in F# to update the content of a word document.

//reference to the package 
#r "WindowsBase"
//reference to the Xml and Linq 
#r "System.Xml"
#r "System.Xml.Linq"

open System
open System.IO
open System.IO.Packaging
open System.Xml
open System.Xml.Linq

//helper to create XName with a namespace
let xname str =
XName.Get(str, "http://schemas.openxmlformats.org/wordprocessingml/2006/main")

// the main function 
// changeDoc copies a word .docx document and updates the content by changing the xml that represents the content
let changeDoc oldPath newPath (updateDocument:XDocument -> XDocument) =
//update the package part
let updatePart (part:PackagePart) =
using (part.GetStream(FileMode.Open, FileAccess.Read)) (fun stream -> 
let xDocumentOut = stream |> XDocument.Load |> updateDocument
xDocumentOut.Save(part.GetStream(FileMode.Create, FileAccess.Write))
)

File.Copy(oldPath, newPath, true)
using (Package.Open(newPath, FileMode.Open, FileAccess.ReadWrite)) (fun package ->
let uri = new Uri("/word/document.xml", UriKind.Relative )

uri |> package.GetPart|> updatePart
)

// test function to update the document
// adds "_test" to every text  in the document.
let updateText (xDoc:XDocument) =
"t" |> xname  |> xDoc.Descendants |> Seq.iter (fun x -> x.Value <- x.Value + "_test")
xDoc

//test
changeDoc @"D:\Tmp\test.docx" @"D:\Tmp\test_copy.docx" updateText;;

Before "D:\Tmp\test.docx":

After "D:\Tmp\test_copy.docx":

F# blogs

2011-06-16T11:31:00.009+02:00

These are the F# blogs I am following:

Please add a comment when your blog is missing.

PsAccelerator

Creating real world WPF applications with Prism 5 and F# (part 2 - MEF)

Creating real world WPF applications with F# and Prism 5 (part 1)

F#

Prism 5

Hello World

Increase your productivity with F# scripts (part 2)

Increase your productivity with F# scripts (part 1)

A simple real-world problem

Windows Store Apps with F# (part 4) : Collections

Windows Store Apps with F# (part 3) : Data Binding and MVVM

Windows Store Apps with F# (part 2) : async/await

Windows Store Apps with F# (part 1) : Make things as simple as possible, but not simpler.

Update of the F# reading list

Dutch article: Monads voor de .NET-ontwikkelaar is available at the SDN site

BCL Team Blog provides more information on code reuse (Portable Libraries part 4)

.NET portability is not an afterthought (adding another layer of indirection - Portable Libraries part 3)

Reuse of legacy software by WinRT and Metro (Windows 8) (Portable Libraries part 2)

Create a Metro App in F# (NOT) (Portable Libraries part 1)

F# type providers: oData from NuGet

Monads for .NET developers

C# resources

Books:

Web:

F# resources

Web:

Presentations

Some theory

Code:

The newbie feeling

The difference between SelectMany and Select in LINQ

Adding xml strings in C# using LINQ

Adding xml strings in F# using computation expressions

What is the USP of the monad?

WTF is a Monad by Robert C. Martin in F#

LINQ to XML, when lazy is too lazy in F# (and C# )

Update an open XML word document in F#

F# blogs