How to register api controller from a library with configuration

Question

What I have done is created a small API in a class library. This API would be used by other sites. Think of it as a standard endpoint that all of our websites will contain.

[Route("api/[controller]")]
[ApiController]
public class CustomController : ControllerBase
{
    // GET api/values
    [HttpGet]
    public ActionResult<IEnumerable<string>> Get()
    {
        return new string[] { "value1", "value2" };
    }
}

The above is in a class library. Now what i would like to do is be able to add this to the projects in a simple manner.

app.UseCustomAPI("/api/crap");

I am not exactly sure how i should handle routing to the api controllers in the library. I created a CustomAPIMiddleware which is able to catch that i called "/api/crap" however i am not sure how i should forward the request over to CustomController in the library

public async Task Invoke(HttpContext context)
    {
        if (context == null)
            throw new ArgumentNullException(nameof(context));
        PathString matched;
        PathString remaining;
        if (context.Request.Path.StartsWithSegments(_options.PathMatch, out matched, out remaining))
        {
            PathString path = context.Request.Path;
            PathString pathBase = context.Request.PathBase;
            context.Request.PathBase = pathBase.Add(matched);
            context.Request.Path = remaining;
            try
            {
                await this._options.Branch(context);
            }
            finally
            {
                context.Request.PathBase = pathBase;
                context.Request.Path = path;
            }
            path = new PathString();
            pathBase = new PathString();
        }
        else
            await this._next(context);
    }

After having done that i am starting to think i may have approached this in the wrong manner and should actually be trying to add it directly to the routing tables somehow. That being said i would like it if they could customize the endpoint that the custom controller reads from.

Update

The following does work. Loading and registering API Controllers From Class Library in ASP.NET core

services.AddMvc()
            .SetCompatibilityVersion(CompatibilityVersion.Version_2_1)
            .AddApplicationPart(Assembly.Load(new AssemblyName("WebAPI")));

However i am really looking for a middlewere type solution so that users can simply add it and i can configure the default settings or they can change some of the settings. The above example would not allow for altering the settings.

 app.UseCustomAPI("/api/crap");

Update from comment without Assembly

If i dont add the .AddApplicationPart(Assembly.Load(new AssemblyName("WebAPI")));

This localhost page can’t be found No webpage was found for the web address: https://localhost:44368/api/Custom

Close but its a bit cumbersome and doesn't allow for configuration. — Linda Lawton - DaImTo
– Linda Lawton - DaImTo, Commented Mar 20, 2019 at 11:35
According to the docs: "By default MVC will search the dependency tree and find controllers (even in other assemblies).". I realise it's secondary to the main question now, but you shouldn't need to use an application-part for this if the hosting project references the WebAPI assembly shown. — Kirk Larkin
– Kirk Larkin, Commented Mar 20, 2019 at 11:44
@KirkLarkin what i want to do is allow the users to change the endpoint. So that they are not stuck with api/custom and could change it to api/crap if they like — Linda Lawton - DaImTo
– Linda Lawton - DaImTo, Commented Mar 20, 2019 at 11:46

Kirk Larkin · Accepted Answer · 2022-01-20 12:12:34Z

To customise the routing for a controller at runtime, you can use an Application Model Convention. This can be achieved with a custom implementation of IControllerModelConvention:

public class CustomControllerConvention : IControllerModelConvention
{
    private readonly string newEndpoint;

    public CustomControllerConvention(string newEndpoint)
    {
        this.newEndpoint = newEndpoint;
    }

    public void Apply(ControllerModel controllerModel)
    {
        if (controllerModel.ControllerType.AsType() != typeof(CustomController))
            return;

        foreach (var selectorModel in controllerModel.Selectors)
            selectorModel.AttributeRouteModel.Template = newEndpoint;
    }
}

This example just replaces the existing template (api/[controller]) with whatever is provided in the CustomControllerConvention constructor. The next step is to register this new convention, which can be done via the call to AddMvc. Here's an example of how that works:

services.AddMvc(o =>
{
    o.Conventions.Add(new CustomControllerConvention("api/whatever"));
});

That's all that's needed to make things work here, but as you're offering this up from another assembly, I'd suggest an extension method based approach. Here's an example of that:

public static class MvcBuilderExtensions
{
    public static IMvcBuilder SetCustomControllerRoute(
        this IMvcBuilder mvcBuilder, string newEndpoint)
    {
        return mvcBuilder.AddMvcOptions(o =>
        {
            o.Conventions.Add(new CustomControllerConvention(newEndpoint));
        });
    }
}

Here's how that would be called:

services.AddMvc()
    .SetCustomControllerRoute("api/whatever");

This whole approach means that without a call to SetCustomControllerRoute, api/Custom will still be used as a default.

Collectives™ on Stack Overflow

How to register api controller from a library with configuration

1 Answer 1

Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

1 Answer 1

Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related