Html.Partial vs Html.RenderPartial & Html.Action vs Html.RenderAction

Dans ASP.NET MVC, quelle est la différence entre:

• Html.Partial et Html.RenderPartial
• Html.Action et Html.RenderAction

Html.Partialrenvoie une chaîne. Html.RenderPartialappelle en Writeinterne et revient void.

L'utilisation de base est:

// Razor syntax
@Html.Partial("ViewName")
@{ Html.RenderPartial("ViewName");  }

// WebView syntax
<%: Html.Partial("ViewName") %>
<% Html.RenderPartial("ViewName"); %>

Dans l'extrait ci-dessus, les deux appels donneront le même résultat.

Bien que l'on puisse stocker la sortie de Html.Partialdans une variable ou la renvoyer à partir d'une méthode, on ne peut pas le faire avec Html.RenderPartial.

Le résultat sera écrit dans le Responseflux pendant l'exécution / l'évaluation.

Cela vaut également pour Html.Actionet Html.RenderAction.

Considérez @ Html.Partial comme du code HTML copié dans la page parent. Considérez @ Html.RenderPartial comme un contrôle utilisateur .ascx incorporé dans la page parent. Un contrôle utilisateur .ascx a beaucoup plus de frais généraux.

'@ Html.Partial' renvoie une chaîne codée html qui est construite en ligne avec le parent. Il accède au modèle du parent.

'@ Html.RenderPartial' renvoie l'équivalent d'un contrôle utilisateur .ascx. Il obtient sa propre copie du ViewDataDictionary de la page et les modifications apportées au ViewData du RenderPartial n'affectent pas le ViewData du parent.

En utilisant la réflexion, nous trouvons:

public static MvcHtmlString Partial(this HtmlHelper htmlHelper, string partialViewName, object model, ViewDataDictionary viewData)
{
    MvcHtmlString mvcHtmlString;
    using (StringWriter stringWriter = new StringWriter(CultureInfo.CurrentCulture))
    {
        htmlHelper.RenderPartialInternal(partialViewName, viewData, model, stringWriter, ViewEngines.Engines);
        mvcHtmlString = MvcHtmlString.Create(stringWriter.ToString());
    }
    return mvcHtmlString;
}

public static void RenderPartial(this HtmlHelper htmlHelper, string partialViewName)
{
    htmlHelper.RenderPartialInternal(partialViewName, htmlHelper.ViewData, null, htmlHelper.ViewContext.Writer, ViewEngines.Engines);
}

Voici ce que j'ai trouvé:

Utilisez RenderAction lorsque vous n'avez pas de modèle à envoyer à la vue et que vous avez beaucoup de code HTML à ramener qui n'a pas besoin d'être stocké dans une variable.

Utilisez Action lorsque vous n'avez pas de modèle à envoyer à la vue et que vous avez un peu de texte à ramener qui doit être stocké dans une variable.

Utilisez RenderPartial lorsque vous avez un modèle à envoyer à la vue et qu'il y aura beaucoup de code HTML qui n'aura pas besoin d'être stocké dans une variable.

Utilisez Partiel lorsque vous avez un modèle à envoyer à la vue et il y aura un peu de texte qui devra être stocké dans une variable.

RenderAction et RenderPartial sont plus rapides.

La différence est que le premier renvoie une sortie MvcHtmlStringmais la seconde ( Render..) directement à la réponse.

Selon moi, l' @Html.RenderPartial()exécution est plus rapide qu'en @Html.Partial()raison de Html.RenderPartial donne une réponse rapide à Output.

Parce que lorsque j'utilise @Html.Partial(), mon site Web prend plus de temps à charger par rapport à @Html.RenderPartial()

@Html.Partialet @Html.RenderPartialsont utilisés lorsque votre modèle de vue partielle correspond à un modèle parent, nous n'avons pas besoin de créer de méthode d'action pour l'appeler.

@Html.Actionet @Html.RenderActionsont utilisés lorsque votre modèle de vue partielle est indépendant du modèle parent, il est essentiellement utilisé lorsque vous souhaitez afficher un contenu de type widget sur la page. Vous devez créer une méthode d'action qui renvoie un résultat de vue partielle lors de l'appel de la méthode à partir de la vue.

En savoir plus sur la question:

"Lorsque Html.RenderPartial () est appelé avec uniquement le nom de la vue partielle, ASP.NET MVC transmet à la vue partielle les mêmes objets de dictionnaire Model et ViewData utilisés par le modèle de vue appelant."

"NerdDinner" de Professional ASP.NET MVC 1.0

Le type de retour de Html.RenderActionest voidcela signifie qu'il rend directement les réponses dans View où le type de retour Html.Actionest. MvcHtmlStringVous pouvez attraper sa vue de rendu dans le contrôleur et la modifier en utilisant la méthode suivante

protected string RenderPartialViewToString(string viewName, object model)
    {
        if (string.IsNullOrEmpty(viewName))
            viewName = ControllerContext.RouteData.GetRequiredString("action");

        ViewData.Model = model;

        using (StringWriter sw = new StringWriter())
        {
            ViewEngineResult viewResult = ViewEngines.Engines.FindPartialView(ControllerContext, viewName);
            ViewContext viewContext = new ViewContext(ControllerContext, viewResult.View, ViewData, TempData, sw);
            viewResult.View.Render(viewContext, sw);
            return sw.GetStringBuilder().ToString();
        }
    }

Cela renverra la chaîne Html de la vue.

Ceci est également applicable à Html.PartialetHtml.RenderPartial

Partial ou RenderPartial: Pas besoin de créer de méthode d'action. à utiliser lorsque les données à afficher sur la vue partielle sont déjà présentes dans le modèle de la page actuelle.

Action ou RenderAction: nécessite une méthode d'action enfant. à utiliser lorsque les données à afficher sur la vue ont un modèle indépendant.

Différences:

1. Le type de retour RenderPartialest is void, où as PartialrenvoieMvcHtmlString

2. Syntaxe d'appel Partial()et RenderPartial()méthodes dans les vues Razor

   @ Html.Partial ("PartialViewName")
   @ {Html.RenderPartial ("PartialViewName"); }

3. Syntaxe d'appel Partial()et RenderPartial()méthodes dans les vues de formulaire Web

[%: Html.Partial ("PartialViewName")%]
[% Html.RenderPartial ("PartialViewName"); %]

Voici les 2 questions d'entrevue courantes liées à Partial()et RenderPartial() quand utiliseriez-vous Partial()plus RenderPartial()et vice versa?

La principale différence est que RenderPartial()renvoie void et la sortie sera écrite directement dans le flux de sortie, où au fur et à mesure que la Partial()méthode revient MvcHtmlString, qui peut être affectée à une variable et la manipuler si nécessaire. Ainsi, lorsqu'il est nécessaire d'affecter la sortie à une variable pour la manipuler, utilisez alors Partial (), sinon utilisez RenderPartial ().

Lequel est le meilleur pour la performance?

Du point de vue des performances, le rendu directement sur le flux de sortie est meilleur. RenderPartial()fait exactement la même chose et est meilleur pour les performances Partial().

Html.Partial: revient MvcHtmlStringet ralentit

Html.RenderPartial: rendre / écrire directement sur le flux de sortie et les retours voidet c'est très rapide par rapport àHtml.Partial

Pour "partiel" je l'utilise toujours comme suit:

S'il y a quelque chose que vous devez inclure dans une page que vous devez consulter via le contrôleur (comme vous le feriez avec un appel Ajax), utilisez "Html.RenderPartial".

Si vous avez une inclusion "statique" qui n'est pas liée à un contrôleur en soi et uniquement dans le dossier "partagé" par exemple, utilisez "HTML.partial"

@Html.Partialrenvoie la vue dans une chaîne codée en HTML et utilise le même TextWriterobjet de vue . @Html.RenderPartialcette méthode retourne void. @Html.RenderPartialest plus rapide que@Html.Partial

La syntaxe pour PartialView:

 [HttpGet] 
 public ActionResult AnyActionMethod
 {
     return PartialView();
 }