Best practice for ensuring calls to both Add* and Use*

[ThomasArdal]

I'm looking to improve a middleware NuGet package I have created. Like many other middleware implementations, my package needs both an AddX and an UseX call:

public void ConfigureServices(IServiceCollection services) { services.AddX(); } public void Configure(IApplicationBuilder app) { app.UseX(); }

AddX register a number of dependencies with dependency injection.

What I'm trying to improve here is that I see a number of users who forget to call the AddX method. This will result in a runtime error when ASP.NET Core tries to create an instance of my middleware class (expected). At this time it's too late to tell the user that this is because of a missing call to AddX, though.

What I'm thinking is to include code like this in my UseX method:

var dependency = app.ApplicationServices.GetService<IMyDependency>(); if (dependency == null) throw new Exception("Make sure to call the AddX method"); return app.UseMiddleware<MyMiddleware>();

This will make the code fail in the UseX method and give the user a hint to what to fix.

I cannot seem to find any documentation around this. Is this a good solution? Does it introduce some other problems? Any special exception types that I need to be aware of here that means something in terms of setting up middleware with ASP.NET Core?

[Tratcher]

MVC does something similar.

[ThomasArdal]

That's a good hint. For anyone interested, MVC does this:

// Verify if AddMvc was done before calling UseMvc // We use the MvcMarkerService to make sure if all the services were added. if (app.ApplicationServices.GetService(typeof(MvcMarkerService)) == null) { throw new InvalidOperationException(Resources.FormatUnableToFindServices( nameof(IServiceCollection), "AddMvc", "ConfigureServices(...)")); }