Comment rendre les vues sous forme de chaînes dans ASP.NET Core ?

Rendu des vues sous forme de chaînes dans .NET Core

Dans ASP.NET Core, le rendu des vues sous forme de chaînes est une fonctionnalité cruciale souvent requise pour des scénarios tels que la création de rapports et la génération de contenu dynamique. , ou des tests. Cet article vous guidera tout au long du processus pour y parvenir dans .NET Core, en traitant du problème spécifique rencontré lors de la conversion du code existant d'ASP.NET vers .NET Core.

Utilisation des extensions de contrôleur pour le rendu des vues

Pour afficher les vues sous forme de chaînes dans .NET Core, une approche efficace consiste à créer une méthode d'extension de contrôleur. Cette méthode constitue un moyen pratique d’accéder aux vues et de les restituer à partir de n’importe quel contrôleur de votre application. Voici un exemple d'implémentation :

using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Mvc.Rendering;
using Microsoft.AspNetCore.Mvc.ViewEngines;
using Microsoft.AspNetCore.Mvc.ViewFeatures;
using System.IO;
using System.Threading.Tasks;

namespace CoreApp.Helpers
{
    public static class ControllerExtensions
    {
        public static async Task<string> RenderViewAsync<TModel>(this Controller controller, string viewName, TModel model, bool partial = false)
        {
            // Handle missing view name
            if (string.IsNullOrEmpty(viewName))
            {
                viewName = controller.ControllerContext.ActionDescriptor.ActionName;
            }

            // Set the view data
            controller.ViewData.Model = model;

            using (var writer = new StringWriter())
            {
                // Obtain the view engine
                IViewEngine viewEngine = controller.HttpContext.RequestServices.GetService(typeof(ICompositeViewEngine)) as ICompositeViewEngine;

                // Find the view
                ViewEngineResult viewResult = viewEngine.FindView(controller.ControllerContext, viewName, !partial);

                // View not found
                if (viewResult.Success == false)
                {
                    return $"A view with the name {viewName} could not be found";
                }

                // Render the view
                ViewContext viewContext = new ViewContext(
                    controller.ControllerContext,
                    viewResult.View,
                    controller.ViewData,
                    controller.TempData,
                    writer,
                    new HtmlHelperOptions()
                );

                await viewResult.View.RenderAsync(viewContext);

                // Return the rendered view as a string
                return writer.GetStringBuilder().ToString();
            }
        }
    }
}

Utilisation de la méthode d'extension

Pour utiliser la méthode d'extension, ajoutez simplement le code suivant à votre contrôleur :

var viewHtml = await this.RenderViewAsync("Report", model);

Pour le rendu une vue partielle :

var partialViewHtml = await this.RenderViewAsync("Report", model, true);

Améliorations par rapport au code d'origine

La méthode d'extension fournie comprend plusieurs améliorations par rapport au code original :

• Saisie forte pour le modèle
• Erreur de vérification de la vue introuvable
• Possibilité de restituer à la fois les vues et les vues partielles
• Exécution asynchrone
• Pas d'injection de dépendances ni de services supplémentaires requis

En utilisant cette approche, vous pouvez facilement restituer et accéder aux vues sous forme de chaînes dans .NET Core, offrant ainsi une flexibilité pour divers scénarios dans lesquels la génération de contenu dynamique est nécessaire.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!