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(...)"));
}