Html.Partial vs Html.RenderPartial e Html.Action vs Html.RenderAction

No ASP.NET MVC, qual é a diferença entre:

• Html.Partial e Html.RenderPartial
• Html.Action e Html.RenderAction

Html.Partialretorna uma String. Html.RenderPartialliga Writeinternamente 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.Partialuma variável ou retorná-la de um método, não se pode fazer isso com Html.RenderPartial.

O resultado será gravado no Responsefluxo durante a execução / avaliação.

Isso também se aplica a Html.Actione Html.RenderAction.

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

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.

A diferença é a primeira: um retorna um, MvcHtmlStringmas o segundo ( Render..) sai direto para a resposta.

Segundo a mim, @Html.RenderPartial()tem uma execução mais rápida do que @Html.Partial()devido ao Html.RenderPartial dá uma resposta rápida ao Output.

Porque quando eu uso @Html.Partial(), meu site leva mais tempo para carregar em comparação com @Html.RenderPartial()

@Html.Partiale @Html.RenderPartialsã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.Actione @Html.RenderActionsã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é voidque significa que ele renderiza diretamente as respostas no modo de exibição em que o tipo de retorno Html.Actioné. MvcHtmlStringVocê 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.PartialeHtml.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:

1. O tipo de retorno de RenderPartialé void, onde, como PartialretornosMvcHtmlString

2. Sintaxe para chamar Partial()e RenderPartial()métodos nas visualizações Razor

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

3. 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().

Html.Partial: retorna MvcHtmlStringe lento

Html.RenderPartial: renderiza / grava diretamente no fluxo de saída e retorna voide é muito rápido em comparação comHtml.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.Partialretorna a exibição na string codificada em HTML e usa o mesmo TextWriterobjeto de exibição . @Html.RenderPartialesse método retorna void. @Html.RenderPartialé mais rápido que@Html.Partial

A sintaxe para PartialView:

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