No ASP.NET MVC, qual é a diferença entre:
Html.Partial
eHtml.RenderPartial
Html.Action
eHtml.RenderAction
No ASP.NET MVC, qual é a diferença entre:
Html.Partial
e Html.RenderPartial
Html.Action
e Html.RenderAction
Respostas:
Html.Partial
retorna uma String. Html.RenderPartial
liga Write
internamente e retorna void
.
O uso básico é:
// Razor syntax
@Html.Partial("ViewName")
@{ Html.RenderPartial("ViewName"); }
// WebView syntax
<%: Html.Partial("ViewName") %>
<% Html.RenderPartial("ViewName"); %>
No trecho acima, as duas chamadas produzirão o mesmo resultado.
Embora se possa armazenar a saída de Html.Partial
uma variável ou retorná-la de um método, não se pode fazer isso com Html.RenderPartial
.
O resultado será gravado no Response
fluxo durante a execução / avaliação.
Isso também se aplica a Html.Action
e Html.RenderAction
.
Html.Partial()
foi criado para ter uma sintaxe mais fluente com o Razor. Como disse o @Vlad, Html.RenderPartial()
é mais eficiente.
Pense em @ Html.Partial como código HTML copiado na página pai. Pense em @ Html.RenderPartial como um controle de usuário .ascx incorporado na página pai. Um controle de usuário .ascx tem muito mais sobrecarga.
'@ Html.Partial' retorna uma string codificada em html que é construída em linha com o pai. Ele acessa o modelo dos pais.
'@ Html.RenderPartial' retorna o equivalente a um controle de usuário .ascx. Ele obtém sua própria cópia do ViewDataDictionary da página e as alterações feitas no ViewData do RenderPartial não afetam o ViewData do pai.
Usando a reflexão, encontramos:
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);
}
Partial
renderizado em um buffer não significa que ele é renderizado de forma assíncrona - muito pelo contrário - não consigo ver como você pode reivindicar que RenderPartial
"consome mais recursos".
Aqui está o que eu encontrei:
Use RenderAction quando você não possui um modelo para enviar para a visualização e possui muito html para recuperar que não precisa ser armazenado em uma variável.
Use Ação quando você não tiver um modelo para enviar para a visualização e tenha um pouco de texto para trazer de volta, que precisa ser armazenado em uma variável.
Use RenderPartial quando você tiver um modelo para enviar para a visualização e haverá muitos html que não precisam ser armazenados em uma variável.
Use Parcial quando você tiver um modelo para enviar para a visualização e haverá um pouco de texto que precisa ser armazenado em uma variável.
RenderAction e RenderPartial são mais rápidos.
@Html.Partial
e @Html.RenderPartial
são usados quando seu modelo de vista parcial é uma correspondência do modelo pai, não precisamos criar nenhum método de ação para chamar isso.
@Html.Action
e @Html.RenderAction
são usados quando seu modelo de vista parcial é independente do modelo pai, basicamente é usado quando você deseja exibir qualquer conteúdo do tipo de widget na página. Você deve criar um método de ação que retorne um resultado de exibição parcial enquanto chama o método da exibição.
Mais sobre a questão:
"Quando Html.RenderPartial () é chamado apenas com o nome da exibição parcial, o ASP.NET MVC passa para a exibição parcial os mesmos objetos de dicionário Model e ViewData usados pelo modelo de exibição de chamada".
"NerdDinner" do profissional ASP.NET MVC 1.0
O tipo de retorno de Html.RenderAction
é void
que significa que ele renderiza diretamente as respostas no modo de exibição em que o tipo de retorno Html.Action
é. MvcHtmlString
Você pode capturar sua exibição de renderização no controlador e modificá-la usando o seguinte método
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();
}
}
Isso retornará a seqüência de caracteres HTML da exibição.
Isso também é aplicável Html.Partial
eHtml.RenderPartial
Parcial ou RenderPartial: Não há necessidade de criar método de ação. use quando os dados a serem exibidos na vista parcial já estiverem presentes no modelo da página atual.
Ação ou RenderAction: requer método de ação filho. use quando os dados a serem exibidos na exibição tiverem modelo independente.
Diferenças:
O tipo de retorno de RenderPartial
é void
, onde, como Partial
retornosMvcHtmlString
Sintaxe para chamar Partial()
e RenderPartial()
métodos nas visualizações Razor
@ Html.Partial ("PartialViewName")
@ {Html.RenderPartial ("PartialViewName"); }
Sintaxe para Chamada Partial()
e RenderPartial()
Métodos em Visualizações de Formulário da Web
[%: Html.Partial ("PartialViewName")%]
[% Html.RenderPartial ("PartialViewName"); %]
A seguir, estão as 2 perguntas comuns da entrevista relacionadas a Partial()
e RenderPartial()
quando você utilizaria Partial()
mais RenderPartial()
e vice-versa?
A principal diferença é que RenderPartial()
retorna nulo e a saída será gravada diretamente no fluxo de saída, onde, conforme o Partial()
método retorna MvcHtmlString
, que pode ser atribuído a uma variável e manipulado, se necessário. Portanto, quando houver necessidade de atribuir a saída a uma variável para manipulá-la, use Partial (), caso contrário, use RenderPartial ().
Qual é o melhor para o desempenho?
Do ponto de vista do desempenho, é melhor renderizar diretamente no fluxo de saída. RenderPartial()
faz exatamente a mesma coisa e é melhor para o desempenho terminar Partial()
.
Para "parcial", eu sempre o uso da seguinte maneira:
Se houver algo que você precise incluir em uma página que você precisa acessar pelo controlador (como faria com uma chamada Ajax), use "Html.RenderPartial".
Se você tiver uma inclusão 'estática' que não esteja vinculada a um controlador em si e apenas na pasta 'compartilhada', por exemplo, use "HTML.partial"
@Html.Partial
retorna a exibição na string codificada em HTML e usa o mesmo TextWriter
objeto de exibição .
@Html.RenderPartial
esse método retorna void
.
@Html.RenderPartial
é mais rápido que@Html.Partial
A sintaxe para PartialView
:
[HttpGet]
public ActionResult AnyActionMethod
{
return PartialView();
}