.net core routing, understand what application called with a generic route

Question

So what I have is a base controller that the following [Route] definition

[Route("{application}/api/[controller]")]
public class BaseController
{

}

All of my current controllers inherit from BaseController.

What I am trying to achieve is that two different application can call my controllers and my code to be aware of what 'application' is calling it.

Application 1 should be able to call /Application1/Api/MyController
Application 2 should be able to call /Application2/Api/MyController

and both requests should go to the same controller but my code should be aware of which application called it.

I thought about having some sort of Middleware and then work out the application from the Request.Path, and then store it in something like HttpContext.Current.Items but that doesn't seem like the correct way to do it.

Answer 1

My personal preference here would be to pass the value as an HTTP header rather than a route parameter, especially if you want it everywhere. It means you don't need a Route attribute and a different URL per application. Using a custom ActionFilterAttribute, there's a bunch of ways you can pass this detail into your action. For example:

public class ApplicationAttribute : ActionFilterAttribute
{
    public override void OnActionExecuting(ActionExecutingContext context)
    {
        if (context.HttpContext.Request.Headers.TryGetValue("Application", out var values))
        {
            // Method 1: This allows you to specify a parameter on your action
            context.ActionArguments.Add("application", values.First());

            // Method 2: This adds the value into the route data
            context.RouteData.Values.Add("Application", values.First());

            // Method 3: This will set a property on your controller
            if (context.Controller is BaseApplicationController baseController)
            {
                baseController.Application = values.First();
            }
        }

        base.OnActionExecuting(context);
    }
}

And apply it to action methods or your controller:

[Application]
public class FooController : Controller
{
}

Method 1 Usage:

public IActionResult Index(string application)
{
    // do something with the parameter passed in
}

Method 2 Usage:

public IActionResult Index(string application)
{
    var application = (string)RouteData.Values["Application"];
}

Method 3 Usage:

First, create a base controller that contains the property:

public abstract class BaseApplicationController : Controller
{
    public string Application { get; set; }
}

Then make sure your controller inherits from it:

[Application]
public class FooController : BaseApplicationController
{
}

Now you can access the property on your controller:

public IActionResult Index(string application)
{
    var application = this.Application;
}

Bonus Method 4:

As an aside, you could use this method to use the URL route value, using the base controller from method 3, modify the attribute to look like this:

public class ApplicationAttribute : ActionFilterAttribute
{
    public override void OnActionExecuting(ActionExecutingContext context)
    {
        if (context.Controller is BaseApplicationController baseController)
        {
            baseController.Application = (string)context.RouteData.Values["application"];
        }

        base.OnActionExecuting(context);
    }
}

Add a route attribute to your controller:

[Route("{application}/api/[controller]/[action]")]

And now you should have the property value on the controller set.