Wintellect Blogs

A Quick Look at F# In Visual Studio Code

Jonathan Wood

8 Dec , 2015  


It’s F# Advent time again! This is a yearly event the F# community comes together for the month of December and each person releases an F# related post on a day of their choosing. Today is that day for me this year.

With the recent announcement at Microsoft’s Connect() conference, Visual Studio Code now has an awesome update that can install extensions. With me being an F# fanatic I got excited to see that actually using F# is one of the first extensions available via Ionide which is originally made for developing in F# in GitHub’s Atom client.

While you could technically already “use” F# in Visual Studio Code, it was only for syntax highlighting. You couldn’t run any of the code. This quick post will help show you the steps to started developing F# within Visual Studio code.

The original creator of Ionide, Krzysztof Cieślak, did a great guest post for the .NET Blog to help announce F# support for VS Code. I figured I’d do my best to extend on it with this post.

Installing the F# Extensions

If you’re used to Atom or Sublime you’re already familiar with the command palette in Visual Studio Code (scroll down to the Command Pallete section).… Read more

, ,

Wintellect Blogs

WintellectPowerShell Now on the PowerShell Gallery

John Robbins

7 Nov , 2015  


Getting and installing modules is easier than ever with the PowerShell Gallery and PowerShellGet. Instead of downloading and extracting files into your PowerShell modules directory, a simple call to Install-Module takes care of everything for you. Today I’ve published my WintellectPowerShell module. Now you can install and get started setting up Visual Studio to access symbol server, source servers, and many other cmdlets for debugging support. All you need to do with PowerShell 5.0 (or by adding the Package Management Preview to PowerShell versions 3 or 4) is issue the following command:

  1. Install-Module -Name WintellectPowerShell -Scope CurrentUser


If you haven’t heard of WintellectPowerShell, here are all the commands it offers.


Provides cmdlets for setting up symbol servers and other
functionality related to debugging and performance tuning.

This module makes setting up symbol servers and source server debugging
functionality easier to control for Visual Studio 2010 through 2015
and WinDBG. Setting up a development machine for symbol server
access is more difficult than it needs to be but no more.

You can have any combination of Visual Studio 2010 through 2015, and
WinDBG on the computer for these cmdlets to work.

These cmdlets had been originally developed as PowerShell scripts by John
Robbins and released on his blog.

Read more

, ,

How To,Wintellect Blogs

First Impressions of the Xamarin Inspector

Jonathan Wood

6 Nov , 2015  

Searching concept.

One of the pain points of using Xamarin Forms is that, just to see updates of any UI updates via XAML, you still need to save your changes, recompile, and relaunch the application. What’s more, is that you’d have to do this on each platform you’re targeting to make sure the UI looks good on each of them.

Well, the awesome folks at Xamarin know this and they’ve just released a preview edition of their newest application – Xamarin Inspector. I’ve played around with it a bit and below are my first impressions of the new application.

Take note that, in the time of this writing, the Xamarin Inspector is currently in early preview. More up-to-date information can be found on Xamarin’s documentation page.

When playing with the Xamarin Inspector I decided to use the demo project that we used for our post a while ago on testing Xamarin applications with F# and FsUnit. I felt this application gave a minimal amount of UI just to see what the Inspector could show.

How to Launch the Inspector

Since the Inspector is currently in preview, you would need to update your Xamarin Studio, in the Xamarin Studio -> Check for Updates screen to access the Alpha channel of the updates, like below.… Read more

, ,

Wintellect Blogs

Automating Xamarin Builds with FAKE – Part 3: Building and Running Unit Tests

Jonathan Wood

4 Nov , 2015  


While this will be a short post it’s also one that may be one of the most important ones to go over – running unit tests. Most of you probably know that being able to run tests early and often can save a ton of time if issues are found later on. One way to do this is to be able to execute your tests as easy as possible and this is possible within your FAKE script. Once again, FAKE comes with functions to be able to execute our tests in any framework you may be using.

Building the Unit Test Project

Of course, before running our tests we need to build the project. As we’ve seen in the previous posts, we’ll build the project with the MsBuild function.

let testProj = !! "FakeDemo.UnitTests/FakeDemo.UnitTests.csproj"

Target "Build-UnitTests" (fun _ ->
        |> MSBuild "FakeDemo.UnitTests\bin\Debug" "Build" [ ("Configuration", "Debug"); ("Platform", "Any CPU") ]
        |> Log "---Unit Test build output----"

Executing Unit Tests

Now here is another cool thing I really like from FAKE – they include helper functions that execute the tests for us. All we need to do is to pass in some configuration and we’re good to go!… Read more

, , ,

Wintellect Blogs

Linking Property Change Notifications in Xamarin Forms (or WPF/Silverlight)

Keith Rome

17 Oct , 2015  


I’d like to share a really awesome bit of code that I’ve been using in my XAML applications for a while now… there are many frameworks and examples out there, but I’ve not yet seen anyone else using this exact technique before…

MVVM in XAML UI Applications

If you are building app UIs using XAML, then you are more likely than not also using the MVVM design pattern. The general idea is that your code which handles application logic, business rules, etc. gets placed into ViewModel classes, and all visual widgets/controls get placed into XAML views. Typically we would have one View per ViewModel, but that’s not a requirement at all (more like a generalized observation), and in fact there are some situations where we might want to have multiple Views for the same ViewModel (or break a complex ViewModel into multiple parts while still connecting to a single View). The ViewModels are supposed to capable of standing alone, and we use data bindings and command bindings to connect the two. This way, we can unit test our ViewModels thoroughly, and (sometimes) allow UX designers to dictate the XAML layout directly.

That’s all fairly normal and typical.

As we dig a little more deeply into the mechanisms of data binding, we learn that part of the “magic” is achieved by way of the INotifyPropertyChanged interface (which includes only one thing – an event named PropertyChanged).… Read more

, , , ,

Wintellect Blogs

Automating Xamarin Builds with FAKE – Part 2: Building PCL, iOS, and Android Projects

Jonathan Wood

13 Oct , 2015  


Continuing from part 1 of this series we now have FAKE setup and ready for us to use our automated building needs. Now let’s build our Xamarin Forms application. In here we’ll go through how much FAKE helps us out by including built-in APIs that allow us to easily create our build targets. If you’ve never seen a FAKE build script before, you may be surprised by how little we need to do, since FAKE has all sorts of APIs that can be leveraged.

Of course, before we can really do anything else with our application we need to make sure everything builds so that will be the focus of this post.

Updated Build Script

In here we’re going to utilize FAKE’s Xamarin Helper library to help us build our iOS application. For our PCL and Android applications, however, we will just use FAKE’s MSBuild helper method as it doesn’t need anything special to build like iOS applications do.

The full script is at the bottom of this post and can be also found on GitHub, but let’s first break it up and talk a bit about each build target.


In most Xamarin applications, your PCL will house all of your core logic.… Read more

, , , ,

Wintellect Blogs

Automating Xamarin Builds with FAKE – Part 1: Introduction and Setup

Jonathan Wood

24 Sep , 2015  


Being a .NET developer, I’m sure one of your pain points throughout the development process in any project has been trying to setup automated building, testing, and even deploying. However, build tools have been evolving much like other development tools and have been getting much, much better. I’m sure most of you have heard of Rake and there are a ton of other tools that can be used as well. One of those tools we’ll be using here is FAKE – F# Make. I do believe, however, that the concepts you can learn here from FAKE can translate to other MAKE-like build tools such as Rake or Cake if you do decide to go with this similar concept.

In this post, we’ll introduce FAKE and show how to set it up in your project as well as a basic FAKE build script. The full source is available on GitHub and will point to all the code in this section.

Introduction to FAKE

While it’s not crucial to have a deep knowledge of F#, some aspects of it can be a bit helpful, such as being able to tap into the community for support and leveraging functional concepts available in F#. While a good bit of the F# projects use it for their building needs, you may recognize a few other projects that use it as well.… Read more

, , ,

Wintellect Blogs

Implementing Sharing in Xamarin Forms

Jonathan Wood

9 Sep , 2015  


One thing you may want to do within your Xamarin application is to allow users to share items that your application may capture, such as photos. While this isn’t quite trivial in Xamarin Forms as it’s different for both iOS and Android, this isn’t too hard to implement with the power of renderers.

We’re going to look at a small demo app that downloads the Wintellect logo and allows it to be shared. Let’s take a look at how this all works.

Xamarin Forms

This demo project is pretty small so all we will have is just one XAML page and within the page will just have an Image. Below is our XAML and our View Model that we’re using as our BindingContext.

<?xml version="1.0" encoding="UTF-8"?>

        <ToolbarItem Text="Share" Order="Secondary" Command="{Binding Share}" Name="Action" />

    <Image x:Name="LogoImage" Source="" Aspect="AspectFit" />
public class ShareImageViewModel
  public Command Share { get; set; }
  public ImageSource Source { get; set; }

  public ShareImageViewModel()
      Share = new Command(ShareCommand);

  void ShareCommand()
      MessagingCenter.Send<ImageSource>(this.Source, "Share");

Notice in our ToolbarItem we have a Command.… Read more


Wintellect Blogs

Creating a Secondary (bottom) iOS Toolbar in Xamarin Forms

Keith Rome

2 Sep , 2015  


Xamarin Forms is a really great platform for mobile app development – we have used it on several apps now and had much better results than when trying to use the native SDK’s directly. Every now and then though you run up against a roadblock with the default renderer implementations where some feature (perhaps a key feature of your app) simply does not work the way it should. Secondary toolbars on iOS are one of those. I recently spent a couple of days trying to coax this feature into working properly before finally finding a solution (many other folks seemed to have simply given up on it).

What is a secondary toolbar?

Xamarin Forms supports the notion of Page-level toolbars. These are represented by the Page.ToolbarItems collection, and each ToolbarItem represents a clickable button that is hosted within the toolbar. In fact, there are two toolbars – the main “primary” toolbar that fills the right end of the navigation bar at the top of your screen, and also a “secondary” toolbar. You can only fit a few (two or three at most) toolbar items on the primary toolbar, and the rest are generally expected to go into the secondary toolbar. On Android this is done by adding an expansion button to the far right end of the primary toolbar which drops down a vertical menu containing the secondary toolbar items.… Read more

, ,

Wintellect Blogs

Unit Testing Your Xamarin Forms Applications with F# and FsUnit

Jonathan Wood

14 Aug , 2015  


One of the best and easiest ways to use F# in your projects is to use it for unit testing and the same can be said for your mobile applications with Xamarin.

While C# has FluentAssertions as well as Should (I prefer the syntax of FluentAssertions between the two) F# has FsUnit to give more readable test conditions. I would say even more readable than the C# equivalent.

With this post I’ll have a small demo Xamarin project using Xamarin Forms to build the UI. This will consist of a simple navigation and a small class to do some logic. We will use F# for our test project to test both the logic and use Xamarin UI Test to make sure our navigation and screens appear as we intend. These tests are also to make sure our workflows work as intended on several different devices.

Let’s quickly compare the two and see how they look. Within our demo Xamarin application, our PCL project that includes our XAML for Xamarin Forms will also have a class to do some logic for us. For demo purposes, this will just be an Add class that takes in two integers and adds them together and returns the result.… Read more

, , ,