define the api version when using generic controllers

Hi,

i am currently working on a webapi that will work with generic controllers. Plugin can be loaded into the webapi and these will be served by these generic controllers. This works all just fine...
I am using swagger for the documentation of the api

If i want to have versioning on the models/plugins i need to have controllers with the api attribute set accordingly. i can get that part working. I need to change the typeinfo of the controller in order to have swagger generate the documents with the versions.
Is there a way to set the controller version when using a generic controller?

i am using dotnet core 2.1

using Microsoft.AspNetCore.Mvc;
using System.Collections.Generic;

namespace WebApiPluginDemo.Controllers
{
    [Route("api/[controller]")]
    [ApiVersion("0.1")]  // should be dynamic depending on the type version
    public class BaseController<T, K> : Controller where T : class
    {
        private Storage<T> _storage;

        public BaseController(Storage<T> storage)
        {

            _storage = storage;
        }

        [HttpGet()]
        public IEnumerable<T> Get()
        {

            return _storage.GetAll();
        }

        [HttpGet("{id}")]
        public IActionResult Get(K id)
        {
            var result = _storage.GetById(id.ToString());
            if (result != null) { return Ok(result); }
            else
            {
                return NotFound();
            }
        }

        [HttpPost("{id}")]
        [ProducesResponseType(201)]
        [ProducesResponseType(400)]
        public IActionResult Post(K id, [FromBody]T value)
        {
            _storage.Add(id.ToString(), value);
            return Created("", "");
        }
    }
}

loading the controllers

    public class PluginFeatureProvider : IApplicationFeatureProvider<ControllerFeature>
    {
        private ControllerFeature feature;

        public void PopulateFeature(IEnumerable<ApplicationPart> parts, ControllerFeature feature)
        {
            this.feature = feature;
            DisablePreviousLoadedPlugins();
            ProcessAllPluginsInDirectory();
        }

which enables me to load the controller like so

feature.Controllers.Add(controllerType.MakeGenericType(new Type[] { item, keytype }).GetTypeInfo());

kind regards,

Frans

[commonsensesoftware]

As a matter of fact … you can! :)

This type of extension scenario was one of the primary use cases that drove support for conventions. Plug-ins and/or extension may not be changeable, you might not have control of the source, or you simply don't want to add the required dependencies to the extensions.

You'll obviously have to provide your own mechanism to configure extensions, but the hooks are there. You can build things up with the existing convention support or, starting in 3.0+, you are able to author your own custom conventions. For example, you might have your own attribute or other convention which indicates the API version for an entire assembly.

The setup might look something like:

services.AddApiVersioning( options =>
{
  var controllerTypes = ResolveExtensionControllers();

  foreach ( var controllerType in controllerTypes )
  {
     var apiVersion = controllerType.GetApiVersion(); // your magic extension method

     options.Conventions.Controller( controllerType ).HasApiVersion( apiVersion );
  }
} );

The wiki contains more details and examples of using conventions.

I hope that gets you going in the right direction.

Hey Chris,

Thanks for the response. I will give this a go. I am wondering if this would work with generic controllers. I suppose I have to provide the generic type on this line

options.Conventions.Controller(controllerType.MakeGenericType(new Type[] { modeltype, keytype })).HasApiVersion( apiVersion );

i will let you know if I can manage it to work.

[commonsensesoftware]

The API is compatible with any instance of Type. Generic types are fine as long as the are closed. The Type you apply the convention to must be the same type that executes. As long as those two match up, it should work just fine.

[commonsensesoftware]

Looks like you're on your way. If you have any more questions or get stuck, feel free to ask. You shouldn't have any issues mapping closed generics the way you've shown. Thanks.