Introducing Arex388.AspNet.Mvc.Startup NuGet Package to Simulate ASP.NET Core's Startup.cs in Classic ASP.NET MVC Applications

It's been a while since I wrote anything on here because I've been busy out of my mind, but I recently made something that I want to share with everyone.

At my work, our main application is an ASP.NET MVC 5 app (5.2.7 to be exact). I use Ninject for dependency injection and it has been working well for ~6 years so far. That being said, I was having a very hard time getting AutoMapper's instance API registered with Ninject. I tried the example in AutoMapper's docs, but I couldn't get it to work. Because of this, I couldn't update to AutoMapper 9 where the static API no longer exists.

After spending a few days reading and researching how to get AutoMapper and Ninject to work I ran across a blog post from Scott Dorman about using the Microsoft.Extensions.DependencyInjection NuGet package with classic ASP.NET MVC apps. I tried implementing his example, but couldn't get it to work at all either.

After several more days of research, I stumbled onto a Gist from David Fowler where he takes a slightly different approach. I decided to give it a shot and this time it worked! Finally, I had a working code sample. From there I just messed around with it in a throw-away app to get the hang of it. Once I was satisfied I decided to extract it out into its own library so I could share it on NuGet.

Originally it was called Arex388.AspNet.Mvc.DependencyInjection, but as I progressed through it, I realized that using Owin I can make it essentially simulate ASP.NET Core's Startup.cs file, except it would all be in the Global.asax.cs. So the current version is a mix of code examples from David Fowler and Scott Dorman with some sprinkles of code from me here and there to glue it together.

How to Use

  1. Add the Arex388.AspNet.Mvc.Startup NuGet package.
  2. Change your Global.asax.cs to inherit from StartupApplication.
  3. Add [assembly: OwinStartup(typeof(YourNamespace.MvcApplication))] attribute to the namespace of your Global.asax.cs.
  4. Implement the Configure and ConfigureServices methods inherited from StartupApplication.
  5. Add ConfigureServices() to the end of Application_Start.

Here's a more complete example:

[assembly: OwinStartup(typeof(YourNamespace.MvcApplication))]
namespace YourNamespace {
    public class MvcApplication :
        StartupApplication {
        public void Application_Start() {
            //	Other setup and configuration code here...


		public override Configure(
			IAppBuilder app) {
			//	Add IAppBuilder configurations

        public override void ConfigureServices(
            IServiceCollection services) {
            var assembly = typeof(MvcApplication).Assembly;

            //	Add your controllers

            //	Add other services that have IServiceCollection extensions


As you can see it's very simple and easy, seems to "just work" and for me at least has helped me make sure my ~6 year old project is still keeping up with ASP.NET Core somehow.

And with that here's a delayed Christmas present to end off 2019! The source code is available on GitHub, and the package is available on NuGet.

Fixing the "Keyset does not exist" exception with the Data Protection API in .NET Core

Looks like I'm going to be making a series of posts based on the project I'm currently working on. In this post, we're going explore an infuriating exception I was getting.

In the project, I'm using the Data Protection API for the first time. I settled on using it with a certificate for protecting the keys. On first run of any of the apps in the project, they would create a new starter key fine, but every run after that they would be unable to decrypt the key and would just keep making new ones. The exception was:

Key {020d5bfa-9105-4854-84ce-f097763d47d5} is ineligible to be the default key because its CreateEncryptor method failed.

Internal.Cryptography.CryptoThrowHelper+WindowsCryptographicException: Keyset does not exist

This was puzzling. Why would it fail to create the encryptor when it just did so on the previous run and generated the key?

After struggling with this for a while, it turned out to be just permissions. For whatever reason, when its time to decrypt the key, the app was unable to read the certificate out of the certificate store. It apparently works perfectly fine when writing new keys, but not for reading them.

Answers on StackOverflow suggested giving IIS_IUSER permissions on the certificate, and I'm sure that would probably work fine in a production environment, but I was not always testing the apps from IIS. In fact, in order to resolve some other even more infuriating issues, I had to manually run the apps through the console. At that point, they were inheriting my user.

In the end, I just gave Everyone permissions on the certificate and it worked out. I also did the same for the certificate on the production server (it's the same certificate). To do so:

  • Open the Certificates MMC
  • Find your certificate, probably in Personal > Certificates
  • Right-click on the certificate All Tasks > Manage Private Keys
  • Add Everyone as a new user with full permissions

Make sure the certificate is valid. You can use a self-signed certificate if you go through some annoying hoops and implement your own version of the class that finds the certificate by its thumbprint. You'll have to do that just so you can tell it to ignore invalid certificates. I did that in the beginning, but eventually just spent the $16 it was to get a valid certificate for two years over at Namecheap.

Hangfire JobStorage.Current is Not Set Even Though you Registered its Services for Dependency Injection

I'm currently working on a project that is split into five ASP.NET Core 2.2 web apps. One of the web apps is a dedicated Hangfire server, and another one is a dedicated IoT server. The IoT server needs to occasionally enqueue background jobs to the Hangfire server. When I was testing it out the other day for the first time, I got a weird exception that Hangfire's JobStorage.Current property is not set.

This surprised me because I made sure to add it and use it in the Startup class. I went back into the class and sure enough, it was there. I then compared it with the Startup classes for the other web apps (which were working fine) and it was identical. Nevertheless the exception was being thrown.

After some searching online and getting nowhere I stumbled, really by chance, onto a bug report on Hangfire's site. It's by a user named Poly and he had the exact same issue as me. Luckily for me, he had a workaround for it by injecting the IServiceProvider in the Configure method and then using it to get an instance of the JobStorage. This initializes the property and everything works great after that.

Sadly, his post is from October of 2016, so almost three years later, this still seems to be an issue in Hangfire.

Review: Star Wars - Thrawn Trilogy Series

I recently finished listening to the Star Wars: Thrawn Trilogy audiobook series, and I quite liked it. At times I didn‘t do anything but sit and listen to it, that‘s how captivated I was with it.

Going into it I didn‘t know much about Thrawn except that he was a tactical genius and that he was the "bad guy". Now, having completed the series, I find him to be quite likable. He‘s still the "bad guy", but he’s the lovable bad guy. Also, yes, he is a tactical genius. His ability to piece together the big picture out of bread crumbs is amazing.

I think this series also introduced Talon Karrde, whom I already liked, but didn‘t know much about either. He‘s Thrawn‘s "good guy" counterpart in my opinion, even though he resists fully committing to being that.

Mara Jade is also introduced, I think, but she‘s kind of mean, although that‘s because she was still under the influence of Palpatine. I‘m glad she finally breaks out of it, although I have a feeling that Palpatine‘s influence was to undermine Joruus C‘baoth‘s plan to claim the Empire as his own.

Overall I really enjoyed the series and I highly recommend it to any Star Wars fan.

Arex388.Geocodio 1.2.2 Released

This is a minor update to add the Metropolitan Divisions property for Census data.

Review: Star Wars - X-Wing Series

Since I recently posted a review of the Michael Vey book series, I decided to write a short review of the Star Wars: X-Wing book series since I finished it first. This was the book series that I used to start listening to audiobooks when driving to and from work. I really like Star Wars and specifically Legends (because new cannon is weak, to say the least...) so I started out with the X-Wing series.

I quite enjoyed the series and learned about the campaigns to capture Coruscant, against Ysanne Isard and the capture of the Lusankya SSD, and the defeat of Warlord Zsinj, amongst other events. Having subscribed to EckhartsLadder YouTube channel and watched his videos on those events I had a rough idea of what happened, but I still liked going through the books. Sadly, I think the audiobooks were abridged, so I probably missed on quite a bit of detail. Maybe one day I'll actually read through the books and see, but that requires spare time...

As I was getting the list of the book titles for this post, I saw that there is a book that I haven't listened to yet. X-Wing: Mercy Kill, listed as a side novel to the Fate of the Jedi series, which I haven't gone through yet, so I'll wait until then.

Anyway, if you like Star Wars and Legends, then I highly recommend reading the books or listening to the audiobooks.

Cleanly Optimize and Embed Font Awesome in Your Website

This is a sort of a follow up to the Website Font Optimization post I wrote a while back, but it would still be beneficial because sometimes I forget how to properly embed Font Awesome (or any font) in a website even though I've done it correctly before.

I was embedding Font Awesome in a new project I'm working on and I started messing around with CSS rules to get the glyphs to actually display and I was thinking to myself that there should be an easier way to do this. Turns out there is, and I was using that on a different project that I happened to update over the last couple of days and it reminded me how to do it properly.

Follow the instructions from the Website Font Optimization post to get your final WOFF2 font. Base64 encode and embed it into your CSS if you want to, I usually do. Here's the crucial step. By default you would use Font Awesome by writing this: <i class="fa fa-font-awesome-flag"></i>, and you still can with my method, except you would copy the glyph into the content of the <i> tag like: <i class="fa"></i>.

When you read this, it will probably show as a blank space, but the glyph is actually there. Then in your CSS, you would simply write a rule for .fa to have font-family: FontAwesome. This way you don't have to mess around with ::before or ::after rules to fill in the glyph since you're bypassing the usual way to use Font Awesome.

Make sure that when you're optimizing your font that you update the character code because if IcoMoon doesn't recognize it it will generate a new one and the glyphs will not show up. I usually just go into the icon details on Font Awesome's website and copy the code from there. I also use the IcoMoon pre-download page to copy the glyphs out. Here's a more complete example of how I do it.


@font-face {
    font-family: FontAwesome;
    font-display: swap;
    src: url("data:font/woff2;base64,...base64_encoded_font...");

.fa {
    font-family: FontAwesome;
    font-style: normal;


    <i class="fa"></i>
    <span>Font Awesome is awesome!</span>

Hope this helps you, and if nothing else, it will help me to remember in the future how to do it easily.

Review: Michael Vey Book Series

I've been wanting to add non-programming content to my blog a little while now, and now I have something to do so with. It's a little late since I finished the series a few weeks ago, but I wanted to do a short review of the Michael Vey series of books by Richard Paul Evans.

I originally learned about the series when Mr. Evans did an interview with Glenn Beck years ago when he was releasing the first book, Michael Vey: The Prisoner of Cell 25. I purchased the book, read a few of the beginning parts, and then I put it on my bookshelf. I didn't dislike the book, but it was a little slow in the beginning and I just had quite a bit going on at the time in real life and couldn't dedicate the time to read it.

Then, about January of this year (2019 as I'm writing this), I decided to start listening to audio books while I'm driving since I spend an hour each way to and from work. I actually started out with a different series, which I might review as well, but when I finished it I decided to start the Michael Vey series again.

Like the first time when I was reading the physical book, the beginning was a little slow, but eventually, it picked up the pace and never slowed down. I'm not going to spoil anything from the books because I really enjoyed the story and would like you to as well.

There are many emotions throughout the story from anger to happiness, sadness, and sorrow to satisfaction. A sad moment occurred around the middle of the series and I got quite teary eyed. Other times I wanted to slap the main character for falling into the psychological traps of the villain.

I did learn quite a bit from the books though and have found myself using that knowledge in day-to-day conversations. There's a very satisfying feeling when that happens.

Overall, I consider this one of my favorite book series and my only sadness is that it's over. I highly recommend reading the books or listening to the audiobooks. The audiobooks themselves were very well done. I would be very happy if this was made into a TV series since there's too much to fit into a movie series.

You can purchase the books from Amazon or the audiobooks from Audible (of course, from other retailers as well).

Projection-Result Pattern: Improving on the Projection-View Pattern...

If you haven't already, I would recommend you read through my original post on the Projection-View Pattern first even though this post is technically a prequel to it. While that pattern is still fine, and I still continue to use it and I will not be changing that, I found myself wanting to use it in non-view workloads.

Specifically, in my project at work, I have quite a lot of code that needs to project data out of the database and transform it, but it never returns a view to the screen. It might be sending off an email, or generating a file, outputting JSON, or something else entirely.

I used to just adapt to what I needed at the time and inline my projections, but it felt highly disconnected considering I had been using the Projection-View Pattern with great results and success for my views. Then it kind of hit me that the view was nothing more than a result of the projection, and the result could be anything, not just a view.

So, I decided to step back a moment and after some more thought and tinkering, I settled on a base pattern that I've dubbed the Projection-Result Pattern. You're amazed at my naming skills, I know...

Also, since the original post for the Projection-View Pattern, I've changed up how I use MediatR, and I now implement IRequestHandler<TRequest, TResponse> instead of HandlerBase<TRequest, TResponse>. I'll show the entire stack of base classes as I am currently using them:

  • AsyncHandlerBase<TRequest> is a simple handler that doesn't return a result.
  • AsyncHandlerBase<TRequest, TResponse> is a simple handler that does return a result.
  • AsyncProjectionHandlerBase<TRequest, TProjection, TResult> is a slightly more complex handler that does data projection and returns a result.
  • QueryHandlerBase<TQuery, TProjection, TView> is an optional handler, but it has its place when I'm returning views. As I'm writing this I'm starting to think that maybe it should be called something different like ViewHandlerBase<TQuery, TProjection, TView> to express it's intent more clearly, but I'll have to sleep on it for a bit.

Now let's look at the code for each of them. For the purpose of the example, we'll pretend there's a DbContext class called MyDbContext that's being injected. Of course, you may not need to inject anything or you just want to use the built-in handler base classes, and that's perfectly fine, I'm just showcasing how I've decided to use MediatR.


public abstract class AsyncHandlerBase<TRequest> :
    where TRequest : IRequest {
    protected MyDbContext Context { get; }
    protected IMapper Mapper { get; }

    protected AsyncHandlerBase(
        MyDbContext context,
        IMapper mapper) {
        Context = context;
        Mapper = mapper;

    public abstract Task<Unit> Handle(
        TRequest request,
        CancellationToken cancellationToken = default);

AsyncHandlerBase<TRequest, TResponse>

The AsyncHandlerBase<TRequest, TResponse> class has an additional property called MapperConfig which I pass to the .ProjectTo<T>() AutoMapper extension methods when I need to. It's slightly less typing than the full Mapper.ConfigurationProvider everywhere. You can remove it if you don't like it or want it.

While I've debated on putting the MapperConfig property in the AsyncProjectionHandlerBase<TRequest, TProjection, TResult> class only, I decided against it because you may end up using the projection extension methods in a class inheriting from this one as well.

public abstract class AsyncHandlerBase<TRequest, TResponse> :
    IRequestHandler<TRequest, TResponse>
    where TRequest : IRequest<TResponse> {
    protected MyDbContext Context { get; }
    protected IMapper Mapper { get; }

    protected IConfigurationProvider MapperConfig => Mapper.ConfigurationProvider;

    protected AsyncHandlerBase(
        MyDbContext context,
        IMapper mapper) {
        Context = context;
        Mapper = mapper;

    public abstract Task<TResponse> Handle(
        TRequest request,
        CancellationToken cancellationToken = default);

AsyncProjectionHandlerBase<TRequest, TProjection, TResult>

public abstract class AsyncProjectionHandlerBase<TRequest, TProjection, TResult> :
    AsyncHandlerBase<TRequest, TResult>
    where TRequest : IRequest<TResult>
    where TProjection : class, new()
    where TResult : class {
    protected AsyncProjectionHandlerBase(
        MyDbContext context,
        IMapper mapper)
        : base(context, mapper) {

    public override Task<TResult> Handle(
        TRequest request,
        CancellationToken cancellationToken = default) {
        var result = GetResult(request);

        return Task.FromResult(result);

    protected virtual TProjection GetProjection(
        TRequest request) {
        return new TProjection();

    protected virtual TResult GetResult(
        TRequest request) {
        var projection = GetProjection(request);
        var result = Mapper.Map<TResult>(projection);

        NormalizeResult(request, projection, result);

        return result;

    protected virtual void NormalizeResult(
        TRequest request,
        TProjection projection,
        TResult result) {

QueryHandlerBase<TQuery, TProjection, TView>

Lastly, we have the QueryHandlerBase<TQuery, TProjection, TView> class, which is optional, but I've found it useful since I only use it to return views and I usually need to have access to the user identity. In this example, I'm also injecting the IdentityProvider from my Arex388.AspNetCore NuGet package. I also constrain the TProjection and TView parameters to inherit from the ProjectionBase and ViewBase base classes.

public abstract class QueryHandlerBase<TQuery, TProjection, TView> :
    AsyncProjectionHandlerBase<TQuery, TProjection, TView>
    where TQuery : IRequest<TView>
    where TProjection : ProjectionBase, new()
    where TView : ViewBase {
    protected IdentityProvider Identity { get; }

    protected QueryHandlerBase(
        MyDbContext context,
        IMapper mapper,
        IdentityProvider identity) => Identity = identity;


With all of that code, I'm wrapping up this post. Really, the Projection-Result Pattern should be thought of as a generic version of the Projection-View Pattern, but it doesn't replace it. Both patterns have their places and use. The Projection-View Pattern simply specializes the Projection-Result Pattern when dealing with returning views to the user.

I hope either pattern will help someone in their coding, they've surely helped me in improving my data access as well as standardizing on a common coding pattern. Between the two patterns, I probably have about 250 or more classes that inherit from them in my work's project.

Arex388.AspNetCore 1.0.18 Released

I've been adding new functionality to the Arex388.AspNetCore package since the last post, and have published a new update. Rather than rehashing what I already wrote in the README on the GitHub repository, I'll just direct you there. I'm happy to say that it's coming along nicely and it lets me learn how to do more things with ASP.NET Core.