Wie render eine ASP.NET MVC view als string?

Diese Antwort ist nicht auf meinem Weg . Dieser ist ursprünglich aus https://stackoverflow.com/a/2759898/2318354 aber hier habe ich den Weg zu zeigen, verwenden Sie es mit "Static" Schlüsselwort, um es gemeinsam für alle Regler .

Für die, die Sie haben, um static Klasse in der Klasse Datei . (Angenommen, deine Klasse File Name Utils.cs )

Diesem Beispiel ist Für die 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();
        }
    }
}

Rufen Sie nun diese Klasse von deinem controller durch hinzufügen von NameSpace in einer Controller-Datei als folgende Weise, indem Sie "this" als parameter auf den Controller.

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

Als Anregung gegeben durch @Sergey diese Erweiterung Methode kann auch vom regler wie unten angegeben

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

Ich hoffe, dass dies nützlich sein wird, um Sie den code sauber und ordentlich.

Ich eine neue Lösung gefunden, das macht ein Blick auf string die zimmerreserviereung, ohne das Durcheinander mit den Response-stream des aktuellen HttpContext (die kann man nicht ändern die Antwort ist ContentType oder andere Header).

Im Grunde alles, was Sie tun ist, erstellen Sie eine gefälschte HttpContext für die Ansicht zu Rendern selbst:

///<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
}

Dieser Werke auf ASP.NET MVC 1.0, zusammen mit ContentResult, JsonResult, etc. (wechselnde Header in der ursprünglichen HttpResponse nicht werfen nicht das "Server nicht Inhaltstyp nach dem HTTP-Header gesendet wurden" Ausnahme).

Update: in ASP.NET MVC 2.0 RC, den code etwas verändert, weil wir zu Durchlaufen haben, in der StringWriter geschrieben, der Blick in den 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);

//...

Wenn Sie verzichten wollen, MVC vollständig, wodurch alle HttpContext Durcheinander...

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);

Dies nutzt der awesome open-source-Razor-Engine hier:
https://github.com/Antaris/RazorEngine

Ich bin mit MVC 1.0 RTM und keine der oben genannten Lösungen bei mir funktioniert. Aber dieser Tat:

Public Function RenderView(ByVal viewContext As ViewContext) As String

    Dim html As String = ""

    Dim response As HttpResponse = HttpContext.Current.Response

    Using tempWriter As New System.IO.StringWriter()

        Dim privateMethod As MethodInfo = response.GetType().GetMethod("SwitchWriter", BindingFlags.NonPublic Or BindingFlags.Instance)

        Dim currentWriter As Object = privateMethod.Invoke(response, BindingFlags.NonPublic Or BindingFlags.Instance Or BindingFlags.InvokeMethod, Nothing, New Object() {tempWriter}, Nothing)

        Try
            viewContext.View.Render(viewContext, Nothing)
            html = tempWriter.ToString()
        Finally
            privateMethod.Invoke(response, BindingFlags.NonPublic Or BindingFlags.Instance Or BindingFlags.InvokeMethod, Nothing, New Object() {currentWriter}, Nothing)
        End Try

    End Using

    Return html

End Function

Rendern einer Ansicht auf eine Zeichenfolge in der Service-Schicht ohne pass ControllerContext herum, es ist eine gute Rick Strahl Artikel hier http://www.codemag.com/Article/1312081 das schafft eine generische controller. Code summary unter:

//Some Static Class
public static string RenderViewToString(ControllerContext context, string viewPath, object model = null, bool partial = false)
{
    //first find the ViewEngine for this view
    ViewEngineResult viewEngineResult = null;
    if (partial)
        viewEngineResult = ViewEngines.Engines.FindPartialView(context, viewPath);
    else
        viewEngineResult = ViewEngines.Engines.FindView(context, viewPath, null);

    if (viewEngineResult == null)
        throw new FileNotFoundException("View cannot be found.");

    //get the view and attach the model to view data
    var view = viewEngineResult.View;
    context.Controller.ViewData.Model = model;

    string result = null;

    using (var sw = new StringWriter())
    {
        var ctx = new ViewContext(context, view, context.Controller.ViewData, context.Controller.TempData, sw);
        view.Render(ctx, sw);
        result = sw.ToString();
    }

    return result;
}

//In the Service Class
public class GenericController : Controller
{ }

public static T CreateController<T>(RouteData routeData = null) where T : Controller, new()
{
    //create a disconnected controller instance
    T controller = new T();

    //get context wrapper from HttpContext if available
    HttpContextBase wrapper;
    if (System.Web.HttpContext.Current != null)
        wrapper = new HttpContextWrapper(System.Web.HttpContext.Current);
    else
        throw new InvalidOperationException("Cannot create Controller Context if no active HttpContext instance is available.");

    if (routeData == null)
        routeData = new RouteData();

    //add the controller routing if not existing
    if (!routeData.Values.ContainsKey("controller") &&
        !routeData.Values.ContainsKey("Controller"))
        routeData.Values.Add("controller", controller.GetType().Name.ToLower().Replace("controller", ""));

    controller.ControllerContext = new ControllerContext(wrapper, routeData, controller);
    return controller;
}

Dann zum Rendern der Ansicht in der Service-Klasse:

var stringView = RenderViewToString(CreateController<GenericController>().ControllerContext, "~/Path/To/View/Location/_viewName.cshtml", theViewModel, true);

Wiederholen von einem eher unbekannten Frage, werfen Sie einen Blick auf MvcIntegrationTestFramework.

Macht es erspart Ihnen das schreiben Ihrer eigenen Helfer, um Strom führen und ist nachweislich gut genug funktioniert. Ich würde davon ausgehen, dies wäre in einem test-Projekt und als ein bonus, den Sie hätte der andere Test-Funktionen einmal hast du dieses setup. Wichtigste stören würde wahrscheinlich aussortieren der Abhängigkeit Kette.

 private static readonly string mvcAppPath = 
     Path.GetFullPath(AppDomain.CurrentDomain.BaseDirectory 
     + "\\..\\..\\..\\MyMvcApplication");
 private readonly AppHost appHost = new AppHost(mvcAppPath);

    [Test]
    public void Root_Url_Renders_Index_View()
    {
        appHost.SimulateBrowsingSession(browsingSession => {
            RequestResult result = browsingSession.ProcessRequest("");
            Assert.IsTrue(result.ResponseText.Contains("<!DOCTYPE html"));
        });
}

Ich einen besseren Weg gefunden zu Rendern razor-Ansicht-Seite, wenn ich habe Fehler mit den oben genannten Methoden, ist diese Lösung für beide web-Formular Umwelt-und mvc-Umfeld.
Kein controller erforderlich ist.

Hier ist das code-Beispiel in diesem Beispiel habe ich exemplarisch ein mvc-Aktion mit einem async-http-handler:

    ///<summary>
    ///Enables processing of HTTP Web requests asynchronously by a custom HttpHandler that implements the IHttpHandler interface.
    ///</summary>
    ///<param name="context">An HttpContext object that provides references to the intrinsic server objects.</param>
    ///<returns>The task to complete the http request.</returns>
    protected override async Task ProcessRequestAsync(HttpContext context)
    {
        if (this._view == null)
        {
            this.OnError(context, new FileNotFoundException("Can not find the mvc view file.".Localize()));
            return;
        }
        object model = await this.LoadModelAsync(context);
        WebPageBase page = WebPageBase.CreateInstanceFromVirtualPath(this._view.VirtualPath);
        using (StringWriter sw = new StringWriter())
        {
            page.ExecutePageHierarchy(new WebPageContext(new HttpContextWrapper(context), page, model), sw);
            await context.Response.Output.WriteAsync(sw.GetStringBuilder().ToString());
        }
    }