Como converter o modelo de exibição em objeto JSON no asp.net MVC?

Sou desenvolvedor Java, novo no .NET. Estou trabalhando em um projeto .NET MVC2 em que quero ter uma exibição parcial para quebrar um widget. Cada objeto de widget JavaScript possui um objeto de dados JSON que seria preenchido pelos dados do modelo. Os métodos para atualizar esses dados são vinculados a eventos quando os dados são alterados no widget ou se esses dados são alterados em outro widget.

O código é algo como isto:

MyController:

virtual public ActionResult DisplaySomeWidget(int id) {
  SomeModelView returnData = someDataMapper.getbyid(1);

  return View(myview, returnData);
}

myview.ascx:

<%@ Control Language="C#" Inherits="System.Web.Mvc.ViewUserControl<SomeModelView>" %>

<script type="text/javascript">
  //creates base widget object;
  var thisWidgetName = new Widget();

  thisWidgetName.updateTable = function() {
    //  UpdatesData
  };
  $(document).ready(function () {
    thisWidgetName.data = <% converttoJSON(model) %>
    $(document).bind('DATA_CHANGED', thisWidgetName.updateTable());
  });
</script>

<div><%:model.name%></div>

O que não sei é como enviar os dados SomeModelViewe, em seguida, poder usá-los para preencher o widget e convertê-los para JSON. Eu já tinha visto algumas maneiras simples de fazê-lo no controlador, mas não na exibição. Eu acho que essa é uma pergunta básica, mas eu venho há algumas horas tentando deixar isso mais liso.

No mvc3 com navalha @Html.Raw(Json.Encode(object))parece fazer o truque.

Muito bem, você acabou de começar a usar o MVC e encontrou sua primeira grande falha.

Você realmente não deseja convertê-lo para JSON na visualização e não deseja convertê-lo no controlador, pois nenhum desses locais faz sentido. Infelizmente, você está preso a esta situação.

A melhor coisa que descobri é enviar o JSON para a visualização em um ViewModel, assim:

var data = somedata;
var viewModel = new ViewModel();
var serializer = new JavaScriptSerializer();
viewModel.JsonData = serializer.Serialize(data);

return View("viewname", viewModel);

então use

<%= Model.JsonData %>

na sua opinião. Esteja ciente de que o .NET JavaScriptSerializer padrão é uma porcaria.

fazê-lo no controlador pelo menos o torna testável (embora não seja exatamente como o descrito acima - você provavelmente quer usar um ISerializer como uma dependência para poder zombar dele)

Atualize também, em relação ao seu JavaScript, seria uma boa prática agrupar TODOS os JS de widget que você possui acima, desta forma:

(
    // all js here
)();

dessa maneira, se você colocar vários widgets em uma página, não terá conflitos (a menos que precise acessar os métodos de outros lugares da página, mas nesse caso, você deverá registrar o widget com alguma estrutura de widget). Pode não ser um problema agora, mas seria uma boa prática adicionar os colchetes agora para economizar muito esforço no futuro, quando isso se tornar um requisito, também é uma boa prática OO encapsular a funcionalidade.

Achei muito legal fazer assim (uso na exibição):

    @Html.HiddenJsonFor(m => m.TrackingTypes)

Aqui está o método auxiliar de acordo com a classe Extension:

public static class DataHelpers
{
    public static MvcHtmlString HiddenJsonFor<TModel, TProperty>(this HtmlHelper<TModel> htmlHelper, Expression<Func<TModel, TProperty>> expression)
    {
        return HiddenJsonFor(htmlHelper, expression, (IDictionary<string, object>) null);
    }

    public static MvcHtmlString HiddenJsonFor<TModel, TProperty>(this HtmlHelper<TModel> htmlHelper, Expression<Func<TModel, TProperty>> expression, object htmlAttributes)
    {
        return HiddenJsonFor(htmlHelper, expression, HtmlHelper.AnonymousObjectToHtmlAttributes(htmlAttributes));
    }

    public static MvcHtmlString HiddenJsonFor<TModel, TProperty>(this HtmlHelper<TModel> htmlHelper, Expression<Func<TModel, TProperty>> expression, IDictionary<string, object> htmlAttributes)
    {
        var name = ExpressionHelper.GetExpressionText(expression);
        var metadata = ModelMetadata.FromLambdaExpression(expression, htmlHelper.ViewData);

        var tagBuilder = new TagBuilder("input");
        tagBuilder.MergeAttributes(htmlAttributes);
        tagBuilder.MergeAttribute("name", name);
        tagBuilder.MergeAttribute("type", "hidden");

        var json = JsonConvert.SerializeObject(metadata.Model);

        tagBuilder.MergeAttribute("value", json);

        return MvcHtmlString.Create(tagBuilder.ToString());
    }
}

Não é super sofisticado, mas resolve o problema de onde colocá-lo (no Controller ou no modo de exibição?) A resposta é obviamente: nenhum;)

Você pode usar Json diretamente da ação,

Sua ação seria algo como isto:

virtual public JsonResult DisplaySomeWidget(int id)
{
    SomeModelView returnData = someDataMapper.getbyid(id);
    return Json(returnData);
}

Editar

Acabei de ver que você supõe que esta é Modeluma Visualização, portanto, o que foi exposto acima não é estritamente correto, você teria que fazer uma Ajaxchamada para o método do controlador para obter isso.ascx que foi dito pois não teria um modelo em si, deixarei meu código caso seja útil e você possa alterar a chamada

Editar 2 basta colocar o código no código

@ Html.Raw (Json.Encode (object)) pode ser usado para converter o objeto modal de exibição em JSON

<htmltag id=’elementId’ data-ZZZZ’=’@Html.Raw(Json.Encode(Model))’ />

Consulte https://highspeedlowdrag.wordpress.com/2014/08/23/mvc-data-to-jquery-data/

Eu fiz abaixo e funciona como charme.

<input id="hdnElement" class="hdnElement" type="hidden" value='@Html.Raw(Json.Encode(Model))'>

Estendendo a ótima resposta de Dave . Você pode criar um HtmlHelper simples .

public static IHtmlString RenderAsJson(this HtmlHelper helper, object model)
{
    return helper.Raw(Json.Encode(model));
}

E na sua opinião:

@Html.RenderAsJson(Model)

Dessa forma, você pode centralizar a lógica para criar o JSON se, por algum motivo, desejar alterar a lógica posteriormente.

O Andrew teve uma ótima resposta, mas eu queria mexer um pouco. A maneira como isso é diferente é que eu gosto que meus ModelViews não tenham dados gerais. Apenas os dados para o objeto. Parece que o ViewData se encaixa na conta dos dados gerais, mas é claro que sou novo nisso. Eu sugiro fazer algo assim.

Controlador

virtual public ActionResult DisplaySomeWidget(int id)
{
    SomeModelView returnData = someDataMapper.getbyid(1);
    var serializer = new JavaScriptSerializer();
    ViewData["JSON"] = serializer.Serialize(returnData);
    return View(myview, returnData);
}

Visão

//create base js object;
var myWidget= new Widget(); //Widget is a class with a public member variable called data.
myWidget.data= <%= ViewData["JSON"] %>;

O que isso faz por você é que ele fornece os mesmos dados em seu JSON e em seu ModelView, para que você possa retornar o JSON de volta ao seu controlador e ele tenha todas as partes. Isso é semelhante a apenas solicitá-lo por meio de um JSONRequest, no entanto, requer menos uma chamada, para que você economize essa sobrecarga. BTW isso é descolado para datas, mas que parece ser outro segmento.