Comment rendre une vue ASP.NET MVC sous forme de chaîne de caractères ?

Question

Je veux produire deux vues différentes (l'une sous la forme d'une chaîne qui sera envoyée par courriel), et l'autre sous la forme de la page affichée à un utilisateur.

Est-ce possible dans ASP.NET MVC beta ?

J'ai essayé plusieurs exemples :

1. RenderPartial vers String en ASP.NET MVC Beta

Si j'utilise cet exemple, je reçois le message "Cannot redirect after HTTP ont été envoyés".

2. Cadre MVC : Capturer la sortie d'une vue

Si je l'utilise, il semble que je ne puisse pas faire de redirectToAction, car elle tente de rendre une vue qui peut ne pas exister. tente de rendre une vue qui n'existe peut-être pas. Si je renvoie la vue, elle est est complètement désordonnée et n'a pas du tout l'air correcte.

Est-ce que quelqu'un a des idées/solutions à ces problèmes que j'ai, ou a des suggestions pour de meilleures solutions ?

Merci beaucoup !

Vous trouverez ci-dessous un exemple. Ce que j'essaie de faire, c'est de créer l'élément Méthode GetViewForEmail :

public ActionResult OrderResult(string ref)
{
    //Get the order
    Order order = OrderService.GetOrder(ref);

    //The email helper would do the meat and veg by getting the view as a string
    //Pass the control name (OrderResultEmail) and the model (order)
    string emailView = GetViewForEmail("OrderResultEmail", order);

    //Email the order out
    EmailHelper(order, emailView);
    return View("OrderResult", order);
}

Réponse acceptée de Tim Scott (modifiée et formatée un peu par moi) :

public virtual string RenderViewToString(
    ControllerContext controllerContext,
    string viewPath,
    string masterPath,
    ViewDataDictionary viewData,
    TempDataDictionary tempData)
{
    Stream filter = null;
    ViewPage viewPage = new ViewPage();

    //Right, create our view
    viewPage.ViewContext = new ViewContext(controllerContext, new WebFormView(viewPath, masterPath), viewData, tempData);

    //Get the response context, flush it and get the response filter.
    var response = viewPage.ViewContext.HttpContext.Response;
    response.Flush();
    var oldFilter = response.Filter;

    try
    {
        //Put a new filter into the response
        filter = new MemoryStream();
        response.Filter = filter;

        //Now render the view into the memorystream and flush the response
        viewPage.ViewContext.View.Render(viewPage.ViewContext, viewPage.ViewContext.HttpContext.Response.Output);
        response.Flush();

        //Now read the rendered view.
        filter.Position = 0;
        var reader = new StreamReader(filter, response.ContentEncoding);
        return reader.ReadToEnd();
    }
    finally
    {
        //Clean up.
        if (filter != null)
        {
            filter.Dispose();
        }

        //Now replace the response filter
        response.Filter = oldFilter;
    }
}

Exemple d'utilisation

Supposons un appel du contrôleur pour obtenir l'email de confirmation de la commande, en passant l'emplacement Site.Master.

string myString = RenderViewToString(this.ControllerContext, "~/Views/Order/OrderResultEmail.aspx", "~/Views/Shared/Site.Master", this.ViewData, this.TempData);

Answer 1

Voici ce que j'ai trouvé, et ça marche pour moi. J'ai ajouté la ou les méthodes suivantes à la classe de base de mon contrôleur. (Vous pouvez toujours créer ces méthodes statiques ailleurs qui acceptent un contrôleur comme paramètre je suppose)

Style MVC2 .ascx

protected string RenderViewToString<T>(string viewPath, T model) {
  ViewData.Model = model;
  using (var writer = new StringWriter()) {
    var view = new WebFormView(ControllerContext, viewPath);
    var vdd = new ViewDataDictionary<T>(model);
    var viewCxt = new ViewContext(ControllerContext, view, vdd,
                                new TempDataDictionary(), writer);
    viewCxt.View.Render(viewCxt, writer);
    return writer.ToString();
  }
}

Style Razor .cshtml

public string RenderRazorViewToString(string viewName, object model)
{
  ViewData.Model = model;
  using (var sw = new StringWriter())
  {
    var viewResult = ViewEngines.Engines.FindPartialView(ControllerContext,
                                                             viewName);
    var viewContext = new ViewContext(ControllerContext, viewResult.View,
                                 ViewData, TempData, sw);
    viewResult.View.Render(viewContext, sw);
    viewResult.ViewEngine.ReleaseView(ControllerContext, viewResult.View);
    return sw.GetStringBuilder().ToString();
  }
}

Edit : ajouté le code Razor.

Answer 2

Cette réponse n'est pas sur mon chemin . Elle provient de https://stackoverflow.com/a/2759898/2318354 mais ici j'ai montré comment l'utiliser avec le mot clé "Static" pour le rendre commun à tous les contrôleurs.

Pour cela, vous devez faire static dans le fichier de classe . (Supposons que le nom de votre fichier de classe est Utils.cs )

Cet exemple est pour Razor.

Utils.cs

public static class RazorViewToString
{
    public static string RenderRazorViewToString(this Controller controller, string viewName, object model)
    {
        controller.ViewData.Model = model;
        using (var sw = new StringWriter())
        {
            var viewResult = ViewEngines.Engines.FindPartialView(controller.ControllerContext, viewName);
            var viewContext = new ViewContext(controller.ControllerContext, viewResult.View, controller.ViewData, controller.TempData, sw);
            viewResult.View.Render(viewContext, sw);
            viewResult.ViewEngine.ReleaseView(controller.ControllerContext, viewResult.View);
            return sw.GetStringBuilder().ToString();
        }
    }
}

Maintenant vous pouvez appeler cette classe à partir de votre contrôleur en ajoutant le NameSpace dans votre fichier de contrôleur de la manière suivante en passant "this" comme paramètre au contrôleur.

string result = RazorViewToString.RenderRazorViewToString(this ,"ViewName", model);

Comme suggéré par @Sergey, cette méthode d'extension peut également être appelée par le cotroller comme indiqué ci-dessous.

string result = this.RenderRazorViewToString("ViewName", model);

J'espère que cela vous sera utile pour rendre le code propre et soigné.

Answer 3

Cela fonctionne pour moi :

public virtual string RenderView(ViewContext viewContext)
{
    var response = viewContext.HttpContext.Response;
    response.Flush();
    var oldFilter = response.Filter;
    Stream filter = null;
    try
    {
        filter = new MemoryStream();
        response.Filter = filter;
        viewContext.View.Render(viewContext, viewContext.HttpContext.Response.Output);
        response.Flush();
        filter.Position = 0;
        var reader = new StreamReader(filter, response.ContentEncoding);
        return reader.ReadToEnd();
    }
    finally
    {
        if (filter != null)
        {
            filter.Dispose();
        }
        response.Filter = oldFilter;
    }
}

Answer 4

J'ai trouvé une nouvelle solution qui rend une vue en chaîne de caractères sans avoir à s'occuper du flux de réponse du HttpContext actuel (qui ne vous permet pas de changer le ContentType de la réponse ou d'autres en-têtes).

En gros, tout ce que vous faites, c'est créer un faux HttpContext pour que la vue se rende elle-même :

/// <summary>Renders a view to string.</summary>
public static string RenderViewToString(this Controller controller,
                                        string viewName, object viewData) {
    //Create memory writer
    var sb = new StringBuilder();
    var memWriter = new StringWriter(sb);

    //Create fake http context to render the view
    var fakeResponse = new HttpResponse(memWriter);
    var fakeContext = new HttpContext(HttpContext.Current.Request, fakeResponse);
    var fakeControllerContext = new ControllerContext(
        new HttpContextWrapper(fakeContext),
        controller.ControllerContext.RouteData,
        controller.ControllerContext.Controller);

    var oldContext = HttpContext.Current;
    HttpContext.Current = fakeContext;

    //Use HtmlHelper to render partial view to fake context
    var html = new HtmlHelper(new ViewContext(fakeControllerContext,
        new FakeView(), new ViewDataDictionary(), new TempDataDictionary()),
        new ViewPage());
    html.RenderPartial(viewName, viewData);

    //Restore context
    HttpContext.Current = oldContext;    

    //Flush memory and return output
    memWriter.Flush();
    return sb.ToString();
}

/// <summary>Fake IView implementation used to instantiate an HtmlHelper.</summary>
public class FakeView : IView {
    #region IView Members

    public void Render(ViewContext viewContext, System.IO.TextWriter writer) {
        throw new NotImplementedException();
    }

    #endregion
}

Cela fonctionne avec ASP.NET MVC 1.0, ainsi qu'avec ContentResult, JsonResult, etc. (la modification des en-têtes de la réponse HttpResponse originale n'entraîne pas l'erreur " Le serveur ne peut pas définir le type de contenu après l'envoi des en-têtes HTTP. ").

Mise à jour : dans ASP.NET MVC 2.0 RC, le code change un peu parce que nous devons passer dans l'élément StringWriter utilisé pour écrire la vue dans le ViewContext :

//...

//Use HtmlHelper to render partial view to fake context
var html = new HtmlHelper(
    new ViewContext(fakeControllerContext, new FakeView(),
        new ViewDataDictionary(), new TempDataDictionary(), memWriter),
    new ViewPage());
html.RenderPartial(viewName, viewData);

//...

Answer 5

Si vous voulez renoncer entièrement à MVC, évitant ainsi tout le désordre de HttpContext...

using RazorEngine;
using RazorEngine.Templating; // For extension methods.

string razorText = System.IO.File.ReadAllText(razorTemplateFileLocation);
string emailBody = Engine.Razor.RunCompile(razorText, "templateKey", typeof(Model), model);

Il utilise l'impressionnant moteur open source Razor Engine : https://github.com/Antaris/RazorEngine