Matt Ward

TypeScript Support in SharpDevelop

MattWard — Wed, 24 Apr 2013 21:00:00 GMT

SharpDevelop 4.3.1 now has support for TypeScript with an early beta release of a new Addin.

The Addin glues together the TypeScript language services, which provide all the features needed for code completion and refactoring, and SharpDevelop using Javascript.NET as the bridge between them. Javascript.NET allows SharpDevelop to host Google's V8 JavaScript engine and have JavaScript code interact with .NET objects.

Features

TypeScript compilation on save or build.
Code folding.
Code completion
Find references
Rename refactoring
Go to definition
Quick class browser support.
TypeScript syntax highlighting

The addin supports:

SharpDevelop 4.3.1
TypeScript 0.8.3.1

Let us take a quick look at some of these features.

Code Completion

Code completion works when you press the dot character.

Code completion also works when you type the first bracket of a function.

Find References, Go to Definition and Rename

These menu options can be found by right clicking on a class or a class member.

Go To TypeScript Definition will show the corresponding type definition. Find TypeScript References will show the reference locations in the Output window. Rename will open a dialog box where you can type in the new name and click OK to have it updated everywhere it is referenced.

Getting the Addin

The addin's source code is available on GitHub. A zip file is available to download containing the pre-compiled addin. Simply unzip the files and install into SharpDevelop using the Addin Manager. The Addin Manager is available by selecting Addin Manager from the Tools menu. Install the addin by clicking the Install Addin button and then restart SharpDevelop.

Configuring TypeScript Compiler Options

The compiler options are available from the Options dialog (Tools - Options) under the Text Editor category. Here you can change when the compiler is run and what options are passed to the compiler when generating JavaScript code.

Limitations and Known Issues

Limitation with multiple projects using TypeScript files in the same solution. All files are included in the same scope.
Performance problems - currently doing work on the UI thread and also re-parsing all TypeScript files each time when a code completion action is triggered.
Different behaviour to Visual Studio with classes show in the code completion window. Visual Studio only shows code completion for TypeScript files you have explicitly referenced in a comment. SharpDevelop shows everything in the current project.
Unable to easily replace the existing SharpDevelop menu options such as Find References so the standard shortcuts will not work.
No support for hovering over a type with the mouse and seeing a tooltip with information about the type.

NuGet Addin for MonoDevelop

MattWard — Mon, 07 Jan 2013 18:41:00 GMT

It has been a while since NuGet support was added to SharpDevelop so, after David Fowler announced that he had got NuGet building under Mono, I had a look at porting the SharpDevelop addin over to MonoDevelop and created a NuGet addin for MonoDevelop.

The addin provides a Manage Packages dialog that you can use to add, remove and update NuGet packages in a similar way to Visual Studio or SharpDevelop. Here is a screenshot of the Manage Packages dialog open in MonoDevelop running on OpenSuse 12.2

The addin has been tested with the following:

MonoDevelop 3.0.5
Mono 2.10.9
OpenSuse 12.2
Windows 7

The addin uses a slightly customised version of NuGet.Core based on the original NuGet's source code available from the mono-build branch. The source code for this customised NuGet.Core is available on GitHub.

Getting the Addin

The addin's source code is available on GitHub.

The addin is also provided as a pre-compiled binary available to download from a custom MonoDevelop repository:

http://mrward.github.com/monodevelop-nuget-addin-repository/3.0.5/main.mrep

You can add this repository to MonoDevelop via the Add-in Manager.

Please note that the addin is a beta release and more work is still to be done.

Manage Packages Dialog

The Manage Packages Dialog can be opened from the Projects menu by selecting Manage NuGet Packages.

It can also be opened by selecting the Solution window, right clicking either the solution, the project or the project's references and selecting Manage NuGet Packages.

As a NuGet package is installed or uninstalled you can see the package operations that executed by expanding the Messages section near the bottom of the dialog.

Configuring Package Sources

NuGet Package Sources can be configured in MonoDevelop's options.

In Linux you can open the options dialog by selecting Preferences from the Edit menu. In Windows you can select Options from the Tools menu. In the Options dialog scroll down the categories on the left hand side until you find NuGet and then select Package Sources. Here you can add and remove NuGet package sources.

PowerShell

Any PowerShell scripts in a NuGet package will be ignored by the addin since Mono does not currently have support for them.

There have been some attempts to implement PowerShell on Mono starting with Igor Moochnick who created Pash in 2008. Work on this was picked up launchpad.net by Jonathan Ben-Joseph but that work stopped. The latest effort on bringing PowerShell to Mono is Jay Bazuzi with recent work done on the Pash source code available on GitHub.

There was also some discussion in the NuGet forums on allowing some way of being able to write a .NET version of the PowerShell scripts (install.ps1, uninstall.ps1 and init.ps1).

Code First Migrations with Entity Framework

MattWard — Sun, 11 Nov 2012 17:00:00 GMT

SharpDevelop 4.3 now has support for Code First Migrations using Entity Framework 5.0.

Microsoft added Code First Migrations to Entity Framework in version 4.3 in February 2012. Code first migrations allows database changes to be implemented with code. The official Entity Framework NuGet package includes three PowerShell cmdlets that extend the NuGet Package Manager Console allowing you to quickly create and use these code first migrations:

Enable-Migrations: Adds support for migrations to your project.
Add-Migration: Generates code for a database migration based on changes to your database model.
Update-Database: Applies migrations to the database.

The PowerShell cmdlets in the official EntityFramework NuGet packages are Visual Studio specific, but there is now a SharpDevelop specific NuGet package (EntityFramework.SharpDevelop) that allows you to use these PowerShell cmdlets in SharpDevelop. This has been made possible by Entity Framework being open sourced.

The EntityFramework.SharpDevelop NuGet package includes the original EntityFramework.dll along with custom versions of the assemblies containing the PowerShell cmdlets - EntityFramework.PowerShell.dll and EntityFramework.PowerShell.Utility.dll.

Now let us take a look at how to use the EntityFramework.SharpDevelop NuGet package.

Installation

Before you begin you should have SQL Express installed. You will also need SharpDevelop version 4.3.0.9134 or above.

We will look at using Entity Framework with a simple C# console application. This application will add a blog post to a SQL Express database and then read all the existing blog posts in the database.

In SharpDevelop first create a new C# Console Application. Now open the NuGet Manage Packages dialog by right clicking the project and selecting Manage Packages. Search for the EntityFramework.SharpDevelop package in the main NuGet feed and click the Add button to add it to your project. A reference to the EntityFramework assembly will be added to your project and your app.config will be modified.

Now we are ready to use Entity Framework to update and read from our database.

Using Entity Framework

First add a new Post class to your project.

public class Post
{
    public int Id { get; set; }
    public string Title { get; set; }
    public string Text { get; set; }
}

Now add a new database context class.

public class BloggingContext : DbContext
{
    public DbSet<Post> Posts { get; set; }
}

You will also need to add a using statement to the BloggingContext class so the EntityFramework's DbContext class can be found.

    using System.Data.Entity;

Now open your Program.cs and add a using statement for System.Linq.

    using System.Linq;

Then in Program.cs update the Main method as shown below:

class Program
{
    public static void Main(string[] args)
    {
        Console.Write("Enter a post title: ");
        string title = Console.ReadLine();

        Console.Write("Enter the post text: ");
        string text = Console.ReadLine();

        using (var db = new BloggingContext()) {

            var newPost = new Post {
                Title = title,
                Text = text
            };

            db.Posts.Add(newPost);
            db.SaveChanges();

            Console.WriteLine("All posts in the database:");

            IQueryable<Post> query = db.Posts
                .OrderBy(p => p.Title)
                .Select(p => p);

            foreach (Post post in query) {
                Console.WriteLine("Post.Title: " + post.Title);
            }
        }

        Console.WriteLine("Press a key to exit.");
        Console.ReadKey();
    }
}

This code reads the blog post title and text entered on the command line, adds a new post to the database and then reads all the posts in the database. Compile and run this application and you should see output similar to the following.

    Enter a post title: First Post
    Enter the post text: Some text here...
    All posts in the database:
    Post.Title: First Post
    Press a key to exit.

After running this application Entity Framework will have created a new database with the same name as the db context class you created. In the screenshot below you can see the database open in SQL Server Express Management Studio.

You can see that Entity Framework has created a Posts table as well as a __MigrationHistory table. Now we will take a look at enabling database migrations.

Enabling Migrations

Open the Package Management Console and enter the command.

    Enable-Migrations

This adds a Migrations folder to your project along with a Configuration.cs file and an initial migration.

The Configuration.cs file can be edited to add seed data and alter other settings used when migrating the database. The initial migration files contain code to generate the Posts table in the database.

Now let us take a look at adding a new migration.

Adding a Migration

We want to add a Published Date to our Post class. Add the new PublishedDate property to the Post class as shown below.

public class Post
{
    public int Id { get; set; }
    public string Title { get; set; }
    public string Text { get; set; }
    public DateTime PublishedDate { get; set; }
}

You can generate a code first migration by entering the following command into the Package Management Console.

    Add-Migration AddPublishedDate

This creates a new migration and gives it the name AddPublishedDate. A new file will be added to your migrations folder which contains the code to update the Posts table with the new PublishedDate column.

namespace EFCodeFirst.Migrations
{
    using System;
    using System.Data.Entity.Migrations;

    public partial class AddPublishedDate : DbMigration
    {
        public override void Up()
        {
            AddColumn("dbo.Posts", "PublishedDate", c => c.DateTime(nullable: false));
        }

        public override void Down()
        {
            DropColumn("dbo.Posts", "PublishedDate");
        }
    }
}

Now you can update your database.

Updating the Database

To update the database we run the following command in the Package Management Console window.

    Update-Database

The new PublishedDate column will then be added to the Posts database table as shown in the screenshot below

That concludes the introduction to using Code First Migrations with SharpDevelop. More information on EntityFramework can be found on the Microsoft MSDN site.

Changes Made to Original Entity Framework NuGet Packages

Renamed NuGet package to EntityFramework.SharpDevelop and included files and assemblies from official EF NuGet package.
Recompiled the EntityFramework.PowerShell and EntityFramework.PowerShell.Utility projects against SharpDevelop's EnvDTE implementation.
Small modifications to the project to compile against .NET 4.0 and the EntityFramework.dll. Microsoft's released source code on Codeplex is for EntityFramework 6 and not for EF 5.
EntityFramework.PowerShell and EntityFramework.PowerShell.Utility assemblies are no longer signed.
Added workaround to fix AppDomain.CreateInstance failing to find constructors taking a EnvDTE.Project parameter.
Add SharpDevelop.EnvDTE.dll to NuGet packages.

All the code for the modified NuGet packages are available on GitHub.

MVC Scaffolding

MattWard — Fri, 28 Sep 2012 13:10:00 GMT

SharpDevelop 4.3 now has support for MVC Scaffolding.

MVC Scaffolding, maintained by Steve Sanderson, provides a way to quickly generate code for views and controllers in your ASP.NET MVC application. It has support for scaffolding the following:

Views and controllers.
Entity Framework DbContexts.
Repositories.
Controller actions.
Unit tests.

It makes use of T4 templates, which can be customised, and can be extended with custom scaffolders to support more than just the features listed above.

The original MVC Scaffolding NuGet packages made heavy use of the Visual Studio API and have been modified to work with SharpDevelop. Full details of the changes made to the original NuGet packages can be found at the end of this post.

Steve Sanderson has a great series of posts on MVC Scaffolding that covers more than this post will. Now let us take a look at how to use MVC Scaffolding with SharpDevelop.

Installation

MVC Scaffolding for SharpDevelop is available as a NuGet package. The NuGet package you should download is MvcScaffolding.SharpDevelop. Install the MvcScaffolding.SharpDevelop NuGet package either from the NuGet package management console or by using the Manage Packages dialog.

Note that the NuGet package MvcScaffolding.SharpDevelop.1.0.9 requires SharpDevelop 4.3.0.9134 or above. If you have an older version installed then you should uninstall the MvcScaffolding.SharpDevelop package, before installing the latest version of SharpDevelop, and then reinstall the MvcScaffolding.SharpDevelop package. A breaking change made to SharpDevelop 4.3 to support the EntityFramework package will cause the older MvcScaffolding.SharpDevelop NuGet package to fail to uninstall cleanly in the newer version of SharpDevelop.

Scaffolding a Controller and Views

As an example we will create a simple blogging site. Create a Razor MVC application called BloggingSite. Then create the following class in a Models folder.

using System;

namespace BloggingSite.Models
{
    public class Post
    {
        public int Id { get; set; }
        public string Title { get; set; }
        public string Text { get; set; }
        public DateTime PublishedDate { get; set; }
    }
}

Now we can scaffold a controller and a set of Create, Read, Update and Delete (CRUD) views. In the Package Management console run the following command.

Scaffold Controller Post

This will generate a set of views, a controller and an Entity Framework database context.

To run the Blogging Site application you will need to have IIS Express and SQL Server Express installed. Your project will also need to be configured to use IIS Express. Select Project Options from the Project menu and then select the Web tab. Choose IIS Express and then click the Create application/virtual directory button.

Then run your application and visit the /Posts page in your browser.

You can then create a new post by clicking the Create New link.

After creating a new post then the post will be displayed on the original /Posts page.

Also scaffolded is the details page which you can view by clicking the Details link.

Finally there is the Delete page where you can remove a post.

Scaffolding CRUD views is just one part of MvcScaffolding so let us take a look at some of other scaffolding that is supported. Steve Sanderson goes into more detail on what you can do with each of the MVC Scaffolders than will be covered here.

Scaffolding a Repository

The PostsController generated uses the BloggingSiteContext class which is derived from Entity Framework's DbContext.

public class PostsController : Controller
{
    private BloggingSiteContext context = new BloggingSiteContext();

    //
    // GET: /Posts/

    public ViewResult Index()
    {
        return View(context.Posts.ToList());
    }

To allow unit testing of the controller we can instead using a repository interface which can be mocked. To do that we run the following command.

Scaffold Controller Post -Repository -Force

By default MVC Scaffolding will not overwrite views and controllers previously created in your project. In order to overwrite the views and controllers created previously we use the -Force option.

The PostsController now looks like this.

public class PostsController : Controller
{
    private readonly IPostRepository postRepository;

    // If you are using Dependency Injection, you can delete the following constructor
    public PostsController() : this(new PostRepository())
    {
    }

    public PostsController(IPostRepository postRepository)
    {
        this.postRepository = postRepository;
    }

    //
    // GET: /Posts/

    public ViewResult Index()
    {
        return View(postRepository.All);
    }

Scaffolding an Empty View

You can scaffold an empty view by using the View scaffolder and specifying the name of the controller, without the Controller part, followed by the name of the view.

Scaffold View Posts MyEmptyView

In a Razor MVC application this will generate the file Views\Posts\MyEmptyView.cshtml in your project.

Scaffolding Database Context

You can scaffold extra properties for your database context by using the DbContext scaffolder and specifying the model class and the name of the database context class. Create a new Blog class, as shown below.

using System;

using System;

namespace BloggingSite.Models
{
    public class Blog
    {
        public int Id { get; set; }
        public string Name { get; set; }
    }
}

Now run the command below to update your database context and a new Blogs property will be added to your BloggingSiteContext class.

Scaffold DbContext Blog BloggingSiteContext

The new BloggingSiteContext class is shown below.

public class BloggingSiteContext : DbContext
{
    // You can add custom code to this file. Changes will not be overwritten.
    // 
    // If you want Entity Framework to drop and regenerate your database
    // automatically whenever you change your model schema, add the following
    // code to the Application_Start method in your Global.asax file.
    // Note: this will destroy and re-create your database with every model change.
    // 
    // System.Data.Entity.Database.SetInitializer(
        new System.Data.Entity.DropCreateDatabaseIfModelChanges
            <BloggingSite.Models.BloggingSiteContext>());


    public DbSet<BloggingSite.Models.Post> Posts { get; set; }

    public DbSet<BloggingSite.Models.Blog> Blogs { get; set; }
}

Scaffolding Controller Actions

You can scaffold new controller actions by using the Action scaffolder and specifying the name of the controller, without the Controller part, and the name of the new action method.

Scaffold Action Posts MyAction

This will add a new MyAction method at the end of your PostsController class.

public ViewResult MyAction()
{
    return View();
}

It will also create an associated view.

You can also scaffold actions that can have data posted to them. If you run the following command a new action will be created that takes a posted Blog object.

Scaffold Action Posts MyPostAction -ViewModel Blog -Post

The PostsController will now have a new MyPostAction method at the end.

[HttpPost, ActionName("MyPostAction")]
public ActionResult MyPostActionPost(Blog blog)
{
    if (ModelState.IsValid) {
        return RedirectToAction("Index");
    } else {
        return View(blog);
    }
}

That is the end of our introduction to using MVC Scaffolding with SharpDevelop.

Modifications Made to Original MVC Scaffolding

Mvc Scaffolding projects now compiled against SharpDevelop's Package Management assembly which implements the Visual Studio API.
T4 template generation now uses MonoDevelop's T4 Templating Engine.
T4Scaffolding.SharpDevelop.1.0.8 NuGet package depends on EntityFramework.SharpDevelop NuGet package instead of the original EntityFramework NuGet package This allows an upgrade to the NuGet package EntityFramework.SharpDevelop.5.0.0 which supports migrations in SharpDevelop.

Source code for the modified MVC Scaffolding can be found on CodePlex.

[Update 2012-11-10] Added information on MvcScaffolding.SharpDevelop 1.0.9 NuGet package requiring newer version of SharpDevelop. Updated "Scaffolding Database Context" section with example Blog class. Updated "Modifications Made to Original MVC Scaffolding" section with change made to T4Scaffolding.SharpDevelop NuGet package.

Using T4MVC with SharpDevelop

MattWard — Sat, 15 Sep 2012 12:40:00 GMT

SharpDevelop 4.3 now has support for T4MVC.

T4MVC is a set of T4 templates, created by David Ebbo, that will generate strongly typed helpers for an ASP.NET MVC application. It will allow you to remove strings from your MVC application making your application easier to maintain.

So let us take a look at how to use T4MVC with SharpDevelop. First you should open or create a new ASP.NET MVC application in SharpDevelop.

Installing T4MVC

T4MVC is available as a NuGet package. The NuGet package you should download is T4MVC.SharpDevelop. This contains a modified version of the original T4MVC template that can be used with SharpDevelop. Further details on all the modifications made to the T4MVC template can be found at the end of this post. Install the T4MVC.SharpDevelop NuGet package either from the NuGet package management console or by using the Manage Packages dialog.

Note that T4MVC 2.13.0 requires SharpDevelop 4.3.0.9132 or above.

After installation two new T4 template files will be added to your project.

T4MVC.tt - main template that generates the strongly typed helpers.
T4MVC.tt.settings.t4 - holds configuration settings used by main T4MVC.tt template.

Generating T4MVC's Strongly Typed Helpers

To run the T4MVC template manually, select it in the Projects window, right click and select Execute Custom Tool. This will generate a set of files as dependencies of the T4MVC.tt file.

It will also make some modifications to your controller classes. The T4MVC template will change your controller classes so they are partial. It will also change your controller methods so they are virtual. What has been changed will be recorded as warnings in the Errors window.

When you make modifications to your application you do not want to have to keep running the T4MVC template manually each time to regenerate the strongly typed helpers. Instead you can configure your project to re-generate the strongly typed helpers on each build.

Generating T4MVC's Strongly Typed Helpers on each Build

To do this you should open the options for the project. From the Projects menu and select Project Options. Open the Custom Tool tab. In this tab you can choose to run custom tools on each build. In the screenshot below the project is configured to run T4MVC on each build.

If you want to run other custom tools you can add filenames for items in your project either as a comma separated list or with each file on a separate line. Currently there is no support for wildcards when specifying filenames.

Now that we have generated the strongly typed helpers let us take a look at how to use a selection of them.

Using T4MVC's Strongly Typed Helpers

View Names

In your _ViewStart.cshtml you may have a reference to a Razor layout page.

@{
    Layout = "~/Views/Shared/_Layout.cshtml";
}

You can replace this string with a strongly typed helper.

@{
    Layout = MVC.Shared.Views._Layout;
}

Action Links

In your views you may be passing action names and controller names as strings HtmlHelper.ActionLink(string linkText, string actionName, string controllerName).

    <li>@Html.ActionLink("Home", "Index", "Home")</li>
    <li>@Html.ActionLink("Contact", "Contact", "Home")</li>

Instead you can use code that looks like you are calling the controller method.

    <li>@Html.ActionLink("Home", MVC.Home.Index())</li>
    <li>@Html.ActionLink("Contact", MVC.Home.Contact())</li>

CSS Links

You may be using strings for links, such as for CSS files, in your views.

<link href="@Url.Content("~/Content/Site.css")" rel="stylesheet" type="text/css">

These can be changed to use the Links.Content helper class.

<link href="@Links.Content.Site_css" rel="stylesheet" type="text/css">

That is a very quick introduction to T4MVC and covers only a few of the helpers it provides. Further information on T4MVC can be found on the T4MVC Codeplex site.

Changes Made to Original T4MVC Template

Visual Studio assembly references have been removed and replaced with a SharpDevelop assembly reference.
Visual Studio namespace imports have been removed and replaced with namespace imports for SharpDevelop.
Removed use of BeginInvoke/EndInvoke which was causing SharpDevelop to hang.

The SharpDevelop specific T4MVC template is maintained in a repository on github.

[Update 2012-10-11] Added information on T4MVC 2.13.0 requiring a newer version of SharpDevelop 4.3. Updated "Changes made to original T4MVC template" section after SharpDevelop EnvDTE API was modified to follow Visual Studio's API when using parameterised properties such as ProjectItem.FileNames() and CodeType.IsDerivedFrom()

NUnit 2.6.1 Support

MattWard — Sun, 12 Aug 2012 14:05:00 GMT

SharpDevelop 4.3 has been updated to use NUnit 2.6.1 which was recently released. The full details on what has changed in NUnit 2.6.1 can be found in the NUnit release notes. One change in this release caused some of SharpDevelop's own unit tests to break so this change is highlighted in the following section.

Running unit tests with an STA thread

NUnit 2.6 no longer reads settings from your test configuration file (app.config). This means that you can no longer make NUnit use the STA thread by setting the default apartment state in your app.config file. So the following app.config file will not work:

  <configuration> 
    <configSections>
      <sectionGroup name="NUnit">
        <section name="TestRunner"  type="System.Configuration.NameValueSectionHandler" />
        </sectionGroup>
      </configSections>
      <NUnit>
        <TestRunner>
           <!-- The ApartmentState value here is ignored. -->
           <add key="ApartmentState" value="STA" />
        </TestRunner>
      </NUnit>
  </configuration>

Instead you should use the RequiresSTA attribute.

The RequiresSTA attribute can be used at the assembly, class or method level. To make NUnit to run all your unit tests with an STA thread you can add the following code to your AssemblyInfo.cs file in the project containing your unit tests.

using NUnit.Framework;

[assembly: RequiresSTA]

Code Coverage with OpenCover

MattWard — Wed, 08 Aug 2012 20:49:00 GMT

SharpDevelop 4.3 now has integrated support for OpenCover thanks to Lex Li.

OpenCover is an open source code coverage tool created by Shaun Wilde. It can be used to measure how much of your code is covered by your unit tests. OpenCover was created to fix the following problems in PartCover, another open source code coverage tool.

64 bit support
Memory usage
Returning no coverage results

For a more detailed look into why OpenCover was created you should read Shaun Wilde's OpenCover First Beta Release post.

Back in 2006 SharpDevelop added support for NCover, then it switched to using PartCover a year later when NCover was turned into a commercial product. Now it supports and ships with OpenCover so let us take a tour of using OpenCover with SharpDevelop.

OpenCover Feature Tour

First you should install SharpDevelop 4.3. Version 4.3.0.8911 or above will have OpenCover support. Then you will need to use a project with unit tests or alternatively you can download a zip file which contains the set of projects created whilst writing this feature tour. Open your solution with SharpDevelop 4.3 and let us get started.

Running Unit Tests with Code Coverage

To run the unit tests with code coverage open the Unit Tests window by selecting Tools - Unit Tests from the View menu. Right click the project or tests that you want to check for code coverage and select Run with code coverage.

At the top of the Unit Tests window there is the run with code coverage toolbar button which can be also used to run code coverage for all the tests.

Another way to run the unit tests with code coverage is to right click in the text editor and select the Run with code coverage menu option.

The unit tests will then be run and OpenCover will profile your code. The output from OpenCover will be displayed in the Output window. Once OpenCover is finished the code coverage results will be displayed in the Code Coverage window.

Code Coverage Results

The code coverage window will show you the percentage of code covered for each class, method and property. On the right hand side you can see the visit count information or if you select the Show Source Code option you can see the corresponding source code with covered code highlighted in green and uncovered code highlighted in red.

The Code Coverage window also allows you to enable or disable code coverage highlighting in the text editor. The top left button in the Code Coverage window is used to enable or disable code coverage highlighting in the text editor.

In the screenshot below the text editor has covered code in highlighted in green and uncovered code in highlighted in red.

Filtering Code Coverage Results

By default OpenCover will show you code coverage for all your code including your tests. Typically you are not interested in code coverage for your unit tests. To exclude classes you can use a filter. The filters you can use are described on the OpenCover wiki. To specify a filter in your unit tests project select Project Options from the Project menu. Then open the Code Coverage tab. Here you can specify an include or exclude filter. In the screenshot below all types in the OpenCoverageFeatureTour.Tests assembly will be excluded.

64 bit or 32 bit

On Windows x64 if your test project is set to target a 32 bit processor then the 32 bit version of NUnit will be used to run your unit tests. If it is set to Any CPU or a 64 bit processor then NUnit will run as a 64 bit process as OpenCover profiles your code.

Code Coverage Options

The colours used to highlight code coverage in the text editor and Code Coverage window can be configured in the Options dialog. From the Tools menu select Options. Then expand the Tools category and select Code Coverage.

That ends the tour of using OpenCover with SharpDevelop.

Using MSTest with SharpDevelop

MattWard — Sun, 06 May 2012 17:32:00 GMT

SharpDevelop 4.2 now has a new sample addin that adds integrated support for running tests with MSTest.

Features

Given the following code:

In the Unit Tests window the MS Tests will be displayed. The unit tests can be run by right clicking and selecting Run tests. The Unit Tests window will update to show the tests that passed and failed.

The output from the MS test runner (mstest.exe) will be displayed in the Output window.

Any test failures are displayed in the Errors window.

There is a default path defined for mstest.exe which points to the Visual Studio 2010 folder but you can alter this path from the Tools Options dialog under Tools - MS Test.

Note that running tests with the debugger or with code coverage does not work.

Full details on how the addin works can be found in the wiki.

Using the MSTest addin

To use the MSTest addin either follow the instructions in the wiki to build it from source or download the pre-built addin and register it with SharpDevelop using the Addin Manager by selecting AddIn Manager from the Tools menu.

Adding a Service Reference

MattWard — Sun, 22 Apr 2012 10:28:00 GMT

SharpDevelop 4.2 now includes support for adding references to WCF services.

Prerequisites

Microsoft Windows SDK should be installed.

In order to generate the service reference SharpDevelop uses Microsoft's ServiceModel Metadata Utility Tool SvcUtil which is included as part of the Microsoft Windows SDK.

Configuring SvcUtil Location

SharpDevelop should automatically detect where SvcUtil is installed however the path to SvcUtil can be overridden if required from the Tools - Options dialog.

Adding a Service Reference

To add a service reference, open the Projects window, right click on the project or the references and select Add Service Reference.

In the Add Service Reference dialog enter the url to the WCF service and click Go. The WCF service that is discovered should then be displayed.

Clicking the Advanced button will allow you to configure further generation options.

In the main Add Service Reference dialog enter a namespace for the service and then click the OK button to generate the service reference.

A service reference proxy will be added to the project and the project's app.config file will be updated with the WCF binding information.

Now you can use the WCF service in your application.

JavaScript Code Folding

MattWard — Sun, 05 Feb 2012 15:53:00 GMT

SharpDevelop 4.2 now includes support for JavaScript code folding and code regions.

When you open a JavaScript (.js) file into the text editor any functions that are defined can be folded.

The text editor also supports code regions.

    //#region Canvas Test 
     
    tests['canvas'] = function() { 
        var elem = document.createElement( 'canvas' ); 
        return !!(elem.getContext && elem.getContext('2d')); 
    }; 
     
    //#endregion

These regions can be folded as shown below.

ASP.NET MVC Support

MattWard — Sun, 29 Jan 2012 20:56:00 GMT

One of the new features in SharpDevelop 4.2 is better support for ASP.NET MVC 3 applications. Previous versions contained project templates for ASP.NET MVC but not much more. With SharpDevelop 4.2 the following features have been added:

Razor project and file templates for C# and Visual Basic
Razor syntax highlighting
Add Controller dialog using T4 templates
Add View dialog using T4 templates
HTML folding

Now let us take at these new features.

Prerequisites

Before using SharpDevelop you should install ASP.NET MVC 3 and IIS, either IIS Express or full IIS. You can get MVC 3 and IIS Express from Microsoft's Web Platform installer or download them directly from the following pages:

After installing IIS Express make sure that you run IISExpress.exe once so it can generate its configuration files for your user profile. If you do not then SharpDevelop will fail to configure IIS Express.

Creating an ASP.NET MVC Application

Now we shall create a new C# ASP.NET MVC application that uses the Razor view engine. First run SharpDevelop and then from the File menu select New Solution to open the New Project dialog.

On the left in Categories select ASP.NET MVC under C#. On the right you will see three project templates.

Empty MVC Application - creates an MVC application with a minimal set of files.
MVC Application - creates an MVC application that uses the Web Forms view engine (.aspx).
Razor MVC Application - creates an MVC application that uses the Razor view engine.

Select the Razor MVC Application project template. Enter a name for the project and select a location where the project will be created. Click Create to create the MVC project.

If you open the Projects window by selecting Projects from the View menu you will see that the project template created a Home Controller, two Razor view pages - Index and Contact, as well as installing the jQuery and Modernizer NuGet packages.

Syntax Highlighting and Folding

If you open the a Razor file (.cshtml) you will see that there is html folding and Razor syntax highlighting.

The Razor syntax highlighting is still under development and does not work in all cases since it is not using Microsoft's Razor parser and uses a basic syntax definition file. In the screenshot above, for example, the Razor @ symbol is not correctly highlighted in the script and link tags.

Running an ASP.NET MVC Application

In order to be able to run your application first you will need to configure the project to use IIS Express or IIS. From the Project menu select Project Options. Select the Debug tab. At the bottom of this tab you will see options for IIS Express and IIS.

For this walkthrough we will use IIS Express. Select IIS Express and enter a port number. Then click the Create Applicaton/Virtual Directory button. A message will then be displayed telling you that the application/virtual directory was created successfully. Now we can run the application.

To run the application select Run from the Debug menu. IIS Express will then be launched and your application will be loaded into your default web browser.

You can set breakpoints in your application and debug your code in the standard way. For example, set a breakpoint in the HomeController's Contact method and then click Contacts in your browser and you will see SharpDevelop stop at the breakpoint.

To stop debugging select Stop process from the Debug menu. You will then see a prompt asking you to detach or terminate the process being debugged, in this case IIS Express. Detaching will leave IIS Express running.

File Templates

SharpDevelop includes a set of file templates for ASP.NET MVC applications. You can create a new file using these templates by selecting the project or a folder in the Projects window, right clicking and select Add New Item.

Select the appropriate template, give the file a name and click Create to add a new file to your project.

Add Controller Dialog

You can add a new controller to your project using a file template as described in the previous section or you can use the Add Controller dialog.

Select the Controllers folder in the Projects window, right click and select Add Controller to show the Add Controller dialog.

In the dialog you specify the controller's name and select one of the templates that will be used to generate the controller class. These templates are defined by a single T4 template that you can edit if you want to customise it. The T4 template exists in the following subfolder where SharpDevelop was installed:

AddIns\BackendBindings\AspNet.Mvc\ItemTemplates

Click the Add button to create a new controller from the T4 template.

Add View Dialog

A new view can be created by using a file template or by using the Add View dialog. Select one of the Views folders, right click and select Add New View to show the Add View dialog.

In the dialog you can specify the following items:

View Name - specifies the name of the view
View Engine - selects either web forms (ASPX) or Razor view engine. The options displayed in the dialog will change based on this selection.
Strongly Typed - allows you to generate a view based on a type in your project.
Model - a list of types in your project. You may have to compile your project for a class to be displayed in this drop down.
Template - specifies which of the T4 templates will be used when generating the view. Templates available are - Empty, Create, Delete, Details, Edit, List.
Use Layout (Razor) - specifies whether the view will use a layout.
Layout (Razor) - specifies the path to the layout page. The browse button allows you to select a layout page from those in your project.
User Master Page (ASPX) - specifies whether the view will use a master page.
Master Page (ASPX) - specifies the path to the master page. The browse button allows you to select a master page from those in your project.
Main Content ID (ASPX) - specifies the main content ID.
Partial View - used to generate a partial view.

Views generated from this dialog use T4 templates which exist in the following folder if you need to customise them:

AddIns\BackendBindings\AspNet.Mvc\ItemTemplates

That concludes the walkthrough of the new ASP.NET MVC 3 support in SharpDevelop. Further information on ASP.NET MVC 3 can be found at the Getting Started with ASP.NET MVC page.

New Icons for SharpDevelop

MattWard — Sat, 21 Jan 2012 17:55:00 GMT

Thanks to Yusuke Kamiyamane's Fugue Icons, and icons created and remixed by Michael Seeger, SharpDevelop 4.2 has a new look. A selection of before and after screenshots are shown below:

SharpDevelop 4.1 Toolbar

SharpDevelop 4.2 Toolbar

SharpDevelop 4.1	SharpDevelop 4.2

Machine.Specifications (MSpec)

MattWard — Wed, 09 Nov 2011 22:07:00 GMT

Here is a preview of a new feature that is planned for SharpDevelop - integrated support for Machine.Specifications.

Machine.Specifications, or MSpec for short, is a Behaviour Driven Development framework for .NET created by Aaron Jensen which takes its inspiration from SpecUnit.NET and RSpec.

Support for MSpec has been added thanks to Tomasz Tretkowski.

So let us take a look at how the MSpec integration works in SharpDevelop.

MSpec Integration

The first thing you will need to do is add a reference to MSpec in the project that will contain your specifications. The easiest way to do this is to use NuGet. Select your project, right click and select Manage Packages.

Search for the Machine.Specifications package and then click the Add button to add the NuGet package to your project.

This will add a Machine.Specifications assembly reference to your project.

Now let us create our first specification. We are going to create a specification which is based on an example provided with the MSpec source code. The specification is for transferring an amount of money between two bank accounts and is shown below.

using System; 
using Machine.Specifications; 
 
namespace Banking.Tests 
{ 
    [Subject(typeof(Account), "Funds transfer")] 
    public class when_transferring_between_two_accounts 
    { 
        static Account fromAccount; 
        static Account toAccount; 
         
        Establish context = () => { 
            fromAccount = new Account { Balance = 1m }; 
            toAccount = new Account { Balance = 1m }; 
        }; 
         
        Because of = () => 
            fromAccount.Transfer(1m, toAccount); 
         
        It should_debit_the_from_account_by_the_amount_transferred = () => 
            fromAccount.Balance.ShouldEqual(0m); 
         
        It should_credit_the_to_account_by_the_amount_transferred = () => 
            toAccount.Balance.ShouldEqual(2m); 
    } 
}

MSpec uses Establish/Because/It which is equivalent to Given/When/Then that is used with SpecFlow. Establish is used to setup the initial state. Because is used to define the event/action that you are testing. It is used to test the final state and see if it matches what is expected.

The Account class that is used by this specification is shown below.

using System; 
 
namespace Banking 
{ 
    public class Account 
    { 
        public decimal Balance { get; set; } 
        
        public void Transfer(decimal amount, Account toAccount) 
        {             
        }
    } 
}

Specifications are displayed in the Unit Tests window. This window can be opened by selecting Unit Tests from the View | Tools menu. The specification we have defined will be displayed in the Unit Test window as shown below.

The Unit Tests window will update as the specification is written in the same way it does when you are writing NUnit tests.

To run MSpec you can right click a specification and select Run tests or you can click the toolbar buttons at the top of the Unit Tests window.

Failures will be highlighted in Red in the Unit Tests window.

The output from MSpec is displayed in the Output window.

Failures are also added to the Errors window. Clicking on an error will take you directly to the source code for the failing test.

Now we have to fix the failures by implementing the Account's Transfer method. The updated Transfer method is shown below:

public void Transfer(decimal amount, Account toAccount) 
{ 
    Balance -= amount; 
    toAccount.Balance += amount; 
}

After making this change and running MSpec again everything passes, as shown below.

That completes the quick introduction to using MSpec with SharpDevelop. Now let us take a look at MSpec Behaviours.

MSpec Behaviours

MSpec Behaviours are a way to group together a set of tests that you want to re-use with different contexts. To do this you create a separate class, add a Behaviors attribute to it, and move your tests into that class. This behaviour class is then referenced by using the Behaves_like syntax. An example taken from the MSpec examples is shown below.

using System; 
using Machine.Specifications; 
 
namespace Banking.Tests 
{ 
    [Subject("Date time parsing")] 
    public class when_a_date_is_parsed_with_the_regular_expression_parser 
     : DateTimeParsingSpecs 
    { 
        Establish context = () =>  
         Parser = new RegexParser(); 
 
        Because of = () =>  
         ParsedDate = Parser.Parse("2009/01/21"); 
 
        Behaves_like<DateTimeParsingBehavior> a_date_time_parser; 
    } 
 
    [Subject("Date time parsing")] 
    public class when_a_date_is_parsed_by_the_infrastructure 
     : DateTimeParsingSpecs 
    { 
        Establish context = () =>  
         Parser = new InfrastructureParser(); 
 
        Because of = () =>  
         ParsedDate = Parser.Parse("2009/01/21"); 
 
        Behaves_like<DateTimeParsingBehavior> a_date_time_parser; 
    } 
 
    public abstract class DateTimeParsingSpecs 
    { 
        protected static DateTime ParsedDate; 
        protected static IParser Parser; 
    } 
 
    [Behaviors] 
    public class DateTimeParsingBehavior 
    { 
        protected static DateTime ParsedDate; 
 
        It should_parse_the_expected_date = () =>  
            ParsedDate.ShouldEqual(new DateTime(2009, 1, 21)); 
    } 
}

Here the behaviour of the parser returning a particular date has been extracted and re-used across two different contexts.

SharpDevelop is aware of MSpec behaviours and will display the underlying tests. The date time parser specifications above will be displayed in the Unit Tests window as shown below.

For further details on MSpec behaviours take a look at the Behaviours in MSpec post by James Gregory.

Further MSpec Information

Here is a selection of links to further information on MSpec that you may find useful.

MSpec on Github

Introducing MSpec - Aaron Jensen's post that first introduced MSpec.

Getting Started with MSpec

Learning BDD - If you prefer to learn by watching a video check out Rob Conery's BDD screencast where he discusses BDD and also covers MSpec.

Make BDD your BFF - Rob Conery walks through BDD with MSpec.

Teaching a String Calculator How to Behave

Behaviours in MSpec

SubSonic T4 Templates

MattWard — Wed, 05 Oct 2011 20:33:00 GMT

SharpDevelop 4.2 now supports SubSonic T4 templates. Subsonic is an open source object-relational mapper and makes use of T4 templates in all but one of its supported methods to provide access to your data. Before we take a look at what new T4 features were added to SharpDevelop to support SubSonic let us see what you need to do to get everything working.

Using SubSonic T4 Templates with SharpDevelop

In order to use the SubSonic T4 templates with SharpDevelop you need to make two modifications to the Settings.ttinclude file.

Replace the EnvDTE assembly reference:

<#@ assembly name="EnvDTE" #>

With the following:

<#@ assembly name="$(addinpath:ICSharpCode.PackageManagement)PackageManagement.dll" #>

This references SharpDevelop's NuGet addin assembly which implements its own version of the Visual Studio object model.

In SharpDevelop 4.3 an extra assembly directive is needed, as shown below:

<#@ assembly name="SharpDevelop.EnvDTE.dll" #>

Add a new import directive as shown below:

<#@ import namespace="EnvDTE = ICSharpCode.PackageManagement.EnvDTE" #>

This creates a namespace alias for EnvDTE so the references to the Visual Studio object model in the SubSonic T4 template will work.

In SharpDevelop 4.3 the EnvDTE import directive does not need to be changed.

All that is left now is to save the changes made to the Settings.ttinclude file and generate the database access code by executing the ActiveRecord.tt, Context.tt and Struct.tt T4 templates. This can be done by right clicking them in the Projects window and selecting Execute Custom Tool.

Now we will take a look at the new features that made this possible.

Referencing SharpDevelop Properties and Environment Variables in T4 Templates

The T4 assembly and include directives now support the $(PropertyName) syntax to use SharpDevelop properties such as SolutionDir and ProjectDir.

<#@ assembly name="$(ProjectDir)lib\MyLibrary.dll" #> 
<#@ include file="$(SolutionDir)Templates\MyTextTemplate.tt" #>

The assembly and include directives also support environment variables through the %EnvironmentVariableName% syntax.

<#@ assembly name="%ProgramFiles%\lib\MyLibrary.dll" #> 
<#@ include file="%HOMEPATH%\MyTextTemplate.tt" #>

This new feature also supports the addinpath property and is used to allow a T4 template to reference SharpDevelop's NuGet addin using the $(addinpath:AddIn-ID) syntax which is expanded to the directory containing the addin.

Accessing the SharpDevelop IDE from a T4 Template

The SubSonic T4 templates use the Visual Studio object model to find the project's app.config file and read the database connection string stored here in order to access your database. To support this the T4 templating host in SharpDevelop now implements the IServiceProvider interface which allows you to access SharpDevelop's implementation of the Visual Studio object model.

To access the Visual Studio object model you set the T4 template so it is host specific:

<#@ template language="C#" hostspecific="true" #>

Then you can access the DTE object, which is the top-level object of the Visual Studio object model, as shown below.

<#
    IServiceProvider provider = (IServiceProvider)Host; 
    EnvDTE.DTE dte = (EnvDTE.DTE)provider.GetService(typeof(EnvDTE.DTE));
#>

The Visual Studio object model is not fully implemented in SharpDevelop so you may run into problems if you make extensive use of this object model.

[Update 2012-10-11] Added changes required for SharpDevelop 4.3

SpecFlow Integration

MattWard — Tue, 09 Aug 2011 19:23:00 GMT

The SpecFlow team recently released version 1.7 and with it they included support for SharpDevelop 4.0. SpecFlow is an open source framework that you can use to do Behaviour Driven Development (BDD) on .NET. It allows you to bind business requirements to the code. Let us take a look at how SpecFlow integrates with SharpDevelop.

Installation

Download and install the following:

If SharpDevelop is installed first then the SpecFlow installer will detect SharpDevelop, as shown in the screenshot below.

The installer will then add a set of SpecFlow templates to SharpDevelop. It will also install a SharpDevelop addin which you will need to register using the addin manager. To register the SpecFlow addin start SharpDevelop and from the Tools menu select AddIn Manager. This will open the AddIn Manager dialog.

Click the Install AddIn button and browse to the SpecFlow installation folder. The default installation folder for SpecFlow is C:\Program Files\TechTalk\SpecFlow. In this folder find the TechTalk.SpecFlow.SharpDevelop4Integration.addin file, select it and click the Open button. The SpecFlow addin should then be displayed in the AddIn Manager dialog.

Restart SharpDevelop so the SpecFlow addin is loaded and is ready to be used.

Now let us take a look at how to use SpecFlow with SharpDevelop.

Using SpecFlow

Here we will follow the workflow that is shown on the SpecFlow web site. This workflow looks at creating a bowling game using SpecFlow.

In SharpDevelop create a new C# class library project called Bowling. Right click the project just created and select Add New Item. In the New File dialog open the SpecFlow category and select the SpecFlow Feature template. Change the filename to be ScoreCalculation.feature. Click the Create button to save the file.

Replace the existing text in the feature file created with the text shown below.

Feature: Score Calculation 
 In order to know my performance 
 As a player 
 I want the system to calculate my total score 
 
Scenario: Gutter Game 
 Given a new bowling game 
 When all of my balls are landing in the gutter 
 Then my total score should be 0 
 
Scenario: All Strikes 
 Given a new bowling game 
 When all of my rolls are strikes 
 Then my total score should be 300

This is the specification for one part of the game. It is written in a language called Gherkin which gives you a user friendly way to specify a set of behaviours that your application should have. More information about the Gherkin language can be found on the Gherkin wiki.

Now select this feature file in the Projects window, right click and select Properties. In the file properties change the Custom Tool to be SpecFlowSingleFileGenerator.

Now every time you save the feature file a new file will be auto-generated.

If you open this generated file you will see that it contains a class that has two NUnit tests.

To run the unit tests you will need to add a reference to NUnit and SpecFlow to the project. In the Projects window, right click your project and select Add Reference. Select the .NET Assembly Browser tab and browse to the NUnit.Framework.dll file that can be found in the SharpDevelop folder C:\Program Files\SharpDevelop\4.0\bin\Tools\NUnit and add that file as a reference. Do the same for the TechTalk.SpecFlow.dll file which can be found in the C:\Program Files\TechTalk\SpecFlow folder.

Now create a new file called BowlingSteps.cs and copy the following code into it.

using System; 
using NUnit.Framework; 
using TechTalk.SpecFlow; 
 
namespace Bowling 
{ 
 
 [Binding] 
 public class BowlingSteps 
 { 
  private Game _game; 
 
  [Given(@"a new bowling game")] 
  public void GivenANewBowlingGame() 
  { 
   _game = new Game(); 
  } 
 
  [When(@"all of my balls are landing in the gutter")] 
  public void WhenAllOfMyBallsAreLandingInTheGutter() 
  { 
   for (int i = 0; i < 20; i++) 
   { 
    _game.Roll(0); 
   } 
  } 
 
  [When(@"all of my rolls are strikes")] 
  public void WhenAllOfMyRollsAreStrikes() 
  { 
   for (int i = 0; i < 12; i++) 
   { 
    _game.Roll(10); 
   } 
  } 
 
  [Then(@"my total score should be (\d+)")] 
  public void ThenMyTotalScoreShouldBe(int score) 
  { 
   Assert.AreEqual(score, _game.Score); 
  } 
 
  [When(@"I roll (\d+)")] 
  public void WhenIRoll(int pins) 
  { 
   _game.Roll(pins); 
  } 
 
  [When(@"I roll (\d+) and (\d+)")] 
  public void WhenIRoll(int pins1, int pins2) 
  { 
   _game.Roll(pins1); 
   _game.Roll(pins2); 
  }  
 
  [When(@"I roll (\d+) times (\d+) and (\d+)")] 
  public void WhenIRollSeveralTimes2(int rollCount, int pins1, int pins2) 
  { 
   for (int i = 0; i < rollCount; i++) 
   { 
    _game.Roll(pins1); 
    _game.Roll(pins2); 
   } 
  } 
 
  [When(@"I roll the following series:(.*)")] 
  public void WhenIRollTheFollowingSeries(string series) 
  { 
   foreach (var roll in series.Trim().Split(',')) 
   { 
    _game.Roll(int.Parse(roll)); 
   } 
  } 
 
  [When(@"I roll")] 
  public void WhenIRoll(Table rolls) 
  { 
   foreach (var row in rolls.Rows) 
   { 
    _game.Roll(int.Parse(row["Pins"])); 
   } 
  } 
 } 
}

The BowlingSteps.cs file shown above implements the scenarios defined in the feature file and will be used by the unit tests to verify the implementation works as expected.

The only bit that is missing is the code that implements the bowling game logic. Create a file called Game.cs and copy the code shown into it.

namespace Bowling 
{ 
 public class Game 
 { 
  public void Roll(int i) 
  {     
  } 
   
  public int Score {  
   get { return -1; } 
  } 
 } 
}

The Game.cs file contains the main Game class that implements the logic that we are going to test. Currently this code is incorrect so we are expecting the unit tests to fail.

In the Unit Tests window (View | Tools | Unit Tests) click the Run all tests toolbar button. All the tests should fail as shown below.

Now we need to fix the tests. The GutterGame test is the easiest to get working. Edit the Game class and change the Score property so it returns 0.

namespace Bowling 
{ 
 public class Game 
 { 
  public void Roll(int i) 
  { 
  } 
   
  public int Score {  
   get { return 0; } 
  } 
 } 
}

Now when you run the unit tests again the GutterGame test will pass.

The next step would be to change the Game class so the AllStrikes unit test will pass. Then you could define more scenarios in feature files to cover more functionality that you want the bowling game to have. Then you would go through the process just described until you have a working solution that meets all the requirements. These steps are not shown here but hopefully you get the idea.

We have looked at how SpecFlow integrates with SharpDevelop and walked through the process of defining a set of scenarios that our application should have, creating unit tests to check the scenarios are implemented correctly and finally implementing the application logic so the unit tests pass.

Further Information

More information on SpecFlow can be found on the SpecFlow web site and on the SpecFlow GitHub wiki.