DEV Community: Khalid Abuhakmeh

Save Your C# Keystrokes With Tuples

Khalid Abuhakmeh — Tue, 11 Feb 2020 00:00:00 +0000

In the year 2000, Microsoft released C# to the masses, and since then, it has evolved with many new features. One of those features includes Tuples. Only recently have tuples become more useful with the addition deconstruction in C# 8. In this post, I’ll show you how to save your keystrokes by working with Tuples. We’ll look at two identical code snippets with as much readability, but significantly fewer characters used.

What Is A Tuple

A Tuple is a newer data structure introduced in later versions of the .NET Framework. Microsoft’s documentation describes a Tuple as:

A tuple is a data structure that has a specific number and sequence of elements.–Microsoft

It’s likely easier to understand what a Tuple is by looking at an example.

// Microsoft Documentation Example
var primes = Tuple.Create(2, 3, 5, 7, 11, 13, 17, 19); 
Console.WriteLine("Prime numbers less than 20: " + 
    "{0}, {1}, {2}, {3}, {4}, {5}, {6}, and {7}", 
    primes.Item1, primes.Item2, primes.Item3, primes.Item4, 
    primes.Item5, primes.Item6, primes.Item7, primes.Rest.Item1); 
// The example displays the following output: 
// Prime numbers less than 20: 2, 3, 5, 7, 11, 13, 17, and 19

Tuples are limited to a structure containing seven items. That said, if you’re using Tuples with this many items, you may want to use a class.

Deconstruction To Save Keystrokes

Let’s take a look at an example using an anonymous friend object collection. Each friend has a name, nickname, and a set of hobbies.

var friends = new[]
{
    new
    {
        name = "Bruce Wayne",
        nickname = "Batman",
        hobbies = new[] {"dressing up", "crime-fighting", "parkour"}
    },
    new
    {
        name = "Natalia Romanova",
        nickname = "Black Widow",
        hobbies = new[] {"martial arts", "spying", "guns"}
    },
    new
    {
        name = "Arthur Curry", 
        nickname = "Aquaman", 
        hobbies = new[] {"surfing", "conversations", "fish"}
    }
};

foreach (var friend in friends)
{
    Console.WriteLine($"{friend.name} ({friend.nickname}) likes {string.Join(", ",friend.hobbies)}.");
}

When we execute the code, we get the following output:

Bruce Wayne (Batman) likes dressing up, crime-fighting, parkour.
Natalia Romanova (Black Widow) likes martial arts, spying, guns.
Arthur Curry (Aquaman) likes surfing, conversations, fish.

The character count of the previous code is 606 characters.

Let’s take a look at how we can use Tuple deconstruction to shorten that code.

var friends = new[]
{
    (
        "Bruce Wayne",
        "Batman",
        new[] {"dressing up", "crime-fighting", "parkour"}
    ),
    (
        "Natalia Romanova",
        "Black Widow",
        new[] {"martial arts", "spying", "guns"}
    ),
    (
        "Arthur Curry",
        "Aquaman",
        new[] {"surfing", "conversations", "fish"}
    )
};

foreach (var (name, nickname, hobbies) in friends)
{
    Console.WriteLine($"{name} ({nickname}) likes {string.Join(", ", hobbies)}.");
}

Executing the tuple deconstruction code, we get the following output.

Bruce Wayne (Batman) likes dressing up, crime-fighting, parkour.
Natalia Romanova (Black Widow) likes martial arts, spying, guns.
Arthur Curry (Aquaman) likes surfing, conversations, fish.

No surprise, it is identical to the first code execution. The difference being that this codebase has a character count of 497. That’s an 18% reduction in keystrokes. The savings come from not having to define property names, and the use of . notation to access those same properties.

By using Tuples we reduced our character count by 18%!–Khalid

Conclusion

Should you switch your entire codebase to use tuples? You should not. I think the advantage of tuples presents itself in tightly scoped situations. These situations can include scripts, unit tests, and code samples. In my opinion, tuples break down once you begin to pass them to external consumers. The items comprising my tuples are clear in the sample code, but if I were to return the tuple to an ignorant consumer, the intention of the data structure would be lost. Like all new things, take the time to absorb the idea, evaluate its value, and use it accordingly. I hope you found this blog post educational. Thank you for reading.

.NET Core 3.0 AllowSynchronousIO Workaround

Khalid Abuhakmeh — Tue, 28 Jan 2020 00:00:00 +0000

Over the last year I’ve been dabbling in the dark arts of GraphQL. As a web api interface, its easy to consume and utilize, but I consider myself a back end developer first and for most. I have been spending my time learning how to build a GraphQL server implementation utilizing .NET Core with GraphQL.NET. I’ve pulled down the project’s recent code, launched the harness project, and was immediately met with an ASP.NET Core error.

System.InvalidOperationException: Synchronous operations are disallowed. Call ReadAsync or set AllowSynchronousIO to true instead.
   at Microsoft.AspNetCore.Server.Kestrel.Core.Internal.Http.HttpRequestStream.Read(Byte[] buffer, Int32 offset, Int32 count)
   at System.IO.StreamReader.ReadBuffer(Span`1 userBuffer, Boolean& readToUserBuffer)
   at System.IO.StreamReader.ReadSpan(Span`1 buffer)
   at System.IO.StreamReader.Read(Char[] buffer, Int32 index, Int32 count)
   at Newtonsoft.Json.JsonTextReader.ReadData(Boolean append, Int32 charsRequired)
   at Newtonsoft.Json.JsonTextReader.ParseValue()
   at Newtonsoft.Json.JsonReader.ReadAndMoveToContent()
   at Newtonsoft.Json.JsonReader.ReadForType(JsonContract contract, Boolean hasConverter)
   at Newtonsoft.Json.Serialization.JsonSerializerInternalReader.Deserialize(JsonReader reader, Type objectType, Boolean checkAdditionalContent)
   at Newtonsoft.Json.JsonSerializer.DeserializeInternal(JsonReader reader, Type objectType)
   at Newtonsoft.Json.JsonSerializer.Deserialize(JsonReader reader, Type objectType)
   at Newtonsoft.Json.JsonSerializer.Deserialize[T](JsonReader reader)
   at Example.GraphQLMiddleware.Deserialize[T](Stream s) in /Users/khalidabuhakmeh/Projects/dotnet/graphql-dotnet/src/GraphQL.Harness/GraphQLMiddleware.cs:line 93
   at Example.GraphQLMiddleware.ExecuteAsync(HttpContext context, ISchema schema) in /Users/khalidabuhakmeh/Projects/dotnet/graphql-dotnet/src/GraphQL.Harness/GraphQLMiddleware.cs:line 54
   at Example.GraphQLMiddleware.Invoke(HttpContext context, ISchema schema) in /Users/khalidabuhakmeh/Projects/dotnet/graphql-dotnet/src/GraphQL.Harness/GraphQLMiddleware.cs:line 41
   at Microsoft.AspNetCore.Diagnostics.DeveloperExceptionPageMiddleware.Invoke(HttpContext context)

It turns out, starting in .NET Core 3.0, all synchronous operations on the request are turned off by default.

AllowSynchronousIO is a option in each server that enables or disables sync IO APIs like HttpReqeuest.Body.Read, HttpResponse.Body.Write, Stream.Flush, etc.. These APIs have long been a source of thread starvation and application hangs. Starting in 3.0.0-preview3 these are disabled by default. –Chris Ross

If you are seeing this error after upgrading your project to .NET Core 3.0, it is likely you are running on these .NET server implementations.

Kestrel
HttpSys
IIS in-process
TestServer

Errors can revolve around ReadAsync, WriteAsync, and FlushAsync with outputs similar to what is listed below.

Synchronous operations are disallowed. Call ReadAsync or set AllowSynchronousIO to true instead.

Synchronous operations are disallowed. Call WriteAsync or set AllowSynchronousIO to true instead.

Synchronous operations are disallowed. Call FlushAsync or set AllowSynchronousIO to true instead.

As a temporary workaround, you can set the value of AllowSynchronousIO in your ConfigureServices method found in your Startup class.

public void ConfigureServices(IServiceCollection services)
{
    services.Configure<KestrelServerOptions>(options =>
    {
        options.AllowSynchronousIO = true;
    });

    // If using IIS:
    services.Configure<IISServerOptions>(options =>
    {
        options.AllowSynchronousIO = true;
    });

    // other services
}

It isn’t a great workaround, but it will keep you moving forward. The better solution is to upgrade your libraries and perform all your actions asynchronously. I hope this helped!

Using Environment Variables In Your .NET Core Builds

Khalid Abuhakmeh — Sat, 25 Jan 2020 00:00:00 +0000

MSBuild is the glue that holds the .NET ecosystem together. As a powerful build system, it can do anything and everything to compose your applications. The tool has been around since the inception of .NET, but with .NET Core enhancements to the csproj files, it has become less scary to dive in and make modifications to your build process. In this post, I’ll show you the one trick that should make your .NET build pipeline easier, primarily if you use continuous integrations (CI) providers like AppVeyor, Windows Azure Kudu, or GitHub Actions.

Getting Started

We have a project file for each .NET Core project we start. Let’s look at an original file for a console application.

<Project Sdk="Microsoft.NET.Sdk">

    <PropertyGroup>
        <OutputType>Exe</OutputType>
        <TargetFramework>netcoreapp3.0</TargetFramework>
    </PropertyGroup>

</Project>

As you can see, the file is quite understandable. We want our artifact to be an executable program, and that we are targeting .NET Core 3.0.

Access To All Environment Variables

When working within this file, you may see variables accessed via the $() syntax. MSBuild gives you access to all environment variables during your build. We can utilize environment variables to execute targets conditionally. Let’s modify our csproj file with some targets and conditions.

<Project Sdk="Microsoft.NET.Sdk">

    <PropertyGroup>
        <OutputType>Exe</OutputType>
        <TargetFramework>netcoreapp3.0</TargetFramework>
    </PropertyGroup>

    <Target Name="Production" Condition="$(Game) == 'Pong'" BeforeTargets="Build">
        <Message Importance="high" Text="Ping!" />
    </Target>

    <Target Name="Development" Condition="$(Game) == 'Ping'" BeforeTargets="Build">
        <Message Importance="high" Text="Pong!" />
    </Target>

</Project>

If the environment variable of Game is Pong, then our build output should have a message of Ping!. If Game is Ping, then we should have an output message of Pong!. Let’s try it out. In a command-line window, we can pass in the environment variable for Game.

➜ ConsoleApp1 Game=Ping dotnet build
Microsoft (R) Build Engine version 16.4.0+e901037fe for .NET Core
Copyright (C) Microsoft Corporation. All rights reserved.

  Restore completed in 28.26 ms for /Users/khalidabuhakmeh/Projects/dotnet/ConsoleApp1/ConsoleApp1/ConsoleApp1.csproj.
  ConsoleApp1 -> /Users/khalidabuhakmeh/Projects/dotnet/ConsoleApp1/ConsoleApp1/bin/Debug/netcoreapp3.0/ConsoleApp1.dll
  Pong!

Build succeeded.
    0 Warning(s)
    0 Error(s)

Time Elapsed 00:00:01.06

Now, for Pong.

➜ ConsoleApp1 Game=Pong dotnet build
Microsoft (R) Build Engine version 16.4.0+e901037fe for .NET Core
Copyright (C) Microsoft Corporation. All rights reserved.

  Restore completed in 29.22 ms for /Users/khalidabuhakmeh/Projects/dotnet/ConsoleApp1/ConsoleApp1/ConsoleApp1.csproj.
  ConsoleApp1 -> /Users/khalidabuhakmeh/Projects/dotnet/ConsoleApp1/ConsoleApp1/bin/Debug/netcoreapp3.0/ConsoleApp1.dll
  Ping!

Build succeeded.
    0 Warning(s)
    0 Error(s)

Time Elapsed 00:00:01.05

As you can see with the two outputs above, we were able to execute build targets based on environment variables selectively. There is an array of options in MSBuild conditions and is viewable at Microsoft’s documentation site.

Environment Variables Everywhere!

In a previous blog post, I talked about running NPM scripts via MSBuild targets, and you should check it out. Building on that post, we can utilize environment variables in our build environment, to selectively run commands to build for different target environments. AppVeyor, a continuous integration service, injects many environment variables for your use. Windows Azure injects all app settings in the portal into your Kudu build environment, and so does GitHub actions.

Conclusion

Microsoft’s simplification of the csproj file makes it easier to reason and modify your .NET Core build process. Utilizing environment variables and MSBuild conditions means we can tailor our build artifacts for our destination environments. Most, if not all, CI services inject many variables that MSBuild can take advantage of, and it is quite simple to build complex conditions on these exposed variables.

Watching More Files With Dotnet Watch For Static Sites

Khalid Abuhakmeh — Wed, 22 Jan 2020 00:00:00 +0000

The marriage of .NET Core and static site generators is a beautiful thing. There are many great static site generator options out there like 11ty, Jekyll, Hugo, and many more. While you can accomplish amazing feats at build time, a dynamic backend can allow your application features that are just not possible at build time. The combination of .NET Core and the static site generator of your choice is a powerful one-two punch. In this post, I’ll show you how to set up an ASP.NET Core application hosting a static site generator, with the added ability to watch all files within your project.

Project and Static Site Setup

In this post, I’ll be using 11ty as my static site generator. This post could be adapted to any other static site framework. To get started with 11ty, check out the documentation site. The first step is to create a new ASP.NET Core application. From a command line, let’s create a new app.

$> mkdir staticz
$> cd staticz
$> dotnet new web

When we run this, we should have an empty ASP.NET Core applications.

The command dotnet new web will create an empty ASP.NET Core web application. Next, let’s run the commands to install 11ty.

$> npm init
$> npm install @11ty/eleventy --save-dev

To be able to run 11ty from the node_modules folder, we need to add an NPM script in packages.json.

{
  "name": "staticz",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1",
    "build": "eleventy --input=. --output=wwwroot"
  },
  "author": "",
  "license": "ISC",
  "devDependencies": {
    "@11ty/eleventy": "^0.10.0"
  }
}

We are passing some default arguments to 11ty. First, the directory to build, and secondly, the output directory of wwwroot. The output directory is the default content directory ASP.NET Core looks for in web projects. Before we run the script, let’s add a index.html file to the root of our project.

<!DOCTYPE html>
<html>
  <head>
    <title>Hello, World!</title>
  </head>
  <body>
    <p>Hi</p>
  </body>
</html>

Let’s make sure our script works by running npm run build in the command line. You should see some build output, and a brand new wwwroot folder. Awesome! Let’s get to the ASP.NET Core part now.

ASP.NET Core Configuration

The ASP.NET Core application has three parts: Add some static file middleware, modify our csproj file, and add a new build target. I’ve mentioned one of the approaches in a previous blog post about kicking some butt with Parcel.

Let’s first look at our changes to the Startup class. We need to register a few middleware components, specifically the DefaultFile middleware and the StaticFile middleware.

using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;

namespace staticz
{
    public class Startup
    {
        // This method gets called by the runtime. Use this method to add services to the container.
        // For more information on how to configure your application, visit https://go.microsoft.com/fwlink/?LinkID=398940
        public void ConfigureServices(IServiceCollection services)
        {
        }

        // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
        public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
        {
            if (env.IsDevelopment())
            {
                app.UseDeveloperExceptionPage();
            }

            app.UseHttpsRedirection();
            app.UseDefaultFiles();
            app.UseStaticFiles();
        }
    }
}

It is important that the UseDefaultFiles registration is called before the UseStaticFiles call. I also threw in the call to UseHttpsRedirection for good-practices reasons. The next step is to tell our application to run the npm run build command we have in packages.json. We do this by modifying our .csproj file.

<Project Sdk="Microsoft.NET.Sdk.Web">

  <PropertyGroup>
    <TargetFramework>netcoreapp3.1</TargetFramework>
  </PropertyGroup>

  <Target Name="Static" BeforeTargets="Build">
    <Exec Command="npm run build" />
  </Target>

  <ItemGroup>
    <!-- extends watching group to include *.js files -->
    <Watch 
      Include=" **\*.cs;** \*.js; **\*.json;** \*.html;**.*.md"
      Exclude="node_modules\ **\*;wwwroot\** \*;" 
    />
</ItemGroup>

</Project>

There are two important elements to this project that you should take note of:

The build target of Static. It will run our NPM script.
The Watch element tells the dotnet-watch command to observe specific files. You can also exclude certain directories as well.

Cool! Now we have all the pieces, only one thing left to do.

Dotnet Watch All The Things

In the command line, type the following command.

$> dotnet watch run

This will use your current project and the configuration options we have in our project file. Here is my command output.

Great! When we visit https://localhost:5001, we see the output of our index.html file.

Now, let’s modify our index.html file from saying Hi to a hipper Yo!.

As soon as the change occurs, our process is shut down and restarted. Since we modified the project to execute our NPM script, we also build our web assets. Going back to https://localhost:5001 we see the results of our hard work.

Yes! Now we have a quick feedback loop that includes our ASP.NET Core work and our static site work. If you want to configure dotnet-watch more granularly, I recommend reading the Microsoft Documentation site for more detailed information around configuring your project.

Conclusion

We have many tools at our disposal, and I think the combination of static site generators and ASP.NET Core are a winning combination. If you work within a multi-disciplinary team, this approach also allows everyone to participate in building your web application. Copywriters can focus on writing content, and developers can focus on optimizing the application using C# and .NET. Remember, this approach can be modified to work with your favorite static site generators, so branch out and experiment. All in all, this is a winning recipe in my book.

Using LINQ to Build A World Travel Itinerary

Khalid Abuhakmeh — Thu, 16 Jan 2020 00:00:00 +0000

I enjoy traveling, having new experiences, and making new friends. With so many locations to get to, it is challenging to keep all of them straight. In this post, I’ll show you how to use Language Integrated Query, or LINQ, to take a list of world locations and link them together into travel legs. This technique is powerful and is useful for other scenarios.

The Problem

Imagine you have a list of locations from around the world. You want to fly to each location and map each leg of your travel. Let’s first look at the sites.

var destinations = new List<string>
{
    "Harrisburg, Pennsylvania, USA",
    "London, England",
    "Amsterdam, Netherlands",
    "Paris, France",
    "Rome, Italy",
    "Shanghai, China",
    "Tokyo, Japan",
    "Sydney, Australia",
    "Maui, Hawaii, USA",
    "Los Angeles, California, USA"
};

We want to generate a list of travel legs from one location to the other. For example, you could start at Harrisburg, Pennsylvania, USA and fly to the next immediate location. In our case, that would be London, England.

[
  {
    legNumber: 1,
    start : "Harrisburg, Pennsylvania, USA",
    end: "London, England"
  },
  {
    legNumber: 2,
    start : "London, England",
    end: "Amsterdam, Netherlands"
  },
  ...
]

Our final destination should bring us back home to the first site. How do we accomplish this in C#?

The Solution: Shift and Zip To The Rescue

The first step to solving our problem is realizing that we need essentially two lists. We can visualize the problem easier if we start with a more straightforward numeric dataset.

[1, 2, 3]

Given we have the values of 1,2, and 3, we want the following result.

[
  [1, 2],
  [2, 3], 
  [3, 1]
]

To get to our result, we need two lists with identical values, but with the first list shifted by one value.

[1, 2, 3]
[2, 3, 1]

We can accomplish this by using a Shift extension method.

// https://stackoverflow.com/a/18181243
public static class ShiftList
{
    public static List<T> Shift<T>(this List<T> list, int shiftBy)
    {
        if (list.Count <= shiftBy)
        {
            return list;
        }

        var result = list.GetRange(shiftBy, list.Count-shiftBy);
        result.AddRange(list.GetRange(0,shiftBy));
        return result;
    }
}

Once we have two lists, we can use LINQ’s Zip method to pair the two list values together into one enumerable.

var shifted = destinations.Shift(1).ToList();
var legs =
    destinations
        // using ZIP to pair the first and second lists here
        .Zip(shifted, (first, second) => new { first , second })
        .Select((leg, i) => new
        {
            legNumber = i + 1, 
            start = leg.first, 
            end = leg.second
        })
        .ToList();

Let’s look at our results!

1.) Harrisburg, Pennsylvania, USA -> London, England
2.) London, England -> Amsterdam, Netherlands
3.) Amsterdam, Netherlands -> Paris, France
4.) Paris, France -> Rome, Italy
5.) Rome, Italy -> Shanghai, China
6.) Shanghai, China -> Tokyo, Japan
7.) Tokyo, Japan -> Sydney, Australia
8.) Sydney, Australia -> Maui, Hawaii, USA
9.) Maui, Hawaii, USA -> Los Angeles, California, USA
10.) Los Angeles, California, USA -> Harrisburg, Pennsylvania, USA

And here is the full program.

using System;
using System.Collections.Generic;
using System.Linq;

namespace ConsoleApp1
{
    class Program
    {
        static void Main(string[] args)
        {
            var destinations = new List<string>
            {
                "Harrisburg, Pennsylvania, USA",
                "London, England",
                "Amsterdam, Netherlands",
                "Paris, France",
                "Rome, Italy",
                "Shanghai, China",
                "Tokyo, Japan",
                "Sydney, Australia",
                "Maui, Hawaii, USA",
                "Los Angeles, California, USA"
            };

            var shifted = destinations.Shift(1).ToList();
            var legs =
                destinations
                    .Zip(shifted, (first, second) => new { first , second })
                    .Select((leg, i) => new
                    {
                        legNumber = i + 1, 
                        start = leg.first, 
                        end = leg.second
                    })
                    .ToList();

            foreach (var leg in legs)
            {
                Console.WriteLine($"{leg.legNumber}.) {leg.start} -> {leg.end}");
            }
        }
    }

    // https://stackoverflow.com/a/18181243
    public static class ShiftList
    {
        public static List<T> Shift<T>(this List<T> list, int shiftBy)
        {
            if (list.Count <= shiftBy)
            {
                return list;
            }

            var result = list.GetRange(shiftBy, list.Count-shiftBy);
            result.AddRange(list.GetRange(0,shiftBy));
            return result;
        }
    }
}

Conclusion

You can use LINQ’s Zip method to tie to lists together into something new. In our case, we wanted to travel from one item to the other in a connected fashion. This technique is robust for different use cases as well. Recently, I used this technique to get the distance between two headers in a command-line output. I hope you found this post a fun exploration into LINQ and playing with collections.

Endpoint Debugging in ASP.NET Core 3 Applications

Khalid Abuhakmeh — Sun, 12 Jan 2020 00:00:00 +0000

Nothing can be more frustrating than going into a situation “thinking” you know how a framework works, only to spend the next several hours pulling your hair out and stewing in a pot of unhealthy feelings. I like to consider myself an ASP.NET routing expert with my experience dating back to MVC 1.0. Recently, I’ve started using ASP.NET Core Razor Pages mixed in with MVC and API approaches. I find the combination of all this technology to be a winning one, but it can also add complexity when building views. In this post, I’ll show you a simple one page Razor Page that can help diagnose route resolution issues quickly. Quickly see what your ASP.NET Core application sees and what it requires to resolve routes.

Endpoint Routing

With .NET Core 3, the responsibility of routing is on the shoulders of the EndpointMiddlware component. Registrations of the approaches described above, MVC, Razor Pages, and API occur in the Configure method of the Startup class. Below, you’ll see the registration of all Razor Pages endpoints.

app.UseEndpoints(endpoints => { endpoints.MapRazorPages(); });

The method scans the project for all Razor Pages and registers them as individual endpoints. Cool right?

What you may not realize is that each registration goes into a global bank of endpoints. This data source of endpoints is called the EndpointDataSource. Luckily, this data source is also registered (on the down-low) with your dependency injection container. The endpoint data source will be critical for our solution.

Solution

When generating links within your application, you’ll end up using helper methods from Url and Html.

<a class="dropdown-item" href="@Url.Page("/Admin/Conferences/Index")">Conferences</a>
<!-- or -->
<a href="@Url.Page("/Admin/Conferences/Edit", new { @conference.Id })" role="button">
    Edit
</a>

If you’re like me, you may forget to add a critical route value, which causes ASP.NET Core to give up on route generation. I’ve found the best way to debug these situations, is to see what routes are registered. To do that, I’ve built a Razor page that you can drop into your project right now and get more information. I named my page _routes.cshtml, and the code-behind is unnecessary.

@page
@using Microsoft.AspNetCore.Mvc.ApplicationModels
@using Microsoft.AspNetCore.Mvc.RazorPages
@using Microsoft.AspNetCore.Routing
@inject EndpointDataSource EndpointsDataSource

@{
    var endpoints = EndpointsDataSource.Endpoints.ToList();
}

<table class="table">
    <thead class="thead-dark">
    <tr>
        <th scope="col">Order</th>
        <th scope="col">Display Name</th>
        <th scope="col">Route Pattern</th>
        <th scope="col">Metadata</th>
    </tr>
    </thead>
    <tbody>
    @foreach (var endpoint in endpoints)
    {
        var routeEndpoint = endpoint as RouteEndpoint;
        <tr>
            <td>@routeEndpoint?.Order</td>
            <td>@endpoint.DisplayName</td>
            <td>@routeEndpoint?.RoutePattern.RawText</td>
            <td>
                <ul>
                    @foreach (var md in endpoint.Metadata)
                    {
                        switch (md)
                        {
                            case PageRouteMetadata prm:
                                <li>
                                    <p>@nameof(PageRouteMetadata)</p>
                                    <ul>
                                        <li>Page Route: @prm.PageRoute</li>
                                        <li>Route Template: @prm.RouteTemplate</li>
                                    </ul>
                                </li>
                                break;
                            case PageActionDescriptor pad:
                                <li>
                                    <p>@nameof(PageActionDescriptor)</p>
                                    <ul>
                                        <li>Id: @pad.Id</li>
                                        <li>Area: @pad.AreaName</li>
                                        <li>Display Name: @pad.DisplayName</li>
                                        <li>View Engine Path: @pad.ViewEnginePath</li>
                                        <li>Relative Path: @pad.RelativePath</li>
                                    </ul>
                                </li>
                                break;
                            case RouteNameMetadata rnm:
                                <li>
                                    Route Name Metadata: @rnm.RouteName
                                </li>
                                break;
                            case SuppressLinkGenerationMetadata slg:
                                <li>
                                    suppress link: @slg.SuppressLinkGeneration;
                                </li>
                                break;
                            default:
                                <li>@md.ToString()</li>
                                break;
                        }
                    }
                </ul>
            </td>
        </tr>
    }
    </tbody>
</table>

And here is what it looks like when you visit the page.

Awesome right?!

More Endpoint Information

The exciting part of debugging endpoints is that there is a treasure trove of information for each route. You can see what required parameters exist for each route, the expected name for resolution, the view engine path, and much more. The debugger in this post was written to diagnose Razor Page issues, but will also work with any library that registers an endpoint.

Conclusion

ASP.NET Core routing is powerful but can be a bit of a black box. Understanding where routes are registered and how you can debug them can save you hours of frustration. Understanding that all endpoints are registered globally and can be accessed via an EndpointDataSource makes the task of debugging much more straightforward. I hope this post has helped, and please feel free to leave a comment.

Battling Spam In Your ASP.NET Core Applications with Akismet

Khalid Abuhakmeh — Sat, 04 Jan 2020 00:00:00 +0000

You’ve spent the better part of a year building your site with hopes of positive community interaction. You deploy your application feeling you’ve accomplished something great. Days later, you realize that your community site has become flooded with horrible advertisements for the latest diet fads, get rich quick schemes, and links to the more sordid parts of the internet.

In this post, I’ll show you how to combat spam in your ASP.NET Core applications using the Akismet API and ideas for implementing necessary components you will need to keep your application data free of unwanted users and their content.

What Is Spam

No, we are not talking about any kind of canned meat. Spam is any unsolicited or undesirable message from a third party. As internet folks, we deal with unwanted email spam every day. You can also find spam in user groups, search engine results, blog comments, and text messages. If a communication medium exists, it likely has a spam problem. Why would anyone want to spam your application?

As stated on Wikipedia:

Spamming remains economically viable because advertisers have no operating costs beyond the management of their mailing lists, servers, infrastructures, IP ranges, and domain names, and it is difficult to hold senders accountable for their mass mailings. –Wikipedia

Fun fact: The term spam can be traced back to Monty Python’s Flying Circus.

What Is Akismet

Akismet is an API service provided by Wordpress. It is a database with known spam instances that can help identify comments as spam. The service works by crowd-sourcing identification to users of the API and comes bundled with every Wordpress instance.

Used by millions of websites, Akismet filters out hundreds of millions of spam comments from the Web every day. –Akismet

As of writing this post, Akismet claims to have blocked close to 500 million spam comments.

The Akismet API has four functional endpoints:

Key Verification : Clients can use this endpoint to verify API keys. Mainly used by services that allow users to add their keys to the application.
Comment Check : Clients can send comments (or any message) to Akismet for spam validation. The check endpoint is the most used endpoint on the service.
Submit Spam : This allows applications to submit verified spam to Akismet, thus enhancing the database of known spam.
Submit Ham : Allows clients to provide false positives (real comments marked as spam), giving Akismet an idea of what factors may have caused the mistake in the first place.

I really recommend reading the Akismet documentation, as it gives detailed advice when testing your implementation.

Before Getting Started With Akismet

Before using Akismet in your application, you must take into account a few factors.

Akismet is not free, but is reasonably priced. For commercial use, plans start at $5 a month. You can create a free account for local development.
Akismet is not perfect. It relies on users to actively mark incoming messages as spam, and also mark false-positives as ham. Thus plan for building mechanisms in your application to manage any avenue protected by Akismet.
Akismet is a web API, so performing any spam protection will incur a network request over the internet. If you have sensitive information or require an offline solution, this is not something I would recommend.

If all those caveats look reasonable to you, you can continue to the Akismet developer portal.

Before continuing to the implementation, you will need an API key from Akismet.

ASP.NET Core Implementation

Now that you understand what Akismet it, you can imagine how you may use it to increase the quality of user interaction in your application. The implementation is quite simple, given Akismet is a web API.

The first step is to install the Akismet client in your ASP.NET Core application. I use a library called Akismet from NuGet.

> Install-Package Akismet -Version 0.7.0

The second step will involve us registering our AkismetClient with ASP.NET Core’s dependency injection. To initialize the client, you will need an API key, the URI of your application, the name of your app.

public void ConfigureServices(IServiceCollection services)
{
    services.AddRazorPages();

    services.AddSingleton(
        new AkismetClient(
        "<Your API Key Here>",
        new Uri(Configuration["blogUrl"]),
        "spam-killer")
    );
}

I chose to register the client as a singleton because the AkismetClient has an internal HttpClient and is otherwise stateless. Feel free to register the client for your specific needs. You may have to use a transient registration if you allow users to supply personal API keys.

The next step is to use it in our application. In this example, I am using Razor Pages with a simple form.

public class Contact : PageModel
{
    private readonly IConfiguration configuration;
    private AkismetClient Akismet { get; }

    public Contact(AkismetClient akismet, IConfiguration configuration)
    {
        this.configuration = configuration ?? throw new ArgumentNullException(nameof(configuration));
        Akismet = akismet ?? throw new ArgumentNullException(nameof(akismet));
    }

    [BindProperty]
    public string Comment { get; set; }

    [BindProperty]
    public string Author { get; set; }

    public bool? IsSpam { get; set; }

    public async Task OnPost()
    {
        var comment = new AkismetComment
        {
            Blog = new Uri(configuration["blogUrl"]),
            CommentAuthorEmail = Author,
            CommentContent = Comment,
        };

        IsSpam = await Akismet.IsSpam(comment);
    }
}

You can see, we are using the AkismetClient to call the IsSpam endpoint with an AkismetComment. A comment has the following properties:

public Uri Blog { get; set; }
public string UserIp { get; set; }
public string UserAgent { get; set; }
public string Referrer { get; set; }
public string Permalink { get; set; }
public string CommentType { get; set; }
public string CommentAuthor { get; set; }
public string CommentAuthorEmail { get; set; }
public string CommentAuthorUrl { get; set; }
public string CommentContent { get; set; }

You don’t have to set all the properties, but the more information you can provide Akismet, the more likely they are to flag an incoming comment as spam.

The Razor page has the following implementation:

@page
@model SpamKiller.Pages.Contact
@{
    ViewData["Title"] = "Contact";
}

@if (Model.IsSpam.HasValue)
{
    <div class="row">
        <div class="col-md-12">
            <div class="alert alert-@(Model.IsSpam.Value ? "warning" : "success")" role="alert">
                <h4 class="alert-heading">The Results Are In!</h4>
                @if (Model.IsSpam.Value)
                {
                    <p>Boo his, you're trying to submit SPAM to my application. You should be ashamed of your nefarious activity.</p>
                }
                else
                {
                    <p>Aww yeah, you successfully submitted some quality stuff here. We'll get back to you as soon as we can.</p>
                }
                <hr>
                <p class="mb-0">Calling Akismet insures we filter out as much SPAM as possible.</p>
            </div>
        </div>
    </div>
}

<div class="row">
    <div class="col-md-12">
        <div class="text-center">
            <form asp-page="Contact" method="post" name="contact">
                <div class="form-group">
                    <label for="email">Email address</label>
                    <input type="email" class="form-control" id="email" aria-describedby="emailHelp" placeholder="Enter email" asp-for="Author">
                    <small id="emailHelp" class="form-text text-muted">We'll never share your email with anyone else.</small>
                </div>
                <div class="form-group">
                    <label for="comment">Example textarea</label>
                    <textarea class="form-control" id="comment" rows="3" asp-for="Comment"></textarea>
                </div>
                <button type="submit" class="btn btn-primary">Submit</button>
            </form>
        </div>
    </div>
</div>

Akismet is easy to test, as they give you inputs that can trigger spam detection immediately. If the user’s email address is akismet-guaranteed-spam@example.com, it will immediately be marked as spam. Here are two examples: one is welcome, and the other marked immediately as spam.

The “good result” we expected:

The “bad” result we expected:

If we log into our Akismet account, it will also show us analytics around our application.

If you’d like to play around with the sample application, you can clone the repository from GitHub.

Conclusion

Building interactive applications are challenging, especially when the internet has nefarious parties waiting to exploit any open form. Luckily, spam isn’t a new problem, and by using Akismet, even a single developer can take on an army of spammers.

Remember the following before using Akismet:

Akismet is free for personal use but has paid tiers for commercial use.
The service is not perfect, so build mechanisms into your application to manage spam and ham (false-positives). Maybe a dashboard or notification system via email/text message.
You will be transmitting the data over the internet, so take into account the latency and sensitivity of the data.

The actual implementation in code is pretty simple, and anyone can do it. I hope I’ve inspired you to battle spam and ultimately help everyone else. Good luck, and please let me know if this post has helped in any way.

Running NPM Scripts From A .NET Core Process

Khalid Abuhakmeh — Sat, 30 Nov 2019 00:00:00 +0000

It’s 2019, and no one can argue that to be a successful developer, you need a couple of tools in your toolbox. For ASP.NET developers, they can build web applications and run Kestrel as a web server. For front end developers, many UI frameworks have their own hot-reload capable web servers. In this post, I’ll show you .NET developers how to start a front end web server from their .NET Core process and use that in their C# application.

Download the project at GitHub.

Why Run NPM Scripts From .NET Core

Like I mentioned above, many web frameworks come with their web servers. By using these internal webservers, developers get access to many features they wouldn’t otherwise. Some highlights include hot-reloading when development files change and extra debugging capabilities. Running these servers from .NET Core allows us to read the output and create variables for our .NET Core application to use (as you’ll see later).

Before we get started, we’ll need NodeJs, NPM, and .NET Core.

Setting up the Script

In a new .NET Core application, we’ll need to set up a packages.json file. This file will have our development dependency and UI framework of our choice. In this example, I am using Parcel to bundle and minify my assets. And as it stands today, it also has [an internal webserver][parcel-sever]. We’ll use the server to serve those assets to our C# application.

{
  "name": "ChildProcesses",
  "version": "1.0.0",
  "dependencies": {},
  "devDependencies": {
    "parcel": "^1.12.4"
  },
  "scripts": {
    "dev": "parcel ./src/index.html",
    "build": "parcel build ./src/index.html",
    "watch": "parcel watch ./src/index.html"
  }
}

Parcel has three commands that are of interest to us.

build: creates our assets for production
watch: creates our assets for development and rebuilds them when they change.
dev: like watch but with a web server

We could run any of the scripts from our .NET Core application, but likely to run dev or watch during our development process. If you want to run build, I suggest my previous post, which shows how you can run NPM scripts during the build process.

The .NET Core Application

Let’s look at the final product of running the NPM script in our .NET Core application.

using System;
using System.Threading;
using System.Threading.Tasks;

namespace ChildProcesses
{
    static class Program
    {
        static async Task Main(string[] args)
        {
            using var parcel = new NpmScript();

            await parcel.RunAsync(Console.WriteLine);

            Console.WriteLine(parcel.HasServer
                ? $"From ASP.NET Core. Parcel is started ({parcel.HasServer}) @ {parcel.Url} at process: {parcel.ProcessId}"
                : "Script has executed.");

            await Task.Delay(TimeSpan.FromSeconds(4));
        }
    }
}

In the code, we create a new NpmScript class, and then run the process. The NpmScript class does a few things that I think folks will appreciate.

It will wait for the Parcel process to complete running.
It will parse the output for the webserver
In the off chance we are not running the webserver, it will timeout and succeed
We can write the console output of our NPM script to an Action
It will throw if the process fails to start.
The node process is a child process of our .NET Core application. When our app stops, so will all child processes.

After we run it, we get the following results:

Here is the Node process running in activity monitor.

When we close out the .NET Core application, we no longer see the node child processes.

The NpmScript Class

The following is the implementation of NpmScript, which uses a Process class to execute our NPM scripts.

public class NpmScript : IDisposable
{
    private readonly string scriptName;

    private static readonly Regex urls =
        new Regex(
            "(ht|f)tp(s?)\\:\\/\\/[0-9a-zA-Z]([-.\\w]*[0-9a-zA-Z])*(:(0-9)*)*(\\/?)([a-zA-Z0-9\\-\\.\\?\\,\\'\\/\\\\\\+&%\\$#_]*)?",
            RegexOptions.IgnoreCase | RegexOptions.Compiled);

    private Process process;
    public string Url { get; private set; }
    public bool HasServer => !string.IsNullOrEmpty(Url);

    public int ProcessId => process?.Id ?? 0;

    private readonly TaskCompletionSource<bool> signal = new TaskCompletionSource<bool>(false);

    /// <summary>
    /// Will execute a script name with default value of "dev"
    /// i.e. npm run [script name]
    /// </summary>
    /// <param name="scriptName"></param>
    public NpmScript(string scriptName = "dev")
    {
        this.scriptName = scriptName;
    }

    /// <summary>
    /// Will wait for npm to start up and retrieve the first url from the output.
    /// **Only use this to run the development server.**
    /// </summary>
    /// <param name="output"></param>
    /// <param name="timeout">In milliseconds</param>
    /// <returns></returns>
    public async Task RunAsync(Action<string> output = null, int timeout = 2000)
    {
        lock(signal) 
        {
            if (process == null)
            {
                var info = new ProcessStartInfo("npm")
                {
                    RedirectStandardOutput = true,
                    RedirectStandardError = true,
                    Arguments = $"run {scriptName}",
                    UseShellExecute = false,
                };

                process = Process.Start(info);
                process.EnableRaisingEvents = true;
                process.BeginOutputReadLine();
                process.BeginErrorReadLine();

                // Process the NPM output and attempt
                // to find a URL. This will stop processing
                // when it finds the first URL
                process.OutputDataReceived += (sender, eventArgs) =>
                {
                    output?.Invoke(eventArgs.Data);

                    if (!string.IsNullOrEmpty(eventArgs.Data) && string.IsNullOrEmpty(Url))
                    {
                        var results = urls.Matches(eventArgs.Data);

                        if (results.Any())
                        {
                            Url = results.First().Value;
                            signal.SetResult(true);
                        }
                    }
                };

                // Terrible things have happened
                // so we can stop waiting for the success
                // event to occur, because it ain't happening
                process.ErrorDataReceived += (sender, args) =>
                {
                    output?.Invoke(args.Data);

                    if (!signal.Task.IsCompleted)
                    {
                        signal.SetException(new Exception("npm web server failed to start"));
                    }
                };

                // set a timeout to wait for the process
                // to finish starting and find the Url. If it doesn't then we
                // assume that the user just ran a script
                var cancellationTokenSource = new CancellationTokenSource(timeout);
                cancellationTokenSource.Token.Register(() =>
                {
                    if (signal.Task.IsCompleted) 
                        return;

                    // we don't want to wait for a url anymore
                    Url = string.Empty;
                    signal.SetResult(true);
                }, false);
            }
        } 

        await signal.Task;
    }

    public void Dispose()
    {
        process?.Dispose();
    }
}

Conclusion

While you could run your frontend web server and .NET Core application as two separate processes, I believe this approach has some benefits that you should consider. First, NPM scripts run as a child process of your .NET Core application. More importantly, you can parse the output of your NPM scripts to create variables to use in your .NET Core applications (think ASP.NET Core). Finally, you can programmatically know whether the NPM scripts succeeded or failed, which can save you hours of debugging. If you’re a .NET Core developer, but still want to use the latest UI frameworks that the JavaScript community has to offer, I hope you consider using this approach. Also, feel free to modify the NpmScript class to meet your needs.

Download the project at GitHub.

Hi, I'm Khalid Abuhakmeh

Khalid Abuhakmeh — Fri, 23 Jun 2017 12:16:28 +0000

I have been coding for 10 years.

You can find me on Twitter as @buhakmeh

I live in New Cumberland, PA which is close to the capital of Harrisburg.

I work currently work for Ritter Insurance Marketing. I also blog at khalidabuhakmeh.com about my .NET adventures.

I mostly program in these languages: C# and JavaScript on the ASP.NET stack.

I am currently learning more about Vue and Functional Programming.

Nice to meet you.