Latest Blog Posts

Angular 2 CLI interview with .NET Rocks

Posted on Tuesday, 23 Aug 2016

Recently I once again (for those that remember my last talk with Carl and Richard was about shortcuts and productivity games in Visual Studio) had the pleasure of talking with Carl Franklin and Richard Campbell on the .NET Rocks Show about the Angular 2 command line interface. With all that's been happening with Angular 2 it was great to have the opportunity to spend a bit of time talking about the tooling around the framework and some of the features the Angular 2 CLI affords us.

So if you've been looking at Angular 2 recently then be sure to check out show 1339 and leave any feedback you may have.

Integration testing your ASP.NET Core middleware using TestServer

Posted on Sunday, 31 Jul 2016

Lately I've been working on a piece of middleware that simplifies temporarily or permanently redirecting a URL from one path to another, whilst easily expressing the permanency of the redirect by sending the appropriate 301 or 302 HTTP Status Code to the browser.

If you've ever re-written a website and had to ensure old, expired URLs didn't result in 404 errors and lost traffic then you'll know what a pain this can be when dealing with a large number of expired URLs. Thankfully using .NET Core's new middleware approach, this task becomes far easier - so much so that I've wrapped it into a library I intend to publish to NuGet:

public void Configure(IApplicationBuilder app, IHostingEnvironment env)
    app.UseRequestRedirect(r => r.ForPath("/32/old-path.html").RedirectTo("/32/new-path").Permanently());
    app.UseRequestRedirect(r => r.ForPath("/33/old-path.html").RedirectTo("/33/new-path").Temporarily());
    app.UseRequestRedirect(r => r.ForPath("/34/old-path.html").RedirectTo(DeferredQueryDbForPath).Temporarily());

private string DeferredQueryDbForPath(string oldPath){
    /* Query database for new path only if old path is hit */
    return newPath;

Whilst working on this middleware I was keen to add some integration tests for a more complete range of tests. After a bit of digging I noticed that doing so was actually really simple, thanks to the TestServer class available as part of the Microsoft.AspNetCore.TestHost package.

What is Test Server?

TestServer is a lightweight and configurable host server, designed solely for testing purposes. Its ability to create and serve test requests without the need for a real web host is it's true value, making it perfect for testing middleware libraries (amongst other things!) that take a request, act upon it and eventually return a response. In the case of the aforementioned middleware, our response we'll be testing will be a status code informing the browser that the page has moved along with the destination the page is located at.

TestServer Usage

As mentioned above, you'll find the TestServer class within the Microsoft.AspNetCore.TestHost package, so first of all you'll need to add it to your test project either by using the following NuGet command:

Install-Package Microsoft.AspNetCore.TestHost

Or by updating your project.json file directly:

"dependencies": {
    "Microsoft.AspNetCore.TestHost": "1.0.0",

Once the NuGet package has downloaded we're ready start creating our tests.

After creating our test class the first thing we need to do is configure an instance of WebHostBuilder, ensuring we add our configured middleware to the pipeline. Once configured we create our instance of TestServer which then bootstraps our test server based on the supplied WebHostBuilder configurations.

public async void Should_Redirect_Permanently()
    // Arrange
    var builder = new WebHostBuilder()
        .Configure(app => {
            app.UseRequestRedirect(r => r.ForPath("/old/").RedirectTo("/new/").Permanently());

    var server = new TestServer(builder);

    // Act

Next we need to manually create a new HTTP Request, passing the parameters required to exercise our middleware. In this instance, using the redirect middleware, all I need to do is create a new GET request to the path outlined in my arrange code snippet above. Once created we simply pass our newly created HttpRequestMessage to our configured instance of TestServer.

// Act
var requestMessage = new HttpRequestMessage(new HttpMethod("GET"), "/old/");
var responseMessage = await server.CreateClient().SendAsync(requestMessage);

// Assert

Now all that's left is to assert our test using the response we received from our TestServer.SendAsync() method call. In the example below I'm using assertion library Shouldly to assert that the correct status code is emitted and the correct path (/new/) is returned in the header.

// Assert

The complete test will look like this:

public class IntegrationTests
    public async void Should_Redirect_Permanently()
        // Arrange
        var builder = new WebHostBuilder()
            .Configure(app => {
                app.UseRequestRedirect(r => r.ForPath("/old/").RedirectTo("/new/").Permanently());

        var server = new TestServer(builder);

        // Act
        var requestMessage = new HttpRequestMessage(new HttpMethod("GET"), "/old/");
        var responseMessage = await server.CreateClient().SendAsync(requestMessage);

        // Assert


In this post we looked at how simple it is to test our middleware using the TestServer instance. Whilst the above example is quite trivial, hopefully it provides you with enough of an understanding as to how you can start writing integration or functional tests for your middleware. 

Proxying HTTP requests in ASP.NET Core using Kestrel

Posted on Saturday, 02 Jul 2016

A bit of a short post this week but hopefully one that will save some a bit of googling!

Recently I've been doing a lot of ASP.NET Core MVC and in one project I've been working on I have an admin login area. My first instinct was to create the login section as an Area within the main application project.

Creating a login area in the same application would work, but other than sharing an /admin/ path it really was a completely separate application. It has different concerns, a completely different UI (in this instance it's an Angular 2 application talking to a back-end API). For these reasons, creating the admin section as an MVC Area just felt wrong - so I began to look at what Kestrel could offer in terms of proxying requests to another application. This way I could keep my user facing website as one project and the administration area as another, allowing them to grow independent of one another.

Whilst proxying requests is possible in IIS, I was keen to use Kestrel as I'd like the option of hosting the application across various platforms, so I was keen to see what Kestrel had to offer.

Enter the ASP.NET Core Proxy Middleware!

After a little digging it came to no surprise that there was some middleware that made proxying requests a breeze. The middleware approach to ASP.NET Core MVC lends itself to such a task and setup was so simple that I felt it merited a blog post.

After installing the Microsoft.AspNetCore.Proxy NuGet package via the "Install-Package Microsoft.AspNetCore.Proxy" command, all I had to do was hook the proxy middleware up to my pipeline using the MapWhen method within my application's Startup class:

// Startup.cs
public void Configure(IApplicationBuilder app, IHostingEnvironment env)

    app.MapWhen(IsAdminPath, builder => builder.RunProxy(new ProxyOptions
        Scheme = "http",
        Host = "localhost",
        Port = "8081"



private static bool IsAdminPath(HttpContext httpContext)
    return httpContext.Request.Path.Value.StartsWith(@"/admin/", StringComparison.OrdinalIgnoreCase);

As you can see, all I'm doing is passing a method that checks the path begins with /admin/.

Once setup, all you need to do is set your second application (in this instance it's my admin application) to the configured port. You can do this within the Program class via the UseUrls extension method:

// Program.cs
public class Program
    public static void Main(string[] args)
        var host = new WebHostBuilder()


Now, if you start up your application and navigate to /admin/ (or whatever path you've specified) the request should be proxied to your secondary application!

Happy coding!

Fira Mono - An exceptional programming font, and now with (optional) ligatures

Posted on Friday, 17 Jun 2016

I've always been a fan of customising my IDE or text editor of choice, and one such customisation (and often the first thing I do after installing an editor) is setup my font of choice which has long been Google's Droid Sans font.

Recently however, I was introduced to a rather interesting but delightful looking typeface called Fira Mono that's been designed by Mozilla specifically for their Firefox OS.

At first I didn't think much of the font, but the more I saw him using it the more it grew on me. Eventually I decided to download it and give it a try. And having been using it now for a number of days I've no intention of switching back to Droid Sans.

Fira Mono in Visual Studio Code:

Fira Mono in Visual Studio:

Would you like ligatures with that?

If you're a developer that likes your programming fonts with ligatures then there is a version available that includes ligatures called Fira Code.

Downloading Fira Mono

The font itself is open-source so if you're interesting it giving it a try then download it via Font Squirrel here, then once extracted to your fonts directory load up Visual Studio (or restart so Visual Studio can load the font) and to go Tools > Options > Environment > Fonts and Colors and select it from the Font dropdown.

Having experimented with various font sizes (In Visual Studio only), font size 9 appears to work really well with Fira Mono.

As mentioned above, if you'd like the ligatures then head over here to download them.

Select by camel case - the greatest ReSharper setting you never knew

Posted on Monday, 06 Jun 2016

One of ReSharper's most powerful features is the sheer number of additional shortcuts it adds to Visual Studio, and out of the arsenal of shortcuts available my most used shortcuts have to be the ones that enable me to modify and manipulate code in as fewer wasted keystrokes as possible. Ultimately, this boils down to the following two shortcuts: 

1: Expand/Shrink Selection (CTRL + ALT + Right to expand, CTRL + ALT + Left to shrink)
This shortcut enables you to expand a selection by scope, meaning pressing CTRL + ALT + Right to expand your selection will start by highlighting the code your cursor is over, then the line then function scope, class and namespace. Check out the following gif to see an example. Be sure to watch the selected area!

Expand/Shrink Selection:

2: Increase selection by word (CTRL + Shift + Right to expand, CTRL + Shift + Left to shrink)

A few of you will probably notice that this shortcut isn't really a ReSharper shortcut - and you'd be right. But none the less, once harnessed, increase/decrease selection by word is extremely powerful when it comes to renaming variables, methods, classes etc. and will serve you well if mastered.

Where am I going with this?

Whilst the aforementioned shortcuts are excellent tools to add to your shortcut toolbox, one thing I always wished they would do was the expand selection by camel case, allowing me to highlight words with more precision and save me the additional key presses when it comes to highlighting the latter part of a variable in order to rename it. For instance, instead of highlighting the whole word in one go (say, the word ProductService, for example), it would first highlight the word Product, followed by Service after the second key press.

Having wanted to do this for sometime now, I was pleasantly surprised when I stumbled across a ReSharper setting to enable just this. This setting can be enabled by going to ReSharper > Options > Environment > Editor > Editor Behaviour and selecting the Use CamelHumps checkbox.

The problem I've found when enabling this is the setting overwrites the default behaviour of CTRL  + ALT + Left / Right. Whilst this may be fine for some, I would rather the ability to choose when to highlight by word and when to highlight by camel case. Luckily you can do just this via the ReSharper_HumpPrev and ReSharper_HumpNext commands that are available for binding in Visual Studio.

To do this do the following:

  1. Open the Visual Studio Options window from Tools > Options
  2. Expand Environment and scroll down to Keyboard
  3. Map the two commands ReSharper_HumpNext and ReSharper_HumpPrev to the key mappings you wish (E.g. ALT+Right Arrow and ALT+Left Arrow) by selecting the command from the list and entering the key mapping in the Press shortcut keys text box, then click Assign.

Now, with UseCamelHumps enabled and my shortcut keys customised, I can choose between the default selection by string, or extend selection by camel case - giving me even more code-editing precision!

Social authentication via Google in ASP.NET Core MVC

Posted on Sunday, 29 May 2016

Lately I've been re-developing my blog and moving it to .NET Core MVC. As I've been doing this I decided to change authentication methods to take advantage of Google's OAuth API as I didn't want the hastle of managing username and passwords.

Initially, I started looking at the SimpleAuthentication library - but quickly realised ASP.NET Core already provided support for third party authentication providers via the `Microsoft.AspNet.Authentication` library.

Having implemented cookie based authentication I thought I'd take a moment to demonstrate how easy it is with ASP.NET's new middleware functionality.

Let's get started.

Sign up for Google Auth Service

Before we start, we're going to need to register our application with the Google Developer's Console and create a Client Id and Client Secret (which we'll use later on in this demonstration).

  1. To do this go to Google's developer console and click "Create Project". Enter your project name (in this instance it's called BlogAuth) then click Create.
  2. Next we need to enable authentication with Google's social API (Google+). Within the Overview page click the Google+ API link located under Social API and click Enable once the Google+ page has loaded.
  3. At this point you should see a message informing you that we need to create our credentials. To do this click the Credentials link on the left hand side, or the Go to Credentials button.
  4. Go across to the OAuth Consent Screen and enter a name of the application you're setting up. This name is visible to the user when authenticating. Once done, click Save.
  5. At this point we need to create our ClientId and ClientSecret, so go across to the Credentials tab and click Create Credentials and select OAuth client ID from the dropdown then select Web Application.
  6. Now we need to enter our app details. Enter an app name (used for recognising the app within Google Developer Console) and enter your domain into the Authorized JavaScript origins. If you're developing locally then enter your localhost address into this field including port number.
  7. Next enter the return path into the Authorized redirect URIs field. This is a callback path that Google will use to set the authorisation cookie. In this instance we'll want to enter http://<domain>:<port>/signin-google (where domain and port are the values you entered in step 6).
  8. Once done click Create.
  9. You should now be greeted with a screen displaying your Client ID and Client Secret. Take a note of these as we'll need them shortly.

Once you've stored your Client ID and Secret somewhere you're safe to close the Google Developer Console window.

Authentication middleware setup

With our Client ID and Client Secret in hand, our next step is to set up authentication within our application. Before we start, we first need to to import the Microsoft.AspNet.Authentication package (Microsoft.AspNetCore.Authorization if you're using RC2 or later) into our solution via NuGet using the following command:

// RC1
install Microsoft.AspNet.Authentication

// RC2
install Microsoft.AspNetCore.Authorization

Once installed it's time to hook it up to ASP.NET Core's pipeline within your solution's `Startup.cs` file.

First we need to register our authentication scheme with ASP.NET. within the `ConfigureServices` method:

public IServiceProvider ConfigureServices(IServiceCollection services)
    // Add authentication middleware and inform .NET Core MVC what scheme we'll be using
    services.AddAuthentication(options => options.SignInScheme = CookieAuthenticationDefaults.AuthenticationScheme);


public void Configure(IApplicationBuilder app, IHostingEnvironment env)

    // Adds a cookie-based authentication middleware to application
    app.UseCookieAuthentication(new CookieAuthenticationOptions
        LoginPath = "/account/login",
        AuthenticationScheme = "Cookies",
        AutomaticAuthenticate = true,
        AutomaticChallenge = true

    // Plugin Google Authentication configuration options
    app.UseGoogleAuthentication(new GoogleOptions
        ClientId = "your_client_id",
        ClientSecret = "your_client_secret",
        Scope = { "email", "openid" }


In terms of configuring our ASP.NET Core MVC application to use Google for authentication - we're done! (yes, it's that easy, thanks to .NET Core MVC's middleware approach). 

All that's left to do now is to plumb in our UI and controllers.

Setting up our controller

First, let's go ahead and create the controller that we'll use to authenticate our users. We'll call this controller AccountController:

public class AccountController : Controller
    public IActionResult Login()
        return View();
    public IActionResult External(string provider)
        var authProperties = new AuthenticationProperties
            // Specify where to return the user after successful authentication with Google
            RedirectUri = "/account/secure"

        return new ChallengeResult(provider, authProperties);
    public IActionResult Secure()
        // Yay, we're secured! Any unauthenticated access to this action will be redirected to the login screen
        return View();

    public async Task<IActionResult> LogOut()
        await HttpContext.Authentication.SignOutAsync("Cookies");

        return RedirectToAction("Index", "Homepage");

Now we've created our AccountController that we'll use to authenticate users, we also need to create our views for the Login and Secure controller actions. Please be aware that these are rather basic and are simply as a means to demonstrate the process of logging in via Google authentication.

// Login.cshtml

<a href="/account/external?provider=Google">Sign in with Google</a>
// Secure.cshtml

This page can only be accessed by authenticated users.

Now, if we fire up our application and head to the /login/ page and click Sign in with Google we should be taken to the Google account authentication screen. Once we click Continue  we should be automatically redirected back to our /secure/ page as expected!

ASP.NET Core tag helpers - with great power comes great responsibility

Posted on Monday, 09 May 2016

I recently watched a Build 2016 talk by N. Taylor Mullen where Taylor demonstrated the power of ASP.NET Core MVC's new tag helpers. Whilst I've been keeping up to date with the changes and improvements being made to Razor, there were a couple times my jaw dropped as Taylor talked about points that were completely new to me. These points really highlighted how powerful the Razor engine is becoming - but as Ben Parker said in Spiderman, "With great power comes great responsibility".

This post serves as a review of how powerful the Razor tag engine is, but also a warning of potential pitfalls you may encounter as your codebase grows.

The power of ASP.NET Core MVC's tag engine

For those of you that haven't been keeping up to date with the changes in ASP.NET Core MVC, one of the new features included within Razor are Tag Helpers. At their essence, tag helpers allow you to replace Razor's jarring syntax with a more natural HTML-like syntax. If we take moment to compare a new tag helper to the equivalent Razor function you'll see the difference (remember, you can still use the HTML helpers, Tag helpers do not replace them and will happily work side by side in the same view).

// Before - HTML Helpers
@Html.ActionLink("Click me", "MyController", "MyAction", { @class="my-css-classname", data_my_attr="my-attribute"}) 

// After - Tag Helpers
<a asp-controller="MyController" asp-action="MyAction" class="my-css-classname" my-attr="my-attribute">Click me</a>

Whilst both of these will output the same HTML, it's clear to see how much more natural the tag helper syntax looks and feels. Infact, with data prefix being optional when using data attributes in HTML, you could mistake the tag helper for HTML (more on this later).

Building your own tag helpers

It goes without saying that we're able to create our own tag helpers, and this is where they get extremely powerful. Let's start by creating a tag helper from start to finish. The follow example is a trivial example, but if you stick stick with me hopefully you'll see why I chose this example as we near the end. So let's begin by creating a tag helper that automatically adds a link-juice preserving rel="nofollow" attribute to links outbound links:

public class NoFollowTagHelper : TagHelper
    // Public properties becomes available on our custom tag as an attribute.
    public string Href { get; set; }

    public override void Process(TagHelperContext context, TagHelperOutput output)
        output.TagName = "a"; // Specify our tag output name
        output.TagMode = TagMode.StartTagAndEndTag; // The type of tag we wish to create

        output.Attributes["href"] = Href;
        if (!output.Attributes["href"].Value.ToString().Contains(""))
            output.Attributes["rel"] = "nofollow";

        base.Process(context, output);

Before continuing, it's worth noting that our derived class (NoFollowTagHelper) is what will become our custom tag helper name; Razor will add hyphens between the uppercase character and then lowercase the string. It will also remove the word TagHelper from the class name if it exists.

Before we can use our tag helper we need to tell Razor where to find it.

Loading our tag helper

To load our tag helper we need to add it to our `_ViewImports.cshtml` file. The _ViewImport's sole purpose is to reference our assemblies relating to the views to save us littering our views with references to assemblies. Using the _ViewImport we can do this in one place, much like we used to specify custom HTLM Helpers in the Web.config in previous versions of ASP.NET MVC.

// _ViewImports.cshtml
@using TagHelperDemo
@using TagHelperDemo.Models
@using TagHelperDemo.ViewModels.Account
@using TagHelperDemo.ViewModels.Manage
@using Microsoft.AspNet.Identity
@addTagHelper "*, Microsoft.AspNet.Mvc.TagHelpers"
@addTagHelper "*, TagHelperDemo" // Reference our assembly containing our tag helper here.

The asterisk will load all tag helpers within the TagHelperDemo assembly. If you wish to only load a single tag helper you can specify it like so:

// _ViewImports.cshtml
@addTagHelper "ImageLoaderTagHelper, TagHelperDemo"

Using our tag helper

Now that we've created our tag helper and referenced it, any references to <no-follow> elements will be transformed into no follow anchor links if the href is going to an external domain:

// Our custom tag helper
<no-follow href="">Thanks for visiting</no-follow>
<no-follow href="/about">About</no-follow>
<!-- The transformed output -->
<a href="" rel="nofollow">Thanks for visiting</a>
<a href="/about">About</a>

But wait! There's more!

Ok, so creating custom no-follow tags isn't ideal and is quite silly when we can just type normal HTML, so let's go one step further. With the new tag helper syntax you can actually transform normal HTML tags too! Let's demonstrate this awesomeness by modifiyng our nofollow tag helper:

[HtmlTargetElement("a", Attributes = "href")]
public class NoFollowTagHelper : TagHelper
    public override void Process(TagHelperContext context, TagHelperOutput output)
        var href = output.Attributes["href"];
        if (!href.Value.ToString().Contains(""))
            output.Attributes["rel"] = "nofollow";

        base.Process(context, output);

As you'll see, we've removed some redundant code and added the HtmlTargetElement attribute. This attribute is what allows us to target existing HTML elements and add additional functionality. Now, if we look at our Razor code ALL of our anchors have been processed by our NoFollowTagHelper class and only those with outbound links have been transformed:

<!-- Before -->
<a href="">Thanks for visiting</a>
<a href="/about">About</a>

<!-- After -->
<a href="" rel="nofollow">Thanks for visiting</a>
<a href="/about">About</a>

We've retrospectively changed the output of our HTML without needing to go through our codebase! For those that have worked on large applications and needed to create some kind of consistency between views, you'll hopefully understand how powerful this can be and the potential use cases for it. In fact, this is exactly how ASP.NET uses the tilde (~/) to locate the path an img src path - see for yourself here.

Moving on

So far we've spent the duration of this blog post talking about how powerful ASP.NET Core MVC's Tag Helpers, but with all great powers comes great responsibility - so let's take a moment to look at the downsides of tag helpers and ways we can prevent potential pitfalls as we use them.

The Responsibility

They look just like HTML
When the ASP.NET team first revealed tag helpers to the world there were mixed reactions over the syntax. The powers of Tag Helpers were clear, but some people feel the blurring of lines between HTML and Razor breaks separation of concerns between HTML and Razor. Take the following comments taken from Scott Hanselman's ASP.NET 5 (vNext) Work in Progress - Exploring TagHelpers post demonstrate the feelings of some:

What are the design goals for this feature? I see less razor syntax, but just exchanged for more non-standard html-like markup. I'm still fond of the T4MVC style of referencing controller actions.

This seems very tough to get on-board with. My biggest concern is how do we easily discern between which more obscure attributes are "TagHelper" related vs which ones are part of the HTML spec? When my company hires new devs, I can't rely on the fact that they would realize that "action" is a "server-side" attribute, but then things like "media" and "type" are HTML ... not to mention how hard it would be to tell the difference if I'm trying to maintain code where folks have mixed server-side/html attributes.

This lack of distinction between HTML and Razor quickly becomes apparent when you open a view file in a text editor that doesn't support the syntax highlighting of Tag Helpers that Visual Studio does. Can you spot what's HTML and what's a tag helper the following screenshot?

The solution

Luckily there is a solution to help people discern between HTML and Razor, and that's to force prefixes using the @tagHelperPrefix declaration.

By adding the @tagHelperPrefix declaration to the top of your view file you're able to force prefixes on all of the tags within that current view:

// Index.cshtml
@tagHelperPrefix "helper:"


    <helper:a asp-controller="MyController" asp-action="MyAction" class="my-css-classname" my-attr="my-attribute">Click me</helper:a>

With a tagHelperPrefix declaration specified in a page, any tag helper that isn't prefixed with the specified prefix will be completely ignored by the Razor engine (note: You also have to prefix the closing tag). If the tag is an enclosing tag that wraps some content, then the body of the tag helper will be emitted:

// Index.cshtml - specify helper prefix
@tagHelperPrefix "helper:"


    // Haven't specified helper: prefix
    <asp-controller="MyController" asp-action="MyAction" class="my-css-classname" my-attr="my-attribute">Click me</a>
<!-- Output without prefix: -->
    Click me

One problem that may arise from this solution is you may forget to add the prefix declaration to your view file. To combat this you can add the prefix declaration to the _ViewImport.cshtml file (which we talked about earlier). As all views automatically inherit from _ViewImport, our prefix rule will cascade down through the rest of our views. As you'd expect, this change will force all tag helpers to require your prefix - even the native .NET MVC tags including any anchors or image HTML tags that feature a tilde:

Unexpected HTML behaviour

Earlier in this article, the second version of NoFollowTagHelper demonstrated how we can harness the power of Tag Helpers to transform any HTML element. Whilst the ability to perform such transformations is a extremely powerful, we're effectively taking HTML, a simple markup language with very little native functionality, and giving it this new power. 

Let me try and explain.

If you were to copy and paste a page of HTML into a .html file and look at it, you'd be confident that there's no magic going on with the markup - effectively what you see is what you get. Now rename that HTML page to .cshtml and put it in an ASP.NET Core MVC application with a number of tag helpers that don't require a prefix and you'll no longer have that same confidence. This lack of confidence can create uncertainty in what was once static HTML. It's the same problem you have when performing DOM manipulations using JavaScript, which is why I prefer to prefix selectors targeted by JavaScript with a 'js', making it clear to the reader that it's being touched by JavaScript (as opposed to selecting DOM elements by classes used styling purposes).

To demonstrate this with an example, what does the following HTML element do?

<img src="/profile.jpg" alt="Profile Picture" />

In any other context it would be a simple profile picture from the root of your application. Considering the lack of classes or Id attributes you'd be fairly confident there's no JavaScript targeting it too.

With Tag Helpers added to the equation this HTML isn't what you expect. When rendered it actually becomes the following:

<img src="" alt="Profile Picture" />

Ultimately, the best way to avoid this unpredictable behaviour is to ensure you use prefixes, or at least be ensure your team are clear as to what tag helpers or are not active.

On closing

Hopefully this post has been valuable in highlighting the good, the bad and the potentially ugly consequences of Tag Helpers in your codebase. They're an extremely powerful addition to the .NET framework, but as with all things - there is potential to shoot yourself in the foot.

Capturing IIS / ASP.NET traffic in Fiddler

Posted on Monday, 25 Apr 2016

Recently, whilst debugging an issue I needed to capture the traffic being sent from my local application to an external RESTful web service. In this instance, I needed to see the contents of a JWT token being passed to the service to verify some of the data. Thankfully, Fiddler by Telerik is just the tool for the job.

What is fiddler?

Fiddler is a super powerful, free web debugging proxy tool created by the guys and girls at Telerik. Once launched, Fiddler will capture all incoming and outgoing traffic from your machine, allowing you to analyse traffic, manipulate HTTP (and HTTPS!) requests and perform a whole host of traffic based operations. It's a fantastic tool for debugging and if you don't have it I'd highly recommend you take a look at it. Did I say it's 100% free too?

Capturing ASP.NET / IIS Traffic

By default, Fiddler is configured to register itself as the system proxy for Microsoft Windows Internet Services (WinInet) - the HTTP layer used by IE (and other browsers), Microsoft Office, and many other products. Whilst this default configuration is suitable for the majority of your debugging, if you wish to capture traffic from IIS (which bypasses WinInet), we'll need to re-route our IIS traffic through Fiddler by modifying our application's Web.config.

Step 1: Update your Web.config

To do this, simply open your Web.config and add the following snippet of code after the <configSections> element.

    <defaultProxy enabled="true">
        <proxy proxyaddress="" bypassonlocal="False"/>

Step 2: Configure Fiddler to use the same port

Now that we've routed our IIS traffic through port 8888, we have to configure Fiddler to listen to the same port. To do this simple open Fiddler, go to Tools > Fiddler Options > Connections then change the port listed within the "Fiddler listens on port" setting to 8888.

Now if you fire up your application you'll start to see your requests stacking up in Fiddler ready for your inspection.

Happy debugging!

Publishing your first NuGet package in 5 easy steps

Posted on Friday, 15 Apr 2016

So you've just finished writing a small .NET library for a one-off project and you pause for a moment and think "I should stick this on NuGet - others may find this useful!". You know what NuGet is and how it works, but having never published a package before you're unsure what to do and are short on time. If this is the case then hopefully this post will help you out and show you just how painless creating your first NuGet package is.

Let's begin!

Step 1: Download the NuGet command line tool

First, you'll need to download the NuGet command line tool. You can do this by going here and downloading the latest version (beneath the Windows x86 Commandline heading).

Step 2: Add the NuGet executable to your PATH system variables

Now we've downloaded the NuGet executable we want to add it to our PATH system variables. At this point, you could simply reference the executable directly - but before long you'll be wanting to contribute more of your libraries and adding it to your PATH system variables will save you more work in the long run.

If you already know how to add PATH variables then jump to Step 3, if not then read on.

Adding the nuget command to your PATH system variables

First, move the NuGet.exe you downloaded to a suitable location (I store mine in C:/NuGet/). Now, right-click My Computer (This PC if you're on Windows 10). Click "Advanced System Settings" then click the "Environment Variables" button located within the Advanced tab. From here double-click the PATH variable in the top panel and create a new entry by adding the path to the directory that contains your NuGet.exe file (in this instance it's C:/NuGet/).

Now, if all's done right you should be able to open a Command Prompt window, type "nuget" and you'll be greeted with a list of NuGet commands.

Step 3: Create a Package.nuspec configuration file

In short, a .nuspec file is an XML-based configuration file that describes our NuGet package and its contents. For further reading on the role of the .nuspec file see the nuspec reference on

To create a .nuspec package manifest file, let's go to the root of our project we wish to publish (that's where I prefer to keep my .nuspec file as it can be added to source control) and open a Command Prompt window (Tip: Typing "cmd" in the folder path of your explorer window will automatically open a Command Prompt window pointing to the directory).

Now type "nuget spec" into your Command Prompt window. If all goes well you should be greeted with a message saying "Created 'Package.nuspec' successfully". If so, you should now see a Package.nuspec file your project folder.

Let's take a moment to look inside of our newly created Package.nuspec file. It should look a little like below:

<?xml version="1.0"?>
    <description>Package description</description>
    <releaseNotes>Summary of changes made in this release of the package.</releaseNotes>
    <copyright>Copyright 2016</copyright>
    <tags>Tag1 Tag2</tags>
      <dependency id="SampleDependency" version="1.0" />

As you can see, all of the parameters are pretty self-explanatory (see the docs here if you have any uncertainties on what the configuration does). The only one you may have a question about is the dependencies node - this is simply a list of the dependencies and their version that your NuGet package may have (See here for more info).

Now we've generated our NuGet configuration file, let's take a moment to fill it in.

Once you're done, your manifest file should look a little like below. The next step is to reference the files to be packaged. In the following example, you'll see that I've referenced the Release .dll file (take a look at the documentation here for more file options). If you haven't noticed, I've also removed the <dependencies> node as my package doesn't have any additional dependencies.

<?xml version="1.0"?>
<package >
    <authors>Joseph Woodward</authors>
    <owners>Joseph Woodward</owners>
    <description>Slugity is a simple, configuration based class library that's designed to create search engine friendly URL slugs</description>
    <releaseNotes>Initial release of Slugity.</releaseNotes>
    <copyright>Copyright 2016</copyright>
    <tags>Slug, slug creator, slug generator, url, url creator</tags>
    <file src="bin\Release\Slugity.dll" target="lib\NET40" />

Step 4: Creating your NuGet package

Once your Package.nuspec file has been filled in, let's create our NuGet package! To do this simply run the following command, replacing the path to the .csproj file with your own.

nuget pack Slugity/Slugity.csproj -Prop Configuration=Release -Verbosity detailed

If you have the time, take a moment to look over the various pack command options in the NuGet documentation.

Once the above command has been run, if all has gone well then you should see a YourPackageName.nupkg file appear in your project directory. This is our NuGet package that we can now submit to!

Step 5: Submitting your NuGet package to

We're almost there! Now all we need to do is head over to and submit our package. If you're not already registered at then you'll need to do so (see the "Register / Sign in" link at the top right of the homepage). Next, go to your Account page and click "Upload a package". Now all you need to do is upload your .nupkg package and verify the package details that will use for your package listing!

Congratulations on submitting your first NuGet package!

I hope this guide has been helpful to you, and as always, if you have any questions then leave them in the comments!

Tips for learning on the job

Posted on Tuesday, 29 Mar 2016

Today, whilst out walking the dog I was listening to an episode of Developer Tea titled "Learning on the Job". As someone that's always looking for smarter ways of learning, this episode was of particular interest to me. In fact, it got me thinking - what tips would I recommend for learning on the job?

I find learning on the job interesting for a few reasons. First of all, you spend a good portion of time at your computer programming. This very fact means you have plenty of opportunities to improve your knowledge and understanding of the language or framework you're using. However, you also have to balance this opportunity with the fact that you're working and have things to do and deadlines to meet. These external pressures mean you have to be smart about how you learn.

One of the strengths of a good developer is their ability to learn on the fly, and we should always be looking for opportunities to learn.

With this in mind. This post is a collection what I've found to be effective ways of learning on the job, whilst not letting it get in the way of your work.

REPLs, Fiddlers and online editors are your friends

REPLs are a great tool for learning. Within my browser's bookmark toolbar I have a whole host of online REPLs or Fiddlers for different languages. Languages such as C#, TypeScript and JavaScript.

If I'm researching a problem or happen to come across some code that I'm struggling to understand, I'll often take a moment to launch the appropriate REPL or Fiddler and experiment with the output to make sure I fully understand what the code is doing. These can be an invaluable tool for testing that base library function you've not never used before, test the output of the algorithm you've found or learn what your transpiled TypeScript code will look like. In fact, some online tools such as .NET Fiddle also have the ability to decompile code all the way to the IL/MSIL level - enabling you to gain an even greater understanding of what your code is doing.

Here are a few of the online tools I would recommend:

This aptly brings me onto my next tip.

Don't just copy and paste that code

Above I talked about REPLs and online Fiddlers. Use them! We've all copied and pasted some code on Stack Overflow to get something working. Take a moment to figure out exactly WHY the code is working and what your code is doing. Copying and pasting code that you don't understand is both dangerous and a wasted opportunity to learn something new. If you're too busy then bookmark it, or better yet - some of the editors listed above such as .NET Fiddle allow you to save snippets of code for later.

Write it down in a notepad

This tip I've found particularly effective and goes beyond learning whilst on the job, but I'll expound on this in a moment.

If you stumble across one of those bits of information that you think "Wow, I didn't know that. I should remember that!", take a moment and write it down on a notepad. The process of writing it down helps your new found knowledge to your long-term memory. Another tip for further improving your long-term memory is to revisit some of your notes a couple of hours, or days later. Repetition is another proven way to improve the retention of such information.

Having a notebook on you is also useful when reading books. If you happen to read a sentence of paragraph whilst reading a book, take a moment to write it down in your own words in your notebook. I guarantee you'll be able to recall the information later that day far clearer than you would have had you continued reading.

Share it with a co-worker or summarise it in a quick tweet

If you've just solved a problem or stumbled across a valuable piece of information then share it with your nearest co-worker. The very fact that you're talking about it or explaining the concept will help engrain it into your long-term memory. You also have the added benefit of sharing information knowledge with others.

If no-one's around then you could always talk it through with your rubber duck, or summarise your new knowledge in a quick tweet.

Stack Overflow

Stack Overflow is another great tool for learning on the job. If you're a registered user then you should take full advantage of the ability to favourite answers or questions. Doing so enables you to review them in more detail at a time more suitable.

Pocket and other alternatives

Bookmark sites like Pocket are another powerful tool when it comes to learning on the job and go a step beyond bookmarking.

Whilst struggling with that problem, if you happened to have come across an interesting article but didn't have the time to read it in its entirety then why not add it to your personal Pocket list and fill in the knowledge gap at a later date whilst you're waiting for the bus. Many of the apps like Pocket include the ability to automatically sync bookmarks with your smartphone for offline viewing making it perfect for commuting.

I hope people find these tips valuable. I'm always interested in hearing other recommendations for learning on the job so if there's anything I've not mentioned then please feel free to add it to the comments!

About Me

I’m a .NET focused software engineer currently working at Just Eat in Bristol, a regular speaker at user groups (and the occasional podcast), an active member within the .NET community, OSS contributor and co-organiser of the .NET South West meet up.

Having worked professionally in the software/web industry for over 10 years across a variety of frameworks and languages, I’ve found my real interests lie in good coding practices and writing maintainable software, regardless of the language.

Read More

Feel free to follow me on any of the channels below.

profile for JoeMighty at Stack Overflow, Q&A for professional and enthusiast programmers

Recent Blog Posts