Ce qui se passe par défaut

pendant le processus de découverte du contrôleur, votre Controller<T> la classe sera parmi les types de candidats. Mais le défaut de mise en œuvre de l' IApplicationFeatureProvider<ControllerFeature> interface,DefaultControllerTypeProvider, éliminera votre Controller<T> parce qu'elle exclut toute classe ouverte paramètres génériques.

pourquoi remplacer IsController () ne fonctionne pas

remplace l'implémentation par défaut de IApplicationFeatureProvider<ControllerFeature> interface, afin de remplacer DefaultControllerTypeProvider.IsController(), ne fonctionnera pas. Parce que vous ne voulez pas réellement que le processus de découverte accepte votre contrôleur générique ouvert (Controller<T>) comme contrôleur valide. C'est un controller valide en soi, et l'usine du controller ne saurait pas comment l'instancier de toute façon, parce qu'elle ne saurait pas ce que T est censé être.

Ce qui doit être fait

1. Générer des types de contrôleurs fermés

avant même que le processus de découverte du contrôleur ne commence, vous besoin de générer des types génériques fermés à partir de votre contrôleur open generic, En utilisant la réflexion. Ici, avec deux types d'entités, nommé Account et Contact:

Type[] entityTypes = new[] { typeof(Account), typeof(Contact) };
TypeInfo[] closedControllerTypes = entityTypes
    .Select(et => typeof(Controller<>).MakeGenericType(et))
    .Select(cct => cct.GetTypeInfo())
    .ToArray();

Nous avons maintenant fermé TypeInfosController<Account> et Controller<Contact>.

2. Les ajouter à une partie d'une application, et de l'inscrire

les pièces D'Application sont habituellement enroulées autour des assemblages CLR, mais nous pouvons implémenter une pièce d'application personnalisée en fournissant une collection de types générés à l'exécution. Nous il suffit de le faire implémenter le IApplicationPartTypeProvider interface. Par conséquent, nos types de Controllers générés par l'exécution vont entrer dans le processus de découverte du controller comme tout autre type intégré le ferait.

L'application personnalisée partie:

public class GenericControllerApplicationPart : ApplicationPart, IApplicationPartTypeProvider
{
    public GenericControllerApplicationPart(IEnumerable<TypeInfo> typeInfos)
    {
        Types = typeInfos;
    }

    public override string Name => "GenericController";
    public IEnumerable<TypeInfo> Types { get; }
}

inscription aux services MVC (Startup.cs):

services.AddMvc()
    .ConfigureApplicationPartManager(apm =>
        apm.ApplicationParts.Add(new GenericControllerApplicationPart(closedControllerTypes)));

aussi longtemps que votre controller dérive duController classe, il n'y a pas besoin de remplacer les IsController méthode de l' ControllerFeatureProvider. Parce que votre le contrôleur Générique hérite du [Controller] attribut ControllerBase, il sera accepté comme contrôleur dans le processus de découverte quel que soit son nom quelque peu bizarre ("Controller`1").

3. Remplacer le nom du contrôleur dans le modèle d'application

néanmoins, "Controller' 1 " n'est pas un bon nom à des fins de routage. Vous voulez chacun de vos fermé générique contrôleurs indépendants RouteValues. Ici, nous remplacerons le nom du contrôleur par celui du type d'entité, pour correspondre à ce qui se passerait avec deux types indépendants "AccountController" et "ContactController".

Le modèle de convention de l'attribut:

public class GenericControllerAttribute : Attribute, IControllerModelConvention
{
    public void Apply(ControllerModel controller)
    {
        Type entityType = controller.ControllerType.GetGenericArguments()[0];

        controller.ControllerName = entityType.Name;
    }
}

appliqué à la classe controller:

[GenericController]
public class Controller<T> : Controller
{
}

Conclusion

cette solution reste proche de l'ensemble ASP.NET l'architecture de base et, entre autres choses, vous garderez une visibilité complète de vos contrôleurs à travers L'API Explorer (pensez à "Swagger").

Il a a été testé avec succès avec le routage classique et basé sur les attributs.

les fournisseurs de fonctions d'Application examinent les parties de l'application et fournissent des fonctions pour ces parties. Il existe des fournisseurs de fonctionnalités intégrés pour les fonctionnalités MVC suivantes:

• Contrôleurs
• Référence Des Métadonnées
• Balise Aides
• Voir Les Composants

les fournisseurs de fonctionnalités héritent de IApplicationFeatureProvider, où T est le type de la fonctionnalité. Vous pouvez implémenter vos propres fournisseurs de fonctionnalités pour n'importe laquelle des fonctionnalités de MVC les types énumérés ci-dessus. L'ordre des fournisseurs de fonctionnalités dans L'ApplicationPartManager.La collecte de FeatureProviders peut être importante, car les fournisseurs ultérieurs peuvent réagir aux mesures prises par les fournisseurs précédents.

par défaut, ASP.NET le noyau MVC ignore les controllers génériques (par exemple, SomeController). Cet exemple utilise un fournisseur de fonctions de controller qui court après le fournisseur par défaut et ajoute des instances de controller génériques pour une liste spécifiée de types (définis dans EntityTypes.Les Types):

public class GenericControllerFeatureProvider : IApplicationFeatureProvider<ControllerFeature>
{
    public void PopulateFeature(IEnumerable<ApplicationPart> parts, ControllerFeature feature)
    {
        // This is designed to run after the default ControllerTypeProvider, 
        // so the list of 'real' controllers has already been populated.
        foreach (var entityType in EntityTypes.Types)
        {
            var typeName = entityType.Name + "Controller";
            if (!feature.Controllers.Any(t => t.Name == typeName))
            {
                // There's no 'real' controller for this entity, so add the generic version.
                var controllerType = typeof(GenericController<>)
                    .MakeGenericType(entityType.AsType()).GetTypeInfo();
                feature.Controllers.Add(controllerType);
            }
        }
    }
}

Les types d'entité:

public static class EntityTypes
{
    public static IReadOnlyList<TypeInfo> Types => new List<TypeInfo>()
    {
        typeof(Sprocket).GetTypeInfo(),
        typeof(Widget).GetTypeInfo(),
    };

    public class Sprocket { }
    public class Widget { }
}

le fournisseur de fonctionnalités est ajouté au démarrage:

services.AddMvc()
    .ConfigureApplicationPartManager(p => 
        p.FeatureProviders.Add(new GenericControllerFeatureProvider()));

par défaut, les noms génériques du contrôleur utilisés pour le routage seraient de la forme GenericController`1[Widget] au lieu de Widget. L'attribut suivant est utilisé pour modifier le nom de correspondre au type générique utilisé par le contrôleur:

utilisation de Microsoft.AspNetCore.Mvc.ApplicationModels; utiliser Système;

namespace AppPartsSample
{
    // Used to set the controller name for routing purposes. Without this convention the
    // names would be like 'GenericController`1[Widget]' instead of 'Widget'.
    //
    // Conventions can be applied as attributes or added to MvcOptions.Conventions.
    [AttributeUsage(AttributeTargets.Class, AllowMultiple = false, Inherited = true)]
    public class GenericControllerNameConvention : Attribute, IControllerModelConvention
    {
        public void Apply(ControllerModel controller)
        {
            if (controller.ControllerType.GetGenericTypeDefinition() != 
                typeof(GenericController<>))
            {
                // Not a GenericController, ignore.
                return;
            }

            var entityType = controller.ControllerType.GenericTypeArguments[0];
            controller.ControllerName = entityType.Name;
        }
    }
}

la classe GenericController:

using Microsoft.AspNetCore.Mvc;

namespace AppPartsSample
{
    [GenericControllerNameConvention] // Sets the controller name based on typeof(T).Name
    public class GenericController<T> : Controller
    {
        public IActionResult Index()
        {
            return Content($"Hello from a generic {typeof(T).Name} controller.");
        }
    }
}

Exemple: contrôleur Générique la fonction

pour obtenir une liste des controllers dans RC2, il suffit D'obtenir ApplicationPartManager de DependencyInjection et de faire ceci:

    ApplicationPartManager appManager = <FROM DI>;

    var controllerFeature = new ControllerFeature();
    appManager.PopulateFeature(controllerFeature);

    foreach(var controller in controllerFeature.Controllers)
    {
        ...
    }