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

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.

Continue Reading

Reactive Azure Service Bus messaging with Azure Event Grid

Earlier this month, I wrote an article for my friends over at DotNetCurry. They run a free digital magazine called DNC Magazine, that comes out every 2 months, is free to download and to which I occasionally contribute.

The article is entitled "Reactive Azure Service Bus messaging with Azure Event Grid". In the article, I explore Service Bus integration with Azure Event Grid, and the advantages and scenarios it brings to the table. This is a relatively new feature (launched in the fall of 2018) and I already use it extensively in some of my projects, so I wanted to create sort of a general purpose guide on getting started with this, including having a look at some of the potential use cases.

You can subscribe to the magazine (for free) or download single issues (also for free) here – the article can be found in the latest issue May-June 2019.

And of course big thanks to Suprotim and the entire DNC team for their hard work and bringing this magazine to .NET devs for free for 7 years now.

Elegant way of producing HTTP responses in ASP.NET Core outside of MVC controllers

ASP.NET Core 2.1 introduced support for a little (or, should I say, not at all) documented feature called IActionResultExecutor<T>. It allows us to use some of the action results -those that we are used to from MVC controllers – outside of the controller context, so for example from a middleware component.

Kristian has a great blog post about result executors, that I recommend you check out. From my side, I wanted to show you today a set of extension methods that were recently introduced into WebApiContrib.Core that make working with IActionResultExecutor<T> and in general authoring HTTP endpoints outside of controllers even easier.

Continue Reading

Be careful when manually handling JSON requests in ASP.NET Core

The other day I was reviewing some code in an ASP.NET Core app. It was an HTTP endpoint, written as a simple, lightweight middleware component (so no MVC), that was handling incoming JSON requests.

The endpoint was intended to act as an ingestion point for larger amounts of data, so by definition it was supposed to perform well. I immediately noticed a few things that raised my eyebrow, that I wanted to share with you today.

Continue Reading

Collectible assemblies in .NET Core 3.0

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.

Continue Reading

Using Roslyn C# Completion Service programmatically

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.

Continue Reading

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

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.

Continue Reading

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

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.

Continue Reading