So fügen Sie eine Teilansicht in ein Webformular ein

Einige Websites, die ich programmiere, verwenden sowohl ASP.NET MVC als auch WebForms.

Ich habe eine Teilansicht und möchte diese in ein Webformular aufnehmen. Die Teilansicht enthält Code, der auf dem Server verarbeitet werden muss, sodass die Verwendung von Response.WriteFile nicht funktioniert. Es sollte mit deaktiviertem Javascript funktionieren.

Wie kann ich das machen?

Ich habe mir die MVC-Quelle angesehen, um herauszufinden, wie ich das machen kann. Es scheint eine sehr enge Kopplung zwischen Controller-Kontext, Ansichten, Ansichtsdaten, Routing-Daten und den HTML-Render-Methoden zu geben.

Um dies zu erreichen, müssen Sie grundsätzlich alle diese zusätzlichen Elemente erstellen. Einige von ihnen sind relativ einfach (z. B. die Ansichtsdaten), andere sind etwas komplexer. Beispielsweise wird bei den Routing-Daten die aktuelle WebForms-Seite als ignoriert betrachtet.

Das große Problem scheint der HttpContext zu sein - MVC-Seiten basieren auf einer HttpContextBase (anstelle von HttpContext wie bei WebForms), und während beide IServiceProvider implementieren, sind sie nicht miteinander verbunden. Die Designer von MVC haben absichtlich beschlossen, die alten WebForms nicht zu ändern, um die neue Kontextbasis zu verwenden. Sie haben jedoch einen Wrapper bereitgestellt.

Dies funktioniert und Sie können einer WebForm eine Teilansicht hinzufügen:

public class WebFormController : Controller { }

public static class WebFormMVCUtil
{

    public static void RenderPartial( string partialName, object model )
    {
        //get a wrapper for the legacy WebForm context
        var httpCtx = new HttpContextWrapper( System.Web.HttpContext.Current );

        //create a mock route that points to the empty controller
        var rt = new RouteData();
        rt.Values.Add( "controller", "WebFormController" );

        //create a controller context for the route and http context
        var ctx = new ControllerContext( 
            new RequestContext( httpCtx, rt ), new WebFormController() );

        //find the partial view using the viewengine
        var view = ViewEngines.Engines.FindPartialView( ctx, partialName ).View;

        //create a view context and assign the model
        var vctx = new ViewContext( ctx, view, 
            new ViewDataDictionary { Model = model }, 
            new TempDataDictionary() );

        //render the partial view
        view.Render( vctx, System.Web.HttpContext.Current.Response.Output );
    }

}

Dann können Sie in Ihrem WebForm Folgendes tun:

<% WebFormMVCUtil.RenderPartial( "ViewName", this.GetModel() ); %>

Es hat eine Weile gedauert, aber ich habe eine großartige Lösung gefunden. Keiths Lösung funktioniert für viele Menschen, aber in bestimmten Situationen ist es nicht die beste, weil manchmal mögen Sie Ihre Anwendung durch den Prozess des Controllers geht für das Rendern der Ansicht, und Keith-Lösung macht nur die Ansicht mit einem bestimmten Modell I‘ Ich präsentiere hier eine neue Lösung, die den normalen Prozess ausführt.

Allgemeine Schritte:

1. Erstellen Sie eine Utility-Klasse
2. Erstellen Sie einen Dummy-Controller mit einer Dummy-Ansicht
3. Rufen Sie in Ihrem aspxoder master pagedie Dienstprogrammmethode auf, um das teilweise Übergeben des Controllers zu rendern, die Ansicht anzuzeigen und bei Bedarf das zu rendernde Modell (als Objekt).

Lassen Sie es uns in diesem Beispiel genau überprüfen

1) Erstellen Sie eine aufgerufene Klasse MVCUtilityund erstellen Sie die folgenden Methoden:

    //Render a partial view, like Keith's solution
    private static void RenderPartial(string partialViewName, object model)
    {
        HttpContextBase httpContextBase = new HttpContextWrapper(HttpContext.Current);
        RouteData routeData = new RouteData();
        routeData.Values.Add("controller", "Dummy");
        ControllerContext controllerContext = new ControllerContext(new RequestContext(httpContextBase, routeData), new DummyController());
        IView view = FindPartialView(controllerContext, partialViewName);
        ViewContext viewContext = new ViewContext(controllerContext, view, new ViewDataDictionary { Model = model }, new TempDataDictionary(), httpContextBase.Response.Output);
        view.Render(viewContext, httpContextBase.Response.Output);
    }

    //Find the view, if not throw an exception
    private static IView FindPartialView(ControllerContext controllerContext, string partialViewName)
    {
        ViewEngineResult result = ViewEngines.Engines.FindPartialView(controllerContext, partialViewName);
        if (result.View != null)
        {
            return result.View;
        }
        StringBuilder locationsText = new StringBuilder();
        foreach (string location in result.SearchedLocations)
        {
            locationsText.AppendLine();
            locationsText.Append(location);
        }
        throw new InvalidOperationException(String.Format("Partial view {0} not found. Locations Searched: {1}", partialViewName, locationsText));
    }       

    //Here the method that will be called from MasterPage or Aspx
    public static void RenderAction(string controllerName, string actionName, object routeValues)
    {
        RenderPartial("PartialRender", new RenderActionViewModel() { ControllerName = controllerName, ActionName = actionName, RouteValues = routeValues });
    }

Erstellen Sie eine Klasse zum Übergeben der Parameter. Ich werde hier RendeActionViewModel aufrufen (Sie können in derselben Datei der MvcUtility-Klasse erstellen).

    public class RenderActionViewModel
    {
        public string ControllerName { get; set; }
        public string ActionName { get; set; }
        public object RouteValues { get; set; }
    }

2) Erstellen Sie nun einen Controller mit dem Namen DummyController

    //Here the Dummy controller with Dummy view
    public class DummyController : Controller
    {
      public ActionResult PartialRender()
      {
          return PartialView();
      }
    }

Erstellen Sie eine Dummy-Ansicht mit dem Namen PartialRender.cshtml(Rasiereransicht) für die DummyControllermit dem folgenden Inhalt. Beachten Sie, dass mit dem HTML-Helfer eine weitere Renderaktion ausgeführt wird.

@model Portal.MVC.MvcUtility.RenderActionViewModel
@{Html.RenderAction(Model.ActionName, Model.ControllerName, Model.RouteValues);}

3) Fügen Sie dies nun einfach in Ihre MasterPageoder aspx-Datei ein, um eine gewünschte Ansicht teilweise zu rendern. Beachten Sie, dass dies eine gute Antwort ist, wenn Sie mehrere Rasiereransichten haben, die Sie mit Ihren MasterPageoder Ihren aspxSeiten mischen möchten . (Angenommen, wir haben eine PartialView namens Login für die Controller-Startseite).

    <% MyApplication.MvcUtility.RenderAction("Home", "Login", new { }); %>

oder wenn Sie ein Modell für die Übergabe an die Aktion haben

    <% MyApplication.MvcUtility.RenderAction("Home", "Login", new { Name="Daniel", Age = 30 }); %>

Diese Lösung ist großartig, verwendet keinen Ajax-Aufruf , der kein verzögertes Rendern für die verschachtelten Ansichten verursacht, keine neue WebRequest erstellt, sodass keine neue Sitzung angezeigt wird , und die Methode zum Abrufen verarbeitet Das ActionResult für die gewünschte Ansicht funktioniert ohne Übergabe eines Modells

Dank der Verwendung von MVC RenderAction in einem Webformular

Der naheliegendste Weg wäre über AJAX

so etwas (mit jQuery)

<div id="mvcpartial"></div>

<script type="text/javascript">
$(document).load(function () {
    $.ajax(
    {    
        type: "GET",
        url : "urltoyourmvcaction",
        success : function (msg) { $("#mvcpartial").html(msg); }
    });
});
</script>

Das ist großartig, danke!

Ich verwende MVC 2 unter .NET 4, für das ein TextWriter an ViewContext übergeben werden muss. Daher müssen Sie httpContextWrapper.Response.Output wie unten gezeigt übergeben.

    public static void RenderPartial(String partialName, Object model)
    {
        // get a wrapper for the legacy WebForm context
        var httpContextWrapper = new HttpContextWrapper(HttpContext.Current);

        // create a mock route that points to the empty controller
        var routeData = new RouteData();
        routeData.Values.Add(_controller, _webFormController);

        // create a controller context for the route and http context
        var controllerContext = new ControllerContext(new RequestContext(httpContextWrapper, routeData), new WebFormController());

        // find the partial view using the viewengine
        var view = ViewEngines.Engines.FindPartialView(controllerContext, partialName).View as WebFormView;

        // create a view context and assign the model
        var viewContext = new ViewContext(controllerContext, view, new ViewDataDictionary { Model = model }, new TempDataDictionary(), httpContextWrapper.Response.Output);

        // render the partial view
        view.Render(viewContext, httpContextWrapper.Response.Output);
    }

Hier ist ein ähnlicher Ansatz, der für mich funktioniert hat. Die Strategie besteht darin, die Teilansicht in eine Zeichenfolge zu rendern und diese dann auf der WebForm-Seite auszugeben.

 public class TemplateHelper
{
    /// <summary>
    /// Render a Partial View (MVC User Control, .ascx) to a string using the given ViewData.
    /// http://www.joeyb.org/blog/2010/01/23/aspnet-mvc-2-render-template-to-string
    /// </summary>
    /// <param name="controlName"></param>
    /// <param name="viewData"></param>
    /// <returns></returns>
    public static string RenderPartialToString(string controlName, object viewData)
    {
        ViewDataDictionary vd = new ViewDataDictionary(viewData);
        ViewPage vp = new ViewPage { ViewData = vd};
        Control control = vp.LoadControl(controlName);

        vp.Controls.Add(control);

        StringBuilder sb = new StringBuilder();
        using (StringWriter sw = new StringWriter(sb))
        {
            using (HtmlTextWriter tw = new HtmlTextWriter(sw))
            {
                vp.RenderControl(tw);
            }
        }

        return sb.ToString();
    }
}

Im Seitencodebehind können Sie dies tun

public partial class TestPartial : System.Web.UI.Page
{
    public string NavigationBarContent
    {
        get;
        set;
    }

    protected void Page_Load(object sender, EventArgs e)
    {
        NavigationVM oVM = new NavigationVM();

        NavigationBarContent = TemplateHelper.RenderPartialToString("~/Views/Shared/NavigationBar.ascx", oVM);

    }
}

und auf der Seite haben Sie Zugriff auf den gerenderten Inhalt

<%= NavigationBarContent %>

Hoffentlich hilft das!

Diese Lösung verfolgt einen anderen Ansatz. Es definiert ein Element, das in einem System.Web.UI.UserControlbeliebigen Webformular platziert und so konfiguriert werden kann, dass der Inhalt von einer beliebigen URL angezeigt wird… einschließlich einer MVC-Teilansicht. Dieser Ansatz ähnelt einem AJAX-Aufruf für HTML, bei dem Parameter (falls vorhanden) über die URL-Abfragezeichenfolge angegeben werden.

Definieren Sie zunächst ein Benutzersteuerelement in 2 Dateien:

Datei /controls/PartialViewControl.ascx

<%@ Control Language="C#" 
AutoEventWireup="true" 
CodeFile="PartialViewControl.ascx.cs" 
Inherits="PartialViewControl" %>

/controls/PartialViewControl.ascx.cs:

public partial class PartialViewControl : System.Web.UI.UserControl {
    [Browsable(true),
    Category("Configutation"),
    Description("Specifies an absolute or relative path to the content to display.")]
    public string contentUrl { get; set; }

    protected override void Render(HtmlTextWriter writer) {
        string requestPath = (contentUrl.StartsWith("http") ? contentUrl : "http://" + Request.Url.DnsSafeHost + Page.ResolveUrl(contentUrl));
        WebRequest request = WebRequest.Create(requestPath);
        WebResponse response = request.GetResponse();
        Stream responseStream = response.GetResponseStream();
        var responseStreamReader = new StreamReader(responseStream);
        var buffer = new char[32768];
        int read;
        while ((read = responseStreamReader.Read(buffer, 0, buffer.Length)) > 0) {
            writer.Write(buffer, 0, read);
        }
    }
}

Fügen Sie dann das Benutzersteuerelement zu Ihrer Webformularseite hinzu:

<%@ Page Language="C#" %>
<%@ Register Src="~/controls/PartialViewControl.ascx" TagPrefix="mcs" TagName="PartialViewControl" %>
<h1>My MVC Partial View</h1>
<p>Below is the content from by MVC partial view (or any other URL).</p>
<mcs:PartialViewControl runat="server" contentUrl="/MyMVCView/"  />

FWIW, ich musste in der Lage sein, eine Teilansicht dynamisch aus vorhandenem Webforms-Code zu rendern und sie oben in ein bestimmtes Steuerelement einzufügen. Ich fand heraus, dass die Antwort von Keith dazu führen kann, dass die Teilansicht außerhalb von gerendert wird<html /> Tags .

Ich habe die Antworten von Keith und Hilarius als Inspiration verwendet, anstatt sie direkt in HttpContext.Current.Response.Output zu rendern. Ich habe die HTML-Zeichenfolge gerendert und sie als LiteralControl zum entsprechenden Steuerelement hinzugefügt.

In der statischen Hilfsklasse:

    public static string RenderPartial(string partialName, object model)
    {
        //get a wrapper for the legacy WebForm context
        var httpCtx = new HttpContextWrapper(HttpContext.Current);

        //create a mock route that points to the empty controller
        var rt = new RouteData();
        rt.Values.Add("controller", "WebFormController");

        //create a controller context for the route and http context
        var ctx = new ControllerContext(new RequestContext(httpCtx, rt), new WebFormController());

        //find the partial view using the viewengine
        var view = ViewEngines.Engines.FindPartialView(ctx, partialName).View;

        //create a view context and assign the model
        var vctx = new ViewContext(ctx, view, new ViewDataDictionary { Model = model }, new TempDataDictionary(), new StringWriter());

        // This will render the partial view direct to the output, but be careful as it may end up outside of the <html /> tag
        //view.Render(vctx, HttpContext.Current.Response.Output);

        // Better to render like this and create a literal control to add to the parent
        var html = new StringWriter();
        view.Render(vctx, html);
        return html.GetStringBuilder().ToString();
    }

In der aufrufenden Klasse:

    internal void AddPartialViewToControl(HtmlGenericControl ctrl, int? insertAt = null, object model)
    {
        var lit = new LiteralControl { Text = MvcHelper.RenderPartial("~/Views/Shared/_MySharedView.cshtml", model};
        if (insertAt == null)
        {
            ctrl.Controls.Add(lit);
            return;
        }
        ctrl.Controls.AddAt(insertAt.Value, lit);
    }