SharpDevelop Community

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.

SharpDevelop Platform Roadmap

ChristophWille — Sat, 03 Mar 2012 14:31:00 GMT

We have waited till the Beta phase of .NET Framework 4.5 to finally decide on our platform story - what will be supported and what will be required.

SharpDevelop 4.x

It will continue to require .NET 4.0 as its runtime, but it will also run on .NET 4.5 (if you upgraded your machine). It supports (as compilation targets) 2.0 to 4.5 - if those frameworks are installed on your machine.

We are currently wrapping up feature development for 4.2, and we have plans for a further feature release 4.3. After that, the current plans are for servicing releases that update dependencies and/or fix bugs. Given those plans, expect 4.x releases for at least a year to come.

SharpDevelop 5 "Zimnitz"

This has been in development for some time already, and you have seen "offsprings" like ILSpy or Code Quality Analysis in SharpDevelop 4.2 to "prove" that our new NRefactory (*) is up to the job. Given that all IDE services need to be adapted to the new infrastructure, we will also take advantage of features in .NET 4.5, thus upping the requirements of SharpDevelop.

However, this means for a considerable part of our current user base to start planning for the future - because .NET 4.5 will likely not support XP (maybe not even Vista). Betas of SD5 will start showing up later this year.

Although the requirements change, the support of frameworks stays the same. (you will only have to install a newer OS on your development machine, deployment is unaffected)

* NRefactory 5 is developed together with the MonoDevelop team, and will support features such as semantic highlighting or more (sophisticated) refactorings.

Soon on Your Computer - SD 4.2 Beta 2

ChristophWille — Sat, 03 Mar 2012 14:27:00 GMT

With support for .NET 4.5, and yes, it does run on Windows 8 Consumer Preview too:

ILSpy 2.0 Beta 1

DanielGrunwald — Thu, 16 Feb 2012 17:45:00 GMT

After a long pause, we have finally released the first Beta of ILSpy 2.0.

Download:

New features compared with version 1.0:

Assembly Lists
Support for decompiling Expression trees
Support for lifted operatores on nullables
Integrated Debugger
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

SharpDevelop 4.2: Code Quality Analysis - Dependency Matrix

siegi44 — Mon, 06 Feb 2012 17:49:00 GMT

In SharpDevelop 4.2 Beta we added a new feature which was partially developed by Tomas Linhart during GSoC 2010. Because it was never finished it took us some time to complete it after GSoC. One of the biggest changes after GSoC was the rewrite of the core engine. The engine now uses the new NRefactory 5 Type System in combination with Mono.Cecil.

It is nearly done now, only little changes to the UI will be made until the final release of SharpDevelop 4.2.

To launch the addin, simply select Analysis > Analyze Code Quality from the main menu. First you have to select a set of assemblies from the file system. After the analyzer completes the matrix above will be shown. The colours are quite simple:

Green: left uses top
Blue: left is used by top
Turquoise: left uses and is used by top

The numbers in the cells tell you how many dependencies there are from left to top or vice versa.

For example this code:

string M(string a) { return a.ToLower(); }

It has three usages of the type System.String and one usage of the method System.String.ToLower.

But in our matrix we show only one dependency on System.String, otherwise the numbers would be too noisy. This shows that there is one class from mscorlib involved in the method M.

This is only a preview and I hope it is useful to you. If you have any suggestions or find bugs, please feel free to post a comment below or on the forums.

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

Output pad: Ported to WPF and added search functionality

siegi44 — Thu, 05 Jan 2012 19:51:00 GMT

While hunting a bug related to Windows Forms, we decided to move the output pad to WPF. It now uses AvalonEdit instead of a textbox and we added support for file hyperlinks (C#, VB and NUnit); additionally you can now search through debug output by pressing Ctrl+F while the output pad is focused.

Decompilation of Object / Collection Initializers with ILSpy

ChristophWille — Mon, 19 Dec 2011 15:02:00 GMT

If you test a method like the following:

        static void TestWithUnusedVariables()
        {
            var x = new Demo()
            {
                SomeProperty = "Hello World"
            };
 
            var y = new List<Demo>
            {
                new Demo() {
                    SomeProperty = "nada"
                    },
                new Demo()
                    {
                        SomeProperty = "nix"
                    }
            };
        }

And decompile with ILSpy you might be thinking that object / collection intializers are not being detected:

private static void TestWithUnusedVariables()
{
    Demo demo = new Demo();
    demo.SomeProperty = "Hello World";
    List<Demo> list = new List<Demo>();
    list.Add(new Demo
    {
        SomeProperty = "nada"
    });
    list.Add(new Demo
    {
        SomeProperty = "nix"
    });
}

Well, you are right. The reason being that the compilers sees that my user variables are not being used, thus optimizing the code by only keeping the compiler-generated ones, thus making it impossible for us to correctly detect the initializer.

However, if you use the variables

        static void TestWithUsedVariables()
        {
            var x = new Demo()
            {
                SomeProperty = "Hello World"
            };
 
            var y = new List<Demo>
            {
                new Demo() {
                    SomeProperty = "nada"
                    },
                new Demo()
                    {
                        SomeProperty = "nix"
                    }
            };
 
            x.SomeProperty = "noch was";
            var z = y.Count();
        }

ILSpy will correctly come up with proper decompiled code:

private static void TestWithUsedVariables()
{
    Demo x = new Demo
    {
        SomeProperty = "Hello World"
    };
    List<Demo> y = new List<Demo>
    {
        new Demo
        {
            SomeProperty = "nada"
        },
        new Demo
        {
            SomeProperty = "nix"
        }
    };
    x.SomeProperty = "noch was";
    int z = y.Count<Demo>();
}

In the sense of a "variable being used" the decompilation also works for variables only used to pass back a value:

        static Demo TestWithReturnValue()
        {
            return new Demo()
                {
                    SomeProperty = "Hello World"
                };
        }

ILSpy output:

private static Demo TestWithReturnValue()
{
    return new Demo
    {
        SomeProperty = "Hello World"
    };
}

Bottom line: object and collection initializers are being properly decompiled if we can ascertain that it actually is one.

AvalonEdit 4.2: Virtual Space

siegi44 — Sun, 27 Nov 2011 08:38:00 GMT

In recent builds of SharpDevelop 4.2 and AvalonEdit I implemented the "Virtual Space" feature. This feature allows you to place the caret after the end of the line. It was necessary to properly implement rectangle selection.

You can enable it in the TextEditor by setting EnableVirtualSpace = true or in the SharpDevelop options. When a rectangle selection is active virtual space is enabled implicitly.

For a detailed overview/explanation see the following:

I hope you find this useful. If you find any bugs or have a suggestion, please leave a comment!

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

SharpDevelop 4.2: Search and Replace refurbished

siegi44 — Sat, 05 Nov 2011 15:00:00 GMT

The Search and Replace engine used in SharpDevelop had a bad architecture. The concept of IDocumentIterator (for a number of documents) and ITextIterator (for a single document) leads to problems when doing manual "Find next" over multiple documents. It leads code duplication and there are lots of hacks to circumvent all sorts of bugs.

In the most recent alpha builds of SharpDevelop 4.2 the core parts of the Search and Replace engine were rewritten. While rewriting the code I wanted to get rid of code duplication, bugs, special cases and improve performance of the search engine. In a first step I removed all the existing engine code.

Choosing a search algorithm

There are lots of debates on .NET string search algorithm on the net. Some propose to use IndexOf, because it seems faster than Regex, others suggest to implement your own FastIndexOf. I choose to implement search using the Regex classes in the BCL for several reasons:

It is easier to maintain because it is less code. Additionally the Regex classes are well tested in contrast to a custom IndexOf.
There are multiple search modes: Normal, Wildcards and Regex. For regex, of course, we had to use the Regex classes. Wildcards are easier to translate to regex and plain text search is fast enough (if not faster in some cases), when using compiled regex.
Features like "Ignore case" and "Match whole words" are implemented with Regex easily. "Match whole words" is simply \bsearchTerm\b.

Using regex has helped to get rid of code duplication, bugs and special cases. I hope you agree with me and see the benefits of simplicity in contrast to micro and rare-case optimization.

SearchPanel: Single file search - Integrated into the AvalonEdit text editor

In AvalonEdit 4.2 Ctrl+F functionality has been directly built into the editor. The normal Search and Replace dialog has been moved to Ctrl+Shift+F. Incremental and Quick find were removed, because the SearchPanel is a very powerful replacement.

As you can see it offers some basic search options. You can use F3 to jump to the next match and Shift+F3 to move to the previous match.The SearchPanel will soon be integrated into ILSpy to allow full-text search in currently decompiled code.

Improving performance and usability of Find all in multiple files

One of the weaknesses of Find all in SharpDevelop was its speed on the one hand and on the other hand, it was locking up SharpDevelop so the user had to wait for Find all to complete.

During the redesign of the search engine, we also focused on making it thread-safe. This requires to create a list of files to search through before doing the actual search. This causes some neglectable delay and overhead. The only case in which this would turn out really bad, is a recursive directory search starting from C:\ using *.* as file mask. But this is certainly not a common scenario when working with an IDE.

The good news is, you can continue working while waiting for the search to complete. Please keep in mind that all changes you make to documents while Find all is active are not guaranteed to be recognized, depending on when the background thread processes the file.

Another good news for all those of you with multi-core CPUs: SharpDevelop 4.2 will process multiple files in parallel and display all results in real-time. So you can work with the first results while the remaining files are processed. This is implemented using the IObservable<T> and IObserver<T> interfaces.

These are the key features of the new search engine. I hope you like it. If you have any suggestions, please leave a comment.

SharpDevelop 4.2: Reimplemented "Create properties"

siegi44 — Sun, 30 Oct 2011 16:47:00 GMT

One of the features still missing after "Alt+Ins" was removed, "Create properties" was reimplemented and added to the recent builds of SharpDevelop 4.2 (master branch).

It can be reached by selecting "Create properties" from the refactoring main menu, or by typing propall and pressing tab in the editor (C# only):

It will insert a small dialog at the caret position:

You can select all the fields you want to create properties for. As you can see there are some options, you can choose whether to generate the setter of a property. Additionally you can choose to implement INotifyPropertyChanged. It will implement the interface, if it has not been implemented yet, and will add an OnPropertyChanged method. A call to OnPropertyChanged will be inserted into each property setter:

I hope you like the return of this feature. Leave comments if you have any suggestions or problems!

"View in browser" context menu

Eusebiu — Sun, 09 Oct 2011 19:29:00 GMT

Hey,

Some time ago I've presented the support of IIS (local and Express) in SharpDevelop where one can set the web server options (Project Properties/Debug tab/Web server)

Now, I'd like to present you a new context menu item called "View in browser". When creating a web project (ASP.NET Web Forms / MVC) or a web service (ASP.NET WS, WCF - SOAP or REST), SharpDevelop will generate some basic files to get you started. Depending on the type of project, you will have some aspx, asmx, svc etc. files. The context menu for these types of files (aspx,asmx,html,htm,svc), will contain the new menu option:

When executing this option, SharpDevelop will verify if the current project is a web project/service, create the virtual directory/application and start it in a browser (default port is set to 8080).

If you have IIS Express installed, SharpDevelop will execute it for you also. As expected, debugging will work too.

If you want to edit/remove the registered websites in IISExpress, you will have to go to ''%userprofile%\documents\IISExpress\config\applicationhost.config" and edit/remove the "configuration/system.applicationHost/sites/site" element.

TODO list:

port collision
ASP.NET MVC

My test environment:

Windows 7 Ultimate 32bit
SharpDevelop 4.2 (master branch)
IIS Express and IIS 7.5 (from Windows 7).

If you switch between IIS Express and local IIS, don't forget to restart your computer, register ASP.NET (aspnet_regiis.exe /i) and restart IIS (iisreset).

Happy coding!

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

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.

All that is left now is to save the changes made to the Settings.ttimport 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.

Tip No. 1: Ctrl+W

siegi44 — Thu, 29 Sep 2011 18:00:00 GMT

Even as core developers of SharpDevelop we sometimes stumble across features in our own product, we did not know about before. Hence we decided to create a SharpDevelop Tips&Tricks section on our blog(s), to let you know all the cool features you can use to speed up your work. Today I want to start with something simple.

Problem

It often happens that you want to select of the code, whole methods or statements, or even (parts of) expressions. Of course you can do that by using the mouse or use Shift + the arrow keys, but it feels very clumsy and is inaccurate and error-prone.

Solution

To avoid this a small hidden feature comes in very handy: Control + W. It is simple to use: Place the caret (the "keyboard cursor") somewhere inside of a piece of code you want to select.

Then hit Ctrl+W and the innermost expression, statement or member will be selected. Hit Ctrl+W again to extend the selection. You can repeat this as many times as you want; you will end up having selected the whole file.

Remarks

Imagine how this feature can be used in conjunction with other features like surround with (Ctrl+J) or extract method. In the future there could be a Introduce variable/constant refactoring, which extracts an expression into a variable/constant initializer.

Quick note: currently it is not possible to undo or shrink the selection. Would you like to have something like that too? If so, which keyboard shortcut would you choose to make it easy to use?

Update: Shrink selection was added as Ctrl+Shift+W in SharpDevelop 4.2 alpha builds. Thank you for your feedback.

Version Information

This feature is available in SharpDevelop 4.0 and newer.

Code Completion Trimming in SharpDevelop 4.2

ChristophWille — Wed, 28 Sep 2011 05:18:00 GMT

As mentioned in the release notes for SharpDevelop 4.1, it doesn't display the correct code completion information if you have the .NET 4.5 preview bits on your machine too. Starting with revision 8111, SharpDevelop 4.2 now correctly trims the code completion to the target framework (available on the build server). Therefore, if you plan to work with 4.0 / 4.5 today, we recommend to switch to SharpDevelop 4.2.