SharpDevelop Community

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.

SharpDevelop 4.3.1: A Little Support for Markdown

siegi44 — Sun, 31 Mar 2013 08:19:00 GMT

The Markdown syntax for formatting text recently gained more and more visibility and is used especially on StackExchange, GitHub and so on. Hence we added simple highlighting support for Markdown.

Here's an example of what it currently looks like in SharpDevelop:

As you can see, it is far from complete, but it is a good start.

If you have a weekend to spare and want to help out, you could help us with one of the following features:

Code completion
Folding
Extended highlighting
Live preview view content

(We won't do those any time soon, because there are more important things to be done in SharpDevelop 5)

SharpDevelop 5 C# Tech Preview

ChristophWille — Wed, 13 Feb 2013 10:33:00 GMT

SharpDevelop 5 has been long in the making, with the bulk of the time being spent on the move to NRefactory 5 (more information). Today we finally have something to show - a C#-only tech preview of SharpDevelop 5. It is not polished, but it will give you an idea what cool things are now possible - code actions being the poster child of the new features coming.

Download

Build 2100 Setup
Build 2100 Source Code

Newer versions can be downloaded from the build server, expect more activity once SharpDevelop 4.3 has shipped.

Features entirely not available

Languages other than C# (VB.NET, IronPython, IronRuby)
Windows Forms designer
XAML code completion
Profiler
Reporting (SharpDevelop Reports)

Features with restricted functionality

NuGet: PowerShell is not yet available (console and PS scripts on install of a package).
WiX: dialog designer is not yet available.
ASP.NET MVC: Code completion and folding currently disabled for Razor and Web Forms (.aspx) files.
Debugger: The object graph visualizer doesn't support collections yet; performance issues for larger collections.

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).

Progress of XML Forms Conversion in SharpDevelop 4.3

cssdadmin — Mon, 31 Dec 2012 12:14:00 GMT

One of the goals for SharpDevelop 5 is to convert legacy XML Forms (xfrms) to WPF, and drop support for XML Forms entirely. Now, you might be asking "Did I miss a Microsoft UI technology?" No, you didn't. XML Forms is a SharpDevelop-internal mechanism for declarative form design (for Windows Forms) that predates WPF by a couple of years - and it shows its age especially when it comes to more design-centric issues (I already mentioned: it is Windows Forms).

To have some of the benefits today, I started the conversion on SharpDevelop 4.3 (it will also be easier to merge between the branches this way). In order for you to know where those conversions happened - and why some behavior might have changed (bugs: please let us know!) - this blog post shows a full list of the changed addin and panels.

Fully Converted Addins

Any and all forms in those addins have been converted:

CppBinding
CSharpBinding
VBNetBinding
ICSharpCode.CodeAnalysis (FxCop)
ICSharpCode.SourceAnalysis - (MattEverson.SourceAnalysis) (StyleCop)
ICSharpCode.CodeCoverage

Converted Option Panels (Options Dialog)

The panels have been converted, and they now derive from ICSharpCode.SharpDevelop.Gui.OptionPanels.ProjectOptionPanel (important for those of you interested in building new addins):

CSharpBinding.OptionPanels.BuildOptions
ICSharpCode.SharpDevelop.Gui.OptionPanels.BuildEvents
ICSharpCode.SharpDevelop.Gui.OptionPanels.Signing
ICSharpCode.SharpDevelop.Gui.OptionPanels.ReferencePaths
ICSharpCode.SharpDevelop.Gui.OptionPanels.ApplicationSettings
ICSharpCode.SharpDevelop.Gui.OptionPanels.DebugOptions
ICSharpCode.CppBinding.Project.ApplicationOptions
ICSharpCode.CppBinding.Project.PreprocessorOptions
ICSharpCode.CppBinding.Project.LinkerOptions
ICSharpCode.VBNetBinding.OptionPanels.ProjectImports
ICSharpCode.VBNetBinding.OptionPanels.BuildOptions
ICSharpCode.AspNet.Mvc.WebProjectOptionsPanel
ICSharpCode.SourceAnalysis.AnalysisProjectOptionsPanel
ICSharpCode.CodeAnalysis.AnalysisProjectOptionsPanel
ICSharpCode.CodeCoverage.CodeCoverageProjectOptionsPanel
ICSharpCode.SharpDevelop.Gui.OptionPanels.ServiceReference.ServiceReferenceOptionsPanel
ICSharpCode.SharpDevelop.Gui.OptionPanels.ProjectCustomToolOptionsPanel
ICSharpCode.SharpDevelop.Gui.OptionPanels.TaskListXaml
ICSharpCode.SharpDevelop.Gui.OptionPanels.SelectStylePanel
ICSharpCode.SharpDevelop.Gui.OptionPanels.SelectCulturePanel
ICSharpCode.SharpDevelop.Gui.OptionPanels.ProjectAndSolutionOptions
ICSharpCode.SharpDevelop.Gui.OptionPanels.LoadSaveOptions
ICSharpCode.SharpDevelop.Gui.OptionPanels.EditStandardHeaderPanel
ICSharpCode.SharpDevelop.Gui.OptionPanels.CodeGenerationPanel
ICSharpCode.SharpDevelop.Gui.OptionPanels.ExternalToolPanel
ICSharpCode.SharpDevelop.Editor.CodeCompletion.CodeCompletionPanel
ICSharpCode.Profiler.AddIn.OptionPanels.General
CSharpCode.PythonBinding.PythonOptionsPanel
ICSharpCode.XamlBinding.Options.CodeCompletion
Debugger.AddIn.Options.DebuggingOptionsPanel
ICSharpCode.PackageManagement.RegisteredProjectTemplatePackageSourcesView
ICSharpCode.PackageManagement.PackageManagementOptionsView
MSHelpSystem.Help3OptionsPanel
ICSharpCode.UsageDataCollector.OptionPage
ICSharpCode.FormsDesigner.Gui.OptionPanels.LocalizationModelOptionsPanel
ICSharpCode.FormsDesigner.Gui.OptionPanels.GridOptionsPanel
ICSharpCode.FormsDesigner.Gui.OptionPanels.GeneralOptionsPanel
ICSharpCode.XmlEditor.XmlEditorOptionsPanel
ICSharpCode.AvalonEdit.AddIn.Options.TextViewOptions
ICSharpCode.AvalonEdit.AddIn.Options.HighlightingOptions
ICSharpCode.AvalonEdit.AddIn.Options.GeneralEditorOptions
ICSharpCode.AvalonEdit.AddIn.Options.BehaviorOptions
HexEditor.View.HexEditOptionsPanel
ICSharpCode.CodeAnalysis.AnalysisIdeOptionsPanel
ICSharpCode.CodeCoverage.CodeCoverageOptionsPanel
ICSharpCode.SourceAnalysis.AnalysisIdeOptionsPanel

The work for 4.3 in this area is now done, the conversion will be completed in SharpDevelop 5.

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()

Installing SharpDevelop on Windows 8

ChristophWille — Wed, 15 Aug 2012 19:41:00 GMT

With Windows 8 released to MSDN and TechNet subscribers today, I thought it'd be a good idea to give a short guide for installing SharpDevelop on a blank Windows 8 installation - because it will fail with an error message (although the screenshot is for SharpDevelop 4.3, the same applies for 4.2):

The easiest way to fix this is to install .NET 3.5 (used by lots of other applications / drivers, thus if you don't install SharpDevelop first thing on Windows 8, it might just install right away because somebody else auto-installed this dependency).

You are looking for "Turn Windows features on or off" - this will open the "Windows Features" dialog on the desktop:

Make sure to check ".NET Framework 3.5", click OK, let it connect to Windows Update and finish the installation. Once done, you can go back to installing SharpDevelop, as it now has all required dependencies!

Note You can alternatively install just the VC++ 2008 SP1 runtime.

Import and Export of Highlighting Settings

ChristophWille — Mon, 13 Aug 2012 05:45:00 GMT

Yesterday, Siegfried put finishing touches on the import/export of color schemes in SharpDevelop. To give you an idea, let's take a look at the following screenshot:

This is an imported color scheme from StudioStyl.es, more specifically http://studiostyl.es/schemes/son-of-obsidian-with-resharper.

Now, how do you get one of those color schemes installed in SharpDevelop? You have to go to the Tools / Options dialog, Text Editor / Highlighting section:

There you will find the "Import highlighting colors" button, that allows you to pick a highlighting definition - either one that was exported from SharpDevelop, or one that came from Visual Studio (as is the case with StudioStyl.es):

Please do note that if you have existing customizations, the import will warn you that those will be reset (otherwise you might end up with very interesting intersections of color schemes).

Speaking of interesting effects: if you compare the first screenshot with the first listing on the StudioStyl.es page, you will notice differences such as the type coloring or the constructor (eg line 15). The reason for this is that sometimes VS supports more options, other times it is SharpDevelop - thus there can't be a perfect mapping when you import from a VS settings file. You might need to make slight adjustments in SharpDevelop after the import to get a perfect look.

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]

NRefactory 5 article

DanielGrunwald — Sat, 11 Aug 2012 16:36:00 GMT

I have published a CodeProject article documenting NRefactory 5: Using NRefactory for analyzing C# code

While NRefactory 5 itself is pretty much stable, there's still a lot of work to do for SharpDevelop 5 to use it -- pretty much everything in SharpDevelop dealing with source code needs to be ported to the new NRefactory 5 API.

But I think this article shows that NRefactory 5 will open up a lot of new feature possibilities. For example, we could detect problems like the missing StringComparison described in the article directly in the SharpDevelop editor while you're typing, no need to recompile. In fact, the MonoDevelop project has two GSoC students working on such live issue detection and other code actions (small refactorings), and most of their code will be usable in both IDEs.

So you can look forward to a much improved C# editing experience in SharpDevelop 5 :)

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.

ILSpy 2.1 async/await Decompilation Support

ChristophWille — Sun, 03 Jun 2012 14:47:00 GMT

ILSpy 2.1 is available as of now - it supports async/await decompilation:

ILSpy_Master_2.1.0.1603_RTW_Binaries.zip
ILSpy_Master_2.1.0.1603_RTW_Source.zip

A few weeks ago, Daniel blogged about the details of how decompiling async / await is implemented. If you are only interested in the results, see the below screenshot for a proof of decompilation working (on Windows 8 RP):

As a reminder: next week on Friday we'll do a Webcast on ILSpy.

AvalonEdit 4.3: Input Method Editor support

siegi44 — Sat, 02 Jun 2012 07:02:00 GMT

Good news for all Chinese, Japanese and Korean users of AvalonEdit (and others using complex script). Recently we were able to add integrated support for IMEs (Input Method Editors) in the latest version of AvalonEdit.

Before: The IME is floating outside of the text area.

After: The IME is directly integrated into the editor. In the first part you can see Korean IME, in the second one Japanese IME in Hiragana Mode.

Tested on: Windows 7

In the development team we don't use IME and we couldn't test it very well, due to a lack of knowledge of the specific languages. (I only know a little Korean and even less Japanese.) So if you run into a bug while using it, please report it on the forums.

Webcast: SharpDevelop Q&A Saturday June 9th

ChristophWille — Thu, 31 May 2012 07:31:00 GMT

From June 7th to June 10th the SharpDevelop team met in Bad Ischl, Austria for their annual #develop developers days (#d^3). This year we did a virtual Q&A session, where we talked about roadmap, architecture, implementation and extensibility.

The recording of the Webcast is available on YouTube: http://www.youtube.com/watch?v=5HaTYJ3AThQ

From our end Daniel, David and myself took part, and as a special guest we had Mike Krüger from MonoDevelop.

There are quite a few interesting tidbits, but we won't spoil it for you - make sure to watch the recording!

Webcast: ILSpy Q&A Friday June 8th

ChristophWille — Thu, 31 May 2012 07:29:00 GMT

The recording of the Webcast is available on YouTube: http://www.youtube.com/watch?v=dO2BdIMckcY

Notes on a few glitches: in the introduction I missed Daniel (sorry!), and there was one recording glitch - my machine is Windows 8 RP, and somehow it didn't record the window content of Internet Explorer 10 but used the default start screen. The link I was mentioning for ILSpy plugins is this one here (it then worked perfectly fine on Daniel's machine).

At the end, David posed an interesting question: Would editing an assembly you are currently debugging in the ILSpy debugger be useful? Adding in general: we need your feedback for improving features as well as prioritizing which ones you need first. Please let us know!

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.

Async Targeting Pack in SharpDevelop 4.2 (and later)

ChristophWille — Fri, 04 May 2012 09:32:00 GMT

Microsoft has released the Async Targeting Pack for Visual Studio 11, which is also available as a NuGet package - and thus available in SharpDevelop. What does this Targeting Pack do? It allows you to use the async / await constructs in your pre-.NET 4.5 application.

Take the following application project:

It comes up with a couple of errors that wouldn't show if I had been targeting .NET 4.5. So how to fix this? NuGet to the rescue:

Search for the Microsoft.CompilerServices.AsyncTargetingPack from the Manage Packages dialog (don't forget to click Add!):

Now your project will build and run nicely - note the new assembly reference (Microsoft.CompilerServices.AsyncTargetingPack.Net4) and NuGet configuration (packages.config):

One important caveat though: You must have .NET 4.5 installed on your development machine and set the project to build using the C# 5.0 compiler!

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.

Decompiling Async/Await

DanielGrunwald — Mon, 16 Apr 2012 12:23:00 GMT

Just after the ILSpy 2.0 release, I started adding support for decompiling C# 5 async/await to ILSpy.

You can get the async-enabled ILSpy build from our build server.

The async support is not yet complete; for example decompilation fails if the IL evaluation stack is not empty at the point of the await expression.

The decompilation logic highly depends on the patterns produced by the C# 5 compiler - it only works with code compiled with the C# compiler in the .NET 4.5 beta release, not with any previous CTPs. Also, it is likely that ILSpy will need adjustments for the final C# 5 compiler.

While testing, I found that the .NET 4.5 beta BCL was not compiled with the beta compiler - where the beta compiler uses multiple awaiter fields, the BCL code uses a single field of type object and uses arrays of length 1. This is similar to the code generated by the .NET 4.5 developer preview, so my guess is that Microsoft used some internal version in between the developer preview and the beta for compiling the .NET 4.5 beta BCL. For more information, take a look at Jon Skeet's description of the async codegen changes.
This means the ILSpy cannot decompile async methods in the .NET 4.5 beta BCL. This problem should disappear with the next .NET 4.5 release (.NET 4.5 RC?).

So how does ILSpy decompile async methods, then? Consider the compiler-generated code of the move next method:

// Async.$AwaitInLoopCondition$d__17
void IAsyncStateMachine.MoveNext()
{
    try
    {
        int num = this.$1__state;
        TaskAwaiter<bool> taskAwaiter;
        if (num == 0)
        {
            taskAwaiter = this.$u__$awaiter18;
            this.$u__$awaiter18 = default(TaskAwaiter<bool>);
            this.$1__state = -1;
            goto IL_7C;
        }
        IL_23:
        taskAwaiter = this.$4__this.SimpleBoolTaskMethod().GetAwaiter();
        if (!taskAwaiter.IsCompleted)
        {
            this.$1__state = 0;
            this.$u__$awaiter18 = taskAwaiter;
            this.$t__builder.AwaitUnsafeOnCompleted<TaskAwaiter<bool>, Async.$AwaitInLoopCondition$d__17>(ref taskAwaiter, ref this);
            return;
        }
        IL_7C:
        bool arg_8B_0 = taskAwaiter.GetResult();
        taskAwaiter = default(TaskAwaiter<bool>);
        if (arg_8B_0)
        {
            Console.WriteLine("Body");
            goto IL_23;
        }
    }
    catch (Exception exception)
    {
        this.$1__state = -2;
        this.$t__builder.SetException(exception);
        return;
    }
    this.$1__state = -2;
    this.$t__builder.SetResult();
}

The state machine works similar to the one used by yield return; so we could reuse a lot of the code from the yield return decompiler.
Each try block begins with a state dispatcher: depending on the value of this.$1__state, the code jumps to the appropriate location. If the async method involves exception handling, there will be a separate state dispatcher at the beginning of each try block.
In this case, there are only two states: the initial state (state = -1) and the state at the await expression (state = 0). The state dispatcher consists only of the two statements "int num = this.$1__state; if (num == 0)". We rely on the fact that in the actual IL code, the state dispatcher is a contiguous sequence of IL instructions, in front of any of the method's actual code.

Note that the async/await decompiler step runs on the ILAst very early in the decompiler pipeline, immediately after the yield return transform, which is prior to any control flow analysis. We're basically still dealing with IL instructions here; but I'm explaining it in terms of C# as that is easier to read (and makes the code much shorter).

The analysis of the state dispatcher works using symbolic execution; it is described in more detail in the yield return decompiler explanation. In our example, the result of the analysis is that the beginning of the first if statement is reached for state==0, and label IL_23 is reached for all other states.

With this information, we start cleaning up the control flow of the method. We look for any 'return;' statements and analyze the instructions directly in front:

            this.$1__state = 0;
            this.$u__$awaiter18 = taskAwaiter;
            this.$t__builder.AwaitUnsafeOnCompleted<TaskAwaiter<bool>, Async.$AwaitInLoopCondition$d__17>(ref taskAwaiter, ref this);
            return;

We then replace this piece code with an instruction that represents the AwaitUnsafeOnCompleted call (represented as "await ref taskAwaiter;" in the following code), followed by a goto to the label for the target state (using the information gained from the symbolic execution). We also remove the boilerplate associated with the $t__builder and the state dispatcher. For demonstration purposes, I'll skip the remaining steps of the async/await decompiler and resume the pipeline to decompile the ILAst to C#, producing the following code:

public async void AwaitInLoopCondition()
{
    while (true)
    {
        TaskAwaiter<bool> taskAwaiter = this.$4__this.SimpleBoolTaskMethod().GetAwaiter();
        if (!taskAwaiter.IsCompleted)
        {
            await ref taskAwaiter;
            taskAwaiter = this.$u__$awaiter18;
            this.$u__$awaiter18 = default(TaskAwaiter<bool>);
            this.$1__state = -1;
        }
        bool arg_8B_0 = taskAwaiter.GetResult();
        taskAwaiter = default(TaskAwaiter<bool>);
        if (!arg_8B_0)
        {
            break;
        }
        Console.WriteLine("Body");
    }
}

As you can see, this transformation has simplified the control flow of the method dramatically.

We now just perform some finishing touches on the method:

Access to the state machine fields is replaced with local variable access, e.g. "this.$4__this" becomes "this".
We detect the "GetAwaiter() / if (!taskAwaiter.IsCompleted) / GetResult() / clear awaiter" pattern and replace it with a simple await expression

Mind that all of this isn't done on the C# representation, but in an early stage of the ILAst pipeline. After some simplifications (variable inlining, copy propagation), the resulting ILAst looks like this:

br(IL_23)
IL_16:
call(Console::WriteLine, ldstr("Body"))
IL_23:
brtrue(IL_16, await(callvirt(Async::SimpleBoolTaskMethod, ldloc(this))))
ret()

Apart from the 'await' opcode, this is exactly the same as the while-loop would look in a non-async method. The remainder of the decompiler pipeline will detect the loop and translate it to the C# code you've seen in the introductory screenshot.

ILSpy 2.0 Final

ChristophWille — Sun, 15 Apr 2012 10:39:00 GMT

Today, we released ILSpy 2.0 final to the Web:

ILSpy_Master_2.0.0.1595_RTW_Binaries.zip
ILSpy_Master_2.0.0.1595_RTW_Source.zip

Daniel's Beta feature post still applies to the release version:

Assembly Lists
Support for decompiling Expression trees
Support for lifted operatores on nullables
Decompile to Visual Basic
Search for multiple strings separated by space (searching for "Assembly manager" in ILSpy.exe would find AssemblyListManager)
Clicking on a local variable will highlight all other occurrences of that variable
Ctrl+F can be used to search within the decompiled code view

However, one thing changed for the binaries distribution: we do not include the debugger addin by default (it is part of the source download). The reason is that it is not stable enough - we´re improving the debugger in SharpDevelop and don´t have the resources to port those changes over to ILSpy just yet.

SharpDevelop 4.2: Debugging C# 5 async methods

siegi44 — Sat, 10 Mar 2012 20:38:00 GMT

As Chris already announced in a previous blog post, SharpDevelop 4.2 and later will support targeting .NET 4.5. One of the interesting new features in .NET 4.5/C# 5 is async. If you have already tried debugging an async method, you will have noticed, that SharpDevelop's debugger is unable to evaluate any local variables.

In short this is because async is - similar to iterator blocks (yield return) - implemented as state machine in a compiler-generated struct. So the debugger has to find the correct location (i.e. compiler-generated code) where all the local variable's values are stored.

In the most recent nightly builds of SharpDevelop 4.2 Beta 2 (starting with build 4.2.0.8661), we've applied the necessary plumbing to make it work. But see for yourself:

Project Behaviors - Extensibility in the Project System

siegi44 — Sun, 04 Mar 2012 14:00:00 GMT

With the upcoming release of SharpDevelop 4.2, you get support for ASP.NET MVC projects based on IIS and IIS Express. We also want to give you debugging support. However this required some changes in our project system, because web development usually involves a web server and the IDE attaches its debugger to the web server when the project is run. This is fundamentally different from normal projects.

Another point is that projects consist of different "project types". For example a WPF project is usually C# + WPF or VB + WPF. An ASP.NET MVC project even consists of three parts: C#, web and MVC.

The Solution

Visual Studio solves this by inserting different project type GUIDs into the project file. Depending on the GUIDs it opens the project file with a different handler. While this approach is a good idea, its implementation in Visual Studio requires the project file to be read two times. First it is opened and scanned for the project type GUIDs and then opened again with an XML parser and finally loaded completely. (Source: [1])

So each project type can have various sub-types defined by GUIDs. Scala implements such type compositions through mixins. In fact we would need something like this (pseudo syntax):

var mvcProject = new CSharpProject() with WebSupport(), MVCSupport();

Of course this is not possible in C#. So we borrowed this concept and implemented it through project behavior chains, as described below:

In SharpDevelop we first load the project file into an IProject container. Which container to use is defined by the file extension. So there is a CSharpProject (.csproj), VBProject (.vbproj) or FSharpProject (.fsproj) and so on. After the container is initialized and the file has been loaded, we look for the project type GUIDs and then load all the project behaviors that apply to the different GUIDs.

A project behavior is a set of virtual methods that can be overridden to alter certain behavior of the project (for example Start, which starts the project with or without debugger). Project behaviors are chained together in the order they appear in the AddIn Tree. If a project behavior does not want to handle a certain call, it is passed onto the next project behavior. At the end of the chain there is the default project behavior which implements the defaults for each project type.

This change allows AddIns to implement different handlers for different projects without modifying the whole project system and/or the debugger.

[1] http://connect.microsoft.com/VisualStudio/feedback/details/481981/adding-a-file-named-projecttypeguids-cs-to-a-library-project-causes-following-error-the-project-type-is-not-supported-by-this-installation

MSBuild Multi-Targeting in SharpDevelop

DanielGrunwald — Sun, 04 Mar 2012 12:40:00 GMT

SharpDevelop has had multi-targeting support for a long time - for example, SharpDevelop 2.0 supported targeting .NET 1.0, 1.1 and 2.0. Our original multi-targeting implementation would not only change the target framework, but also use the matching C# compiler version*.

When Visual Studio 2008 and MSBuild 3.5 came along and introduced official multi-targeting support, we separated the 'target framework' and 'compiler version' settings. The 'target framework' setting uses the <TargetFrameworkVersion> MSBuild property, which is the official multi-targeting support as in Visual Studio 2008. The 'compiler version' setting determines the MSBuild ToolsVersion, which controls the version of the C# compiler to use - Visual Studio does not have this feature.

I'll call the latter feature MSBuild Multi-Targeting, as this allows us to pick the MSBuild version to use, and thus enables SharpDevelop to open and edit VS 2005 or 2008 projects without having to upgrade them to the VS 2010 project format.

Unfortunately, life isn't as simple as that. It turns out that MSBuild 4.0 is unable to compile projects with a ToolsVersion lower than 4.0 if the Windows SDK 7.1 is not installed. To allow users to use SharpDevelop without downloading the Windows SDK, we implemented a simple fix: we use MSBuild 3.5 to compile projects with a ToolsVersion of 2.0 or 3.5. This is why SharpDevelop ships with both "ICSharpCode.SharpDevelop.BuildWorker40.exe" and "ICSharpCode.SharpDevelop.BuildWorker35.exe".

Now what happens if SharpDevelop is run on a machine without .NET 3.5? If the framework specified by the 'ToolsVersion' is missing, SharpDevelop crashed with an MSBuild error when opening the project. There were also crashes when creating/upgrading projects to missing ToolsVersions. Moreover, in the rare scenario where .NET 2.0 and .NET 4.0 are installed, but .NET 3.5 is missing, SharpDevelop was able to open the project but the build worker would crash when trying to compile.

For this reason, the SharpDevelop 4.0 and 4.1 setups require both .NET 3.5 and .NET 4.0 to be installed. This wasn't an issue when we made that decision - .NET 3.5 is likely to be already installed on most machines. However, Windows 8 will change that - .NET 4.5 is installed by default, but .NET 3.5 is missing. So we added the necessary error handling to SharpDevelop 4.2. The SharpDevelop 4.2 setup no longer requires .NET 3.5 - you'll need it only when targeting .NET 2.0/3.0 or 3.5.

Another issue is that .NET 4.0 does not ship with the Reference Assemblies - you need to install the Windows SDK to get those. This causes MSBuild to reference the assemblies in the GAC instead, which might be a later version (due to installed service packs or in-place upgrades like .NET 4.5), and also emit massive amounts of warnings (one warning per reference). Moreover, it caused the 'Copy Local' flag to default to true for references to .NET assemblies, causing System.dll etc. to be copied into the output directory.

At the time, the reference assemblies were only available as part of Visual Studio 2010 - the free Windows SDK 7.1 was released later. So it was a high priority for us to work around this problem. For this reason, SharpDevelop injects a custom MSBuild .targets file into the project being built: SharpDevelop.TargetingPack.targets. This file runs a simple custom MSBuild task that detects references to default .NET assemblies and sets the 'Copy Local' flag to false. (we also inject several other custom .targets files; for example for running FxCop or StyleCop as part of a build)

We used the Microsoft.Build.Utitilies.dll when implementing this custom task. However, that library ships only with .NET 2.0, not with .NET 4.0, so we had to switch to Microsoft.Build.Utitilies.v4.dll to get the C# 4.0 build working without .NET 2.0. This should not be a problem as the copy local workaround is only included when targeting .NET 4.0 or higher, so we won't try to load it the 3.5 build worker process.

To summarize, the SharpDevelop 4.2 setup requires:

Windows XP SP2 or higher
.NET 4.0 Full (.NET 4.5 Full will also work)
VC++ 2008 runtime (part of .NET 3.5 so most people have it already)
In the minimal configuration, you can only compile for .NET 4.0 using MSBuild 4.0.

Additionally:

If .NET 4.5 is installed, the C# 5 compiler will replace the C# 4 compiler; and .NET 4.5 will appear as an additional target framework.
If .NET 3.5 SP1 is installed, you will be able to use .NET 2.0/3.0/3.5 as target framework, and C# 2 and C# 3 as compiler versions.
Installing the Windows SDK 7.1 is highly recommended (provides reference assemblies and documentation for code completion).
Some SharpDevelop features might require installation of additional tools such as FxCop, StyleCop, F#, TortoiseSVN, SHFB.

* Everything said about the C# compiler in this post also applies to the VB compiler.