Partagez des contrôleurs, des vues, des pages Razor et bien plus encore avec des composants d’application

Par Rick Anderson

Affichez ou téléchargez l’exemple de code (procédure de téléchargement)

Un composant d’application est une abstraction des ressources d’une application. Les composants d’application permettent aux ASP.NET Core de découvrir les contrôleurs, les composants d’affichage, les tag helpers, les pages Razor, les sources de compilation razor, etc. AssemblyPart est un composant d’application. AssemblyPart encapsule une référence d’assembly et exposer les types et les références de compilation.

Les fournisseurs de fonctionnalités utilisent les composants d’application pour remplir les fonctionnalités d’une application ASP.NET Core. Le cas d’usage principal des composants d’application est la configuration d’une application pour découvrir (ou éviter de charger) les fonctionnalités ASP.NET Core d’un assembly. Par exemple, vous pouvez partager des fonctionnalités communes entre plusieurs applications. À l’aide de composants d’application, vous pouvez partager un assembly (DLL) contenant des contrôleurs, des vues, des pages Razor, des sources de compilation razor, des Tag Helpers, etc. avec plusieurs applications. Le partage d’un assembly est préférable à la duplication du code dans plusieurs projets.

Les applications ASP.NET Core chargent les fonctionnalités à partir de ApplicationPart. La classe AssemblyPart représente un composant d’application qui s’appuie sur un assembly.

Charger les fonctionnalités ASP.NET Core

Utilisez les classes Microsoft.AspNetCore.Mvc.ApplicationParts et AssemblyPart pour découvrir et charger les fonctionnalités ASP.NET Core (contrôleurs, composants d’affichage, etc.). Le ApplicationPartManager suit les composants d’application et les fournisseurs de fonctionnalités disponibles. ApplicationPartManager est configuré dans Startup.ConfigureServices :

// Requires using System.Reflection;
public void ConfigureServices(IServiceCollection services)
{
    var assembly = typeof(MySharedController).Assembly;
    services.AddControllersWithViews()
        .AddApplicationPart(assembly)
        .AddRazorRuntimeCompilation();

    services.Configure<MvcRazorRuntimeCompilationOptions>(options => 
    { options.FileProviders.Add(new EmbeddedFileProvider(assembly)); });
}

Le code suivant fournit une autre approche pour configurer ApplicationPartManager à l’aide de AssemblyPart :

// Requires using System.Reflection;
// Requires using Microsoft.AspNetCore.Mvc.ApplicationParts;
public void ConfigureServices(IServiceCollection services)
{
    var assembly = typeof(MySharedController).Assembly;
    // This creates an AssemblyPart, but does not create any related parts for items such as views.
    var part = new AssemblyPart(assembly);
    services.AddControllersWithViews()
        .ConfigureApplicationPartManager(apm => apm.ApplicationParts.Add(part));
}

Les deux exemples de code précédents chargent le SharedController à partir d’un assembly. Le SharedController n’est pas dans le projet de l’application. Consultez le téléchargement de l’exemple de solution WebAppParts.

Inclure des vues

Utilisez une Razor bibliothèque de classes pour inclure des vues dans l’assembly.

Empêcher le chargement des ressources

Les composants d’application peuvent être utilisés pour éviter de charger des ressources dans un assembly ou un emplacement particulier. Ajoutez ou supprimez des membres de la collection Microsoft.AspNetCore.Mvc.ApplicationParts pour masquer ou rendre des ressources disponibles. L’ordre des entrées dans la collection ApplicationParts n’est pas important. Configurez ApplicationPartManager avant de l’utiliser pour configurer les services dans le conteneur. Par exemple, configurez ApplicationPartManager avant d’appeler AddControllersAsServices. Appelez Remove sur la collection ApplicationParts pour supprimer une ressource.

Le ApplicationPartManager inclut des composants pour :

• Assembly de l’application et assemblys dépendants.
• Microsoft.AspNetCore.Mvc.ApplicationParts.CompiledRazorAssemblyPart
• Microsoft.AspNetCore.Mvc.Razor.RuntimeCompilation
• Microsoft.AspNetCore.Mvc.TagHelpers.
• Microsoft.AspNetCore.Mvc.Razor.

Fournisseurs de fonctionnalités

Les fournisseurs de fonctionnalités d’application examinent les composants d’application et fournissent des fonctionnalités pour ces composants. Il existe des fournisseurs de fonctionnalités intégrés pour les fonctionnalités ASP.NET Core suivantes :

• ControllerFeatureProvider
• TagHelperFeatureProvider
• MetadataReferenceFeatureProvider
• ViewsFeatureProvider
• internal classRazorCompiledItemFeatureProvider

Les fournisseurs de fonctionnalités héritent de IApplicationFeatureProvider<TFeature>, où T correspond au type de la fonctionnalité. Les fournisseurs de fonctionnalités peuvent être implémentés pour tous les types de fonctionnalités précédemment répertoriés. L’ordre des fournisseurs de fonctionnalités dans ApplicationPartManager.FeatureProviders peut avoir un impact sur le comportement au moment de l’exécution. Les fournisseurs ajoutés ultérieurement peuvent réagir aux actions effectuées par des fournisseurs ajoutés précédemment.

Afficher les fonctionnalités disponibles

Les fonctionnalités disponibles pour une application peuvent être énumérées en demandant un ApplicationPartManager par le biais de l’injection de dépendances :

using AppPartsSample.ViewModels;
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Mvc.ApplicationParts;
using Microsoft.AspNetCore.Mvc.Controllers;
using System.Linq;
using Microsoft.AspNetCore.Mvc.Razor.Compilation;
using Microsoft.AspNetCore.Mvc.Razor.TagHelpers;
using Microsoft.AspNetCore.Mvc.ViewComponents;

namespace AppPartsSample.Controllers
{
    public class FeaturesController : Controller
    {
        private readonly ApplicationPartManager _partManager;

        public FeaturesController(ApplicationPartManager partManager)
        {
            _partManager = partManager;
        }

        public IActionResult Index()
        {
            var viewModel = new FeaturesViewModel();

            var controllerFeature = new ControllerFeature();
            _partManager.PopulateFeature(controllerFeature);
            viewModel.Controllers = controllerFeature.Controllers.ToList();

            var tagHelperFeature = new TagHelperFeature();
            _partManager.PopulateFeature(tagHelperFeature);
            viewModel.TagHelpers = tagHelperFeature.TagHelpers.ToList();

            var viewComponentFeature = new ViewComponentFeature();
            _partManager.PopulateFeature(viewComponentFeature);
            viewModel.ViewComponents = viewComponentFeature.ViewComponents.ToList();

            return View(viewModel);
        }
    }
}

L’exemple de téléchargement utilise le code précédent pour afficher les fonctionnalités de l’application :

Controllers:
    - FeaturesController
    - HomeController
    - HelloController
    - GenericController`1
    - GenericController`1
Tag Helpers:
    - PrerenderTagHelper
    - AnchorTagHelper
    - CacheTagHelper
    - DistributedCacheTagHelper
    - EnvironmentTagHelper
    - Additional Tag Helpers omitted for brevity.
View Components:
    - SampleViewComponent

Découverte dans les composants d’application

Les erreurs HTTP 404 ne sont pas rares lors du développement avec des composants d’application. Ces erreurs sont généralement causées par l’absence d’une exigence essentielle concernant la manière dont les composants d’applications sont découverts. Si votre application retourne une erreur HTTP 404, vérifiez que les conditions suivantes sont remplies :

• Le paramètre applicationName doit être défini sur l’assembly racine utilisé pour la découverte. L’assembly racine utilisé pour la découverte est normalement l’assembly de point d’entrée.
• L’assembly racine doit avoir une référence aux parties utilisées pour la découverte. La référence peut être directe ou transitive.
• L’assembly racine doit référencer le Kit de développement logiciel (SDK) web. L’infrastructure a une logique qui marque les attributs dans l’assembly racine qui sont utilisés pour la découverte.