Roslyn on Strathweb. A free flowing tech monologue.

Hello OmniSharp on .NET 6.0!

Mon, 31 Jan 2022 18:31:34 +0000

On December 15, 2021 we released version 1.38.0 of OmniSharp which, for the first time, included .NET 6.0 builds of the OmniSharp server. The related feature branch was maintained for over a year, and previously contained a .NET 5-based variant of OmniSharp, though that one was never released.

This is a big milestone in the OmniSharp project as the .NET 6.0 build is much faster and a lot more stable, and is the first step towards retiring the .NET Framework/Mono builds of OmniSharp.

C# semantic classification with Roslyn

Mon, 15 Jun 2020 16:21:40 +0000

A while ago, I blogged about using Roslyn’s completion service. In today’s post, I wanted to continue looking at some of the excellent compiler features that can be utilized to build IDE-like features in your projects. This time, we will look at how to do semantic classification of the code using Roslyn.

Hidden features of OmniSharp and C# extension for VS Code

Thu, 13 Feb 2020 19:41:07 +0000

OmniSharp powers intellisense and language services in C# plugins and extensions for numerous editors, including VS Code. When we build things into OmniSharp, we typically try to keep things lightweight (of course if the term “lightweight” applies to anything related to MSBuild…) and non-invasive. This means that many features/tweaks are actually opt-in by default, and wouldn’t normally show up on their own.

In this post I wanted to show you a few of such less known features.

Enforcing C# EditorConfig formatting conventions at build time

Sun, 26 Jan 2020 07:40:29 +0000

EditorConfig is an excellent way to enforce stylistic rules on your C# projects. However, the rules and their corresponding IDExxxx diagnostics are only enforced in the editor, such as Visual Studio or VS Code with OmniSharp, but not at build time.

While there are various categories of EditorConfig conventions that you can use, in this post, I will show you how to enforce the formatting conventions (IDE0055) at build time.

Building a C# Interactive shell in a browser with Blazor (WebAssembly) and Roslyn

Fri, 07 Jun 2019 14:52:38 +0000

In this post I wanted to show you how to write and embed a C# interactive shell (a REPL - read-evaluate-print-loop) in a browser, on top of WebAssembly.

The REPL will give you fully fledged C# interactive development playground, while still being completely sandboxed in the browser environment. I originally wrote this example for my session at Dotnet Cologne on May 10 this year.

More after the jump.

Roslyn analyzers and code fixes in OmniSharp and VS Code

Tue, 30 Apr 2019 20:10:17 +0000

Recently we merged a big (albeit still experimental) feature into OmniSharp - the support for Roslyn analyzers.

I wanted to take a few moments today to discuss this feature with you, share some background info, show you how to get it enabled and share some plans for the next steps.

Collectible assemblies in .NET Core 3.0

Wed, 09 Jan 2019 22:16:39 +0000

Since the beginning of .NET Core, the one feature that I have been most anxiously waiting for, has been support for collectible assemblies. It took a while (a while!), but finally, in .NET Core 3.0 (at the time of writing 3.0.0-preview-27122-01 from 2018-12-04), it’s here.

It’s going to be a killer functionality, that will support some excellent use cases in .NET Core - especially around application plugins, extensibility and dynamic assembly generation.

Let’s have a quick look at how we can load and unload assemblies in .NET Core.

Using Roslyn C# Completion Service programmatically

Wed, 05 Dec 2018 20:23:48 +0000

I am involved in a few open source projects built around the Roslyn compiler. One of those projects is OmniSharp, which brings intellisense and C# language services to a number of editors out there, allowing them to provide for their users a rich C# code authoring experience.

Which actually brings me to the point of today’s post. Roslyn is a compiler-as-a-service that you can embed in your own app, and when you do that, you could reach into its C# language services (more specifically, CompletionService) and easily build your own C# intellisense engine.

However, this is not really documented, so I wanted to use this post to show you how you can get started with that.

dotnet-script 0.27.0 is out – with a ton of features!

Thu, 08 Nov 2018 20:59:15 +0000

It’s that time again, the new dotnet-script release, version 0.27.0 is out. It’s been 2+ months since the last release so this one is fully packed with great features.

You can get it by running dotnet tool install dotnet-script -g (if you don’t have it installed yet) or dotnet tool update dotnet-script -g (if you just need an update).

Let me quickly walk you through some of them.

No InternalsVisibleTo, no problem – bypassing C# visibility rules with Roslyn

Mon, 08 Oct 2018 19:26:35 +0000

Both the C# compiler and the CLR/CoreCLR runtimes contain a bunch of rules that are in place to save us from ourselves (and to allow us to write code without needing to fully understand ECMA-334 C# Language Specification). That said, there are times where we want to do some things that are normally not allowed, and a good example of that is reaching into reflection to execute some private or internal code.

Today I wanted to show you how to do something quite cool - how to bypass the type/member visibility rules using the Roslyn compiler. In other words, how to get access to internal and private members without needing to use reflection or something like InternalsVisibleToAttribute.

dotnet-script 0.26 is out – with a boatload of new features

Thu, 23 Aug 2018 09:30:09 +0000

After a short holiday break, the dotnet-script release train is back at full speed! This week we released 0.26 which can be installed from NuGet - as the .NET CLI global tool - or from Chocolatey.

Let me do a quick roundup of what’s new.

dotnet-script now available as .NET Core SDK 2.1 global tool

Wed, 11 Apr 2018 08:14:09 +0000

Yesterday we released version 0.20.0 of dotnet-script - a command line tool that allows you to run C# scripts (.csx) in the .NET Core runtime.

The highlight of this release is that it is now avaialble as .NET Core SDK 2.1 global tool, which provides an excellent acquisition/installation story directly from nuget.

Generic and dynamically generated controllers in ASP.NET Core MVC

Fri, 06 Apr 2018 13:42:56 +0000

One of those recurring themes that seem to come back fairly regularly among .NET web developers, is the usage of generic controllers to define endpoints in their Web APIs. I have witnessed these discussions as part of ASP.NET MVC, then ASP.NET Web API and most recently in ASP.NET Core MVC.

While I don’t necessarily see a huge need or benefit for generic controllers, I can imagine that - especially in enterprise context - there are scenarios where exposing similarly structured, “cookie-cutter” CRUD endpoints quickly and seamlessly, could possibly have some business value.

Let’s have a look at generic controllers then, and how we could also dynamically feed types into them.

Easy way to create a C# lambda expression from a string (with Roslyn)

Mon, 29 Jan 2018 13:51:02 +0000

I’ve worked on quite a lot of projects over the years, with many different teams, and one of the questions that keeps coming back to me over and over with a high degree of regularity is how to load a C# lambda from a string - for example from a configuration file.

This is not surprising, because being able to do that can give you a tremendous amount of flexibility in your code, as it would (for the lack of better word) unlock the possibility to alter business logic from the configuration level, without having to recompile and redeploy your application.

Historically, this has been possible but also quite a painful task. Today I wanted to show you a remarkably simple solution to this problem - with the help of the Roslyn compiler Nuget packages.

dotnet-script 0.11 out – with inline Nuget support

Wed, 09 Aug 2017 11:12:44 +0000

Yesterday I released, thanks to the great help of Bernhard - version 0.11 of dotnet-script, the C# script runner for .NET Core.

It is the biggest release yet - with the highlight feature being the ability to use inline Nuget packages.

Here is the overview of what’s in there.

Introducing C# script runner for .NET Core and .NET CLI

Tue, 18 Oct 2016 15:48:54 +0000

In this post I wanted to share a little project I’ve been working on recently - a .NET CLI and .NET Core based script runner for C# (CSX scripts).

The idea was super simple - I just wanted to be able to author C# scripts using .NET Core, leverage project.json to define the script dependencies and execute scripts cross platfom using .NET CLI - via a dotnet script command.

The project is located here on Github. You can head over and have a look at readme to get started - but, briefly, the key features are listed here.

Building Analyzers & Refactoring Tools with Roslyn (from NDC Sydney)

Tue, 06 Sep 2016 06:59:19 +0000

Last month I was at the excellent NDC Sydney conference, where I did a talk about building code analyzers and refactoring tools with Roslyn. Below you can find the the video, code and slides from the session. Thanks to everyone who attended - I had great fun, and I was even mugged by a kangaroo afterwards. Video 🔗You can watch the talk on Vimeo. And if you are wondering, yes, my t-shirt says “#ENDREGIONS”.

Implementing custom #load behavior in Roslyn scripting

Fri, 17 Jun 2016 08:10:01 +0000

#load directives in C# scripts are intended to allow you to reference a C# script source file from another C# script. As an author of a host application, in which the Roslyn scripting would be embedded, it’s up to you to define how #load should behave.

Let’s have a look at the process of doing that.

Building strongly typed application configuration utility with Roslyn

Mon, 25 Apr 2016 20:02:55 +0000

In this post we will have a look at how, with just several lines of Roslyn code, you can build an extremely cool and powerful utility - a library allowing you to provide configuration for your application as a strongly typed C# script file.

This post was inspired by the ConfigR library, which provides this type of functionality through scriptcs (I also blogged about ConfigR before).

We will, however, deal with marshalling configuration data between the C# configuration and the parent app differently than ConfigR does.

Enabling C# 7 Features in Visual Studio “15” Preview

Thu, 31 Mar 2016 02:16:25 +0000

Yesterday, at Build, Microsoft released the first public preview of Visual Studio “15” - the next iteration of Visual Studio.

One of the main reasons why you’d want to try it out already is to be able to use some of the heralded C# 7 features - such as binary literals, local functions or pattern matching (to name just a few).

It’s been possible to test out these features in a slightly hacky way before (see Josh’s post) - by building Roslyn from source and deploying it into VS using the CompilerExtension VSIX, but of course it’s much easier and convenient to just use C# 7 features directly in VS “15” now.

In this post I’m gonna show you how to enable the experimental C# 7 features - because they are by default not available.

Roslyn scripting on CoreCLR (.NET CLI and DNX) and in memory assemblies

Thu, 10 Mar 2016 17:46:22 +0000

For a while now, the Roslyn C# scripting APIs (Microsoft.CodeAnalysis.CSharp.Scripting) have been portable, and supported cross platform usage.

However, I recently ran into a few difficulties regarding using the Roslyn Scripting APIs in .NET CLI (which is replacing DNX) context. The solution was to use a lower level unmanaged CoreCLR API - and since they it’s not that well documented, I thought it would be beneficial to document it in a blog post.

Adding C# Scripting to Your Development Arsenal

Tue, 01 Dec 2015 17:44:51 +0000

As part of my efforts to popularize C# scripting in the .NET community (which, hopefully, you have noticed by following this blog, my Twitter or my Github) and in celebration of the first stable release of Roslyn scripting packages on Nuget yesterday, I published a guest post at Canadian Developer Connection blog - Adding C# Scripting to Your Development Arsenal. You can read the post here, and hopefully you find it useful.

Using Roslyn and unit tests to enforce coding guidelines and more

Fri, 25 Sep 2015 11:48:37 +0000

Last year, during a few of my Roslyn talks, I was presenting a cool idea of leveraging Roslyn in unit tests to enforce a certain style in code, and in general inspect the consistency of the code in various ways.

It’s a really powerful concept, and something I wanted to blog about, but of course forgot - until I was reminded of that yesterday on Twitter.

Let’s have a look.

Hacking DNX to run C# scripts

Tue, 01 Sep 2015 13:29:49 +0000

Because of my considerable community involvement in promoting C# scripting (i.e. here or here), I thought the other day, why not attempt to run C# scripts using DNX?

While out of the box, DNX only compiles proper, traditional C# only, thanks to the compilation hooks it exposes, it is possible to intercept the compilation object prior to it being actually emitted, which allows you to do just about anything - including run C# scripts.

Let’s explore more.

Razor views pre-compilation with ASP.NET 5 and MVC 6

Fri, 12 Dec 2014 10:36:22 +0000

In previous versions of MVC framework, running on top of the “classic” ASP.NET runtime, it was quite common for developers to switch view compilation on, so that the views get compiled upfront, allowing you to see any errors at compile time, rather than at runtime.

This was done by a simply adding true to your csproj file.

Given that everything changes in the new ASP.NET 5 world, how would you do it now? Let’s explore.

Building refactoring tools (diagnostics and code fixes) with Roslyn

Mon, 13 Oct 2014 10:01:16 +0000

Some time ago I blogged about building next generation Visual Studio support tools with Roslyn. This was when Roslyn was still on its 2012 CTP. A lot has changed since then, with Roslyn going open source, and new iterations of the CTPs getting released.

Most of the APIs used in the original have changed, so I thought it would be a good idea to do a new post, and rebuilt the sample used in the old post from scratch, using the latest Roslyn CTP.

Leveraging Roslyn to author ASP.NET Web API without recompiling

Sat, 16 Mar 2013 17:10:31 +0000

Some time ago I posted a mini-series of posts about using Roslyn to script Web API, and that has gotten some great response. In that original post, I mentioned & used, without going into too much details, a very useful “compiler as a service” feature Roslyn offers.

Recently, Glenn Block started a very exciting project called scriptcs (which now Justin Rusbtach and I happen to be a part of too) to provide a seamless/node.js-esque scripting experience for C# and in that project we indeed leverage on Roslyn heavily - to do some behind the scenes tricks to hide the compilation aspect from the user, so that it really resembles pure script execution.

Building Web API Visual Studio support tools with Roslyn

Sun, 03 Feb 2013 18:57:59 +0000

In my humble opinion, Microsoft Roslyn is one of the most exciting things on the .NET stack. One of the many (MANY) things you can do easily with Roslyn, is write your own development-time code analysis tools.

We have talked about Roslyn scripting capabilities on this blog before (twice actually). Let’s look at code analysis today and see how we could built tools that could help Web API developers build nice clean HTTP services.

More after the jump.

Scripting Web API self host with Roslyn CTP – Part 2

Wed, 03 Oct 2012 00:58:30 +0000

This is part two of the series - if you haven’t read part one check it out before proceeding.

Last time we did some cool stuff with using C# script files to instantiate a working Web API server - by executing them with RCSI and C# interactive window.

In part two, let’s use Roslyn to build our own scripting application (custom C# console), which will act as an input window for the user; user will be able type C# code that’s supposed to be executed and run it (something that services such as Compilify offer). We will expose Web API assemblies in that context, allowing the user to type in the code required for the Web API server to be run.

More after the jump.

Scripting Web API self host with Roslyn CTP – Part 1

Thu, 27 Sep 2012 10:46:06 +0000

If you follow me on Twitter you probably already know that recently I’ve been playing around with Roslyn. If you don’t know about Roslyn, in very short, you can think of it as “compiler as a service”.

There is a whole plethora of stuff that Roslyn allows us to do, one of the coolest being the scripting API - enabling us to use C# as a script language (think i.e. Perl or Python). So I had this idea, why not script a fully functional web server through Web API self host?

More after the jump.