Arex388.OpenWeatherMap 1.0.0 Released

I've started a very complicated update for the project at my work and it had a requirement to get the current weather conditions (specifically temperature and humidity) for a geocoordinate point. I settled on using the OpenWeatherMap API because it provided what I needed and the free account allows for more than enough daily usage for my needs.

I looked at what was available on NuGet, but the packages available were years out of date and I didn't like having to rely on potentially abandoned packages. So, in the spirit of all the other API clients I've made so far, I rolled my own package: Arex388.OpenWeatherMap. Since I only needed the current weather conditions for a geocoordinate point, I only implemented that functionality, but if there's demand for more I'll expand the functionality. NuGet is available here.

Arex388.Extensions.CsvHelper 1.0.1 Released

The Arex388.Extensions.CsvHelper package has been updated to 1.0.1. This is a minor update that does a simple check if the contents of a CsvDbSet<T> have changed by summing their hash codes. If the hash code hasn't changed then the call to Save() will return early.

Since this blog is now backed by this package I've noticed that the CSV files are always being updated on the server regardless if there was changes or not. This was caused by the Save() method always running because the CSV file that tracks visits to a post is always changing. With this update I'm hoping that only it will be getting updated instead of everything.

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 account's permissions.

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.

Arex388.Geocodio 1.2.2 Released

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

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>. Here's 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. I slept on it and I've accepted it, so it is now called ViewHandlerBase.

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) => 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.SunriseSunset 1.0.0 Released

I'm starting a new project, and it has a requirement to be able to pull the sunset time for each day. I looked around a bit for an API and found that sunrise-sunset.org has such an API.

I figured I might as well add to my collection of API clients, so I made a C# client for it. It's called Arex388.SunriseSunset, as you might have guessed by now.

The source code is available on GitHub, and a package is available on NuGet.

Arex388.Geocodio 1.2.0 Released

This update includes backwards compatibility support. The GeocodioClient now accepts a third argument for the endpoint version. By default the client will always use the latest version, but it can be changed using the new EndpointVersions constant.

Arex388.Geocodio 1.1.0 Released

This update includes full support for all fields and their return values. Originally, I had implemented the lookup for fields, but I omitted the return values for some reason. Since Geocodio had an update to the fields I decided to rectify this omission. Please be aware that field lookups will result in additional charges from Geocodio.