Formato de data do asp.net MVC JsonResult

Eu tenho uma ação de controlador que efetivamente simplesmente retorna um JsonResult do meu modelo. Portanto, no meu método, tenho algo como o seguinte:

return new JsonResult(myModel);

Isso funciona bem, exceto por um problema. Há uma propriedade de data no modelo e isso parece ser retornado no resultado Json da seguinte forma:

"\/Date(1239018869048)\/"

Como devo lidar com as datas para que elas sejam retornadas no formato exigido? Ou como eu manejo esse formato acima no script?

Apenas para expandir a resposta do casperOne .

A especificação JSON não considera valores de data. A MS teve que fazer uma ligação, e o caminho que eles escolheram foi explorar um pequeno truque na representação javascript de strings: a string literal "/" é igual a "\ /", e uma string literal nunca será serializada como " \ / "(mesmo" \ / "deve ser mapeado para" \\ / ").

Consulte http://msdn.microsoft.com/en-us/library/bb299886.aspx#intro_to_json_topic2 para obter uma explicação melhor (role para baixo até "De literais em JavaScript para JSON")

Um dos pontos negativos do JSON é a falta de um literal de data / hora. Muitas pessoas ficam surpresas e desapontadas ao saber disso quando encontram o JSON pela primeira vez. A explicação simples (consoladora ou não) para a ausência de um literal de data / hora é que o JavaScript também nunca teve um: O suporte para valores de data e hora no JavaScript é fornecido inteiramente por meio do objeto Date. A maioria dos aplicativos que usam JSON como formato de dados, portanto, geralmente tendem a usar uma sequência ou um número para expressar valores de data e hora. Se uma string é usada, geralmente você pode esperar que ela esteja no formato ISO 8601. Se um número for usado, em vez disso, geralmente o valor significa o número de milissegundos em Tempo Universal Coordenado (UTC) desde a época, em que a época é definida como meia-noite de 1º de janeiro de 1970 (UTC). Novamente, isso é uma mera convenção e não faz parte do padrão JSON. Se você estiver trocando dados com outro aplicativo, precisará verificar sua documentação para ver como ele codifica valores de data e hora em um literal JSON. Por exemplo, o ASP.NET AJAX da Microsoft não usa nenhuma das convenções descritas. Em vez disso, ele codifica os valores do .NET DateTime como uma string JSON, em que o conteúdo da string é / Date (ticks) / e onde ticks representa milissegundos desde a época (UTC). Então, 29 de novembro de 1989, 4:55:30, no UTC, é codificado como "\ / Date (628318530718) \ /". NET AJAX não usa nenhuma das convenções descritas. Em vez disso, ele codifica os valores do .NET DateTime como uma string JSON, em que o conteúdo da string é / Date (ticks) / e onde ticks representa milissegundos desde a época (UTC). Então, 29 de novembro de 1989, 4:55:30, no UTC, é codificado como "\ / Date (628318530718) \ /". NET AJAX não usa nenhuma das convenções descritas. Em vez disso, ele codifica os valores do .NET DateTime como uma string JSON, em que o conteúdo da string é / Date (ticks) / e onde ticks representa milissegundos desde a época (UTC). Então, 29 de novembro de 1989, 4:55:30, no UTC, é codificado como "\ / Date (628318530718) \ /".

Uma solução seria apenas analisá-lo:

value = new Date(parseInt(value.replace("/Date(", "").replace(")/",""), 10));

No entanto, ouvi dizer que há uma configuração em algum lugar para fazer com que o serializador produza DateTimeobjetos com a new Date(xxx)sintaxe. Vou tentar descobrir isso.

O segundo parâmetro de JSON.parse()aceita uma reviverfunção onde prescreve como o valor originalmente produzido por, antes de ser retornado.

Aqui está um exemplo de data:

var parsed = JSON.parse(data, function(key, value) {
  if (typeof value === 'string') {
    var d = /\/Date\((\d*)\)\//.exec(value);
    return (d) ? new Date(+d[1]) : value;
  }
  return value;
});

Veja os documentos de JSON.parse ()

Aqui está a minha solução em Javascript - muito parecida com a do JPot, mas mais curta (e possivelmente um pouco mais rápida):

value = new Date(parseInt(value.substr(6)));

"value.substr (6)" remove a parte "/ Date (" e a função parseInt ignora os caracteres não numéricos que ocorrem no final.

EDIT: Eu intencionalmente deixei de fora a raiz (o segundo argumento para analisarInt); veja meu comentário abaixo . Além disso, observe que as datas ISO-8601 são preferidas a esse formato antigo - portanto, esse formato geralmente não deve ser usado para novos desenvolvimentos. Veja a excelente biblioteca Json.NET para uma ótima alternativa que serializa datas usando o formato ISO-8601.

Para datas JSON no formato ISO-8601, basta passar a string para o construtor Date:

var date = new Date(jsonDate); //no ugly parsing needed; full timezone support

Existem algumas respostas para lidar com isso no lado do cliente, mas você pode alterar o lado do servidor de saída, se desejar.

Existem algumas maneiras de abordar isso, vou começar com o básico. Você precisará subclassificar a classe JsonResult e substituir o método ExecuteResult. A partir daí, você pode adotar algumas abordagens diferentes para alterar a serialização.

Abordagem 1: A implementação padrão usa o JsonScriptSerializer . Se você der uma olhada na documentação, poderá usar o método RegisterConverters para adicionar JavaScriptConverters personalizados . Existem alguns problemas com isso: o JavaScriptConverter serializa em um dicionário, ou seja, pega um objeto e serializa em um dicionário Json. Para tornar o objeto serializado em uma string, é necessário um pouco de hackery, veja post . Este hack particular também escapará da string.

public class CustomJsonResult : JsonResult
{
    private const string _dateFormat = "yyyy-MM-dd HH:mm:ss";

    public override void ExecuteResult(ControllerContext context)
    {
        if (context == null)
        {
            throw new ArgumentNullException("context");
        }

        HttpResponseBase response = context.HttpContext.Response;

        if (!String.IsNullOrEmpty(ContentType))
        {
            response.ContentType = ContentType;
        }
        else
        {
            response.ContentType = "application/json";
        }
        if (ContentEncoding != null)
        {
            response.ContentEncoding = ContentEncoding;
        }
        if (Data != null)
        {
            JavaScriptSerializer serializer = new JavaScriptSerializer();

            // Use your custom JavaScriptConverter subclass here.
            serializer.RegisterConverters(new JavascriptConverter[] { new CustomConverter });

            response.Write(serializer.Serialize(Data));
        }
    }
}

Abordagem 2 (recomendada): A segunda abordagem é começar com o JsonResult substituído e ir com outro serializador Json, no meu caso, o serializador Json.NET . Isso não requer a invasão da abordagem 1. Aqui está minha implementação da subclasse JsonResult:

public class CustomJsonResult : JsonResult
{
    private const string _dateFormat = "yyyy-MM-dd HH:mm:ss";

    public override void ExecuteResult(ControllerContext context)
    {
        if (context == null)
        {
            throw new ArgumentNullException("context");
        }

        HttpResponseBase response = context.HttpContext.Response;

        if (!String.IsNullOrEmpty(ContentType))
        {
            response.ContentType = ContentType;
        }
        else
        {
            response.ContentType = "application/json";
        }
        if (ContentEncoding != null)
        {
            response.ContentEncoding = ContentEncoding;
        }
        if (Data != null)
        {
            // Using Json.NET serializer
            var isoConvert = new IsoDateTimeConverter();
            isoConvert.DateTimeFormat = _dateFormat;
            response.Write(JsonConvert.SerializeObject(Data, isoConvert));
        }
    }
}

Exemplo de uso:

[HttpGet]
public ActionResult Index() {
    return new CustomJsonResult { Data = new { users=db.Users.ToList(); } };
}

Créditos adicionais: James Newton-King

Moment.js é uma extensa biblioteca de data e hora que também suporta isso. http://momentjs.com/docs/#/parsing/asp-net-json-dates/

ex: momento ("/ Data (1198908717056-0700) /")

Isso pode ajudar. saída do plunker

Descobri que criar um novo JsonResulte retornar não é satisfatório - ter que substituir todas as chamadas return Json(obj)por return new MyJsonResult { Data = obj }é uma dor.

Então eu pensei, por que não apenas seqüestrar o JsonResultuso de um ActionFilter:

public class JsonNetFilterAttribute : ActionFilterAttribute
{
    public override void OnActionExecuted(ActionExecutedContext filterContext)
    {
        if (filterContext.Result is JsonResult == false)
        {
            return;
        }

        filterContext.Result = new JsonNetResult(
            (JsonResult)filterContext.Result);
    }

    private class JsonNetResult : JsonResult
    {
        public JsonNetResult(JsonResult jsonResult)
        {
            this.ContentEncoding = jsonResult.ContentEncoding;
            this.ContentType = jsonResult.ContentType;
            this.Data = jsonResult.Data;
            this.JsonRequestBehavior = jsonResult.JsonRequestBehavior;
            this.MaxJsonLength = jsonResult.MaxJsonLength;
            this.RecursionLimit = jsonResult.RecursionLimit;
        }

        public override void ExecuteResult(ControllerContext context)
        {
            if (context == null)
            {
                throw new ArgumentNullException("context");
            }

            var isMethodGet = string.Equals(
                context.HttpContext.Request.HttpMethod, 
                "GET", 
                StringComparison.OrdinalIgnoreCase);

            if (this.JsonRequestBehavior == JsonRequestBehavior.DenyGet
                && isMethodGet)
            {
                throw new InvalidOperationException(
                    "GET not allowed! Change JsonRequestBehavior to AllowGet.");
            }

            var response = context.HttpContext.Response;

            response.ContentType = string.IsNullOrEmpty(this.ContentType) 
                ? "application/json" 
                : this.ContentType;

            if (this.ContentEncoding != null)
            {
                response.ContentEncoding = this.ContentEncoding;
            }

            if (this.Data != null)
            {
                response.Write(JsonConvert.SerializeObject(this.Data));
            }
        }
    }
}

Isso pode ser aplicado a qualquer método que retorne a JsonResultpara usar o JSON.Net:

[JsonNetFilter]
public ActionResult GetJson()
{
    return Json(new { hello = new Date(2015, 03, 09) }, JsonRequestBehavior.AllowGet)
}

que responderá com

{"hello":"2015-03-09T00:00:00+00:00"}

como desejado!

Você pode, se não se importar em chamar a iscomparação a cada solicitação, adicione isso ao seu FilterConfig:

// ...
filters.Add(new JsonNetFilterAttribute());

e todo o seu JSON agora será serializado com o JSON.Net em vez do incorporado JavaScriptSerializer.

Usando o jQuery para converter automaticamente datas com $.parseJSON

Nota : esta resposta fornece uma extensão jQuery que adiciona suporte automático ao formato de data ISO e .net.

Como você está usando o Asp.net MVC, suspeito que esteja usando o jQuery no lado do cliente. Sugiro que você leia esta postagem do blog que possui um código como usar $.parseJSONpara converter automaticamente datas para você.

O código suporta datas formatadas em Asp.net, como as mencionadas, bem como datas formatadas em ISO. Todas as datas serão formatadas automaticamente para você usando $.parseJSON().

A comunicação Ajax entre o cliente e o servidor geralmente envolve dados no formato JSON. Embora o JSON funcione bem para strings, números e booleanos, ele pode apresentar algumas dificuldades para datas devido à maneira como o ASP.NET as serializa. Como não possui representação especial para datas, elas são serializadas como strings simples. Como solução, o mecanismo de serialização padrão do ASP.NET Web Forms e MVC serializa datas em um formato especial - / Data (ticks) / - em que ticks é o número de milissegundos desde 1 de janeiro de 1970.

Este problema pode ser resolvido de duas maneiras:

lado do cliente

Converta a sequência de datas recebida em um número e crie um objeto de data usando o construtor da classe date com os ticks como parâmetro.

function ToJavaScriptDate(value) {
  var pattern = /Date\(([^)]+)\)/;
  var results = pattern.exec(value);
  var dt = new Date(parseFloat(results[1]));
  return (dt.getMonth() + 1) + "/" + dt.getDate() + "/" + dt.getFullYear();
}

lado do servidor

A solução anterior usa um script do lado do cliente para converter a data em um objeto Data JavaScript. Você também pode usar o código do lado do servidor que serializa instâncias do .NET DateTime no formato de sua escolha. Para realizar essa tarefa, você precisa criar seu próprio ActionResult e serializar os dados da maneira que desejar.

referência: http://www.developer.com/net/dealing-with-json-dates-in-asp.net-mvc.html

Eu tive o mesmo problema e, em vez de retornar o valor da data real, usei o ToString ("dd MMM aaaa") nele. Em seguida, no meu javascript, usei a nova data (valor do dado), em que o valor do dado pode ser "01 de janeiro de 2009".

Veja este tópico:

http://forums.asp.net/p/1038457/1441866.aspx#1441866

Basicamente, enquanto o Date()formato é javascript válido, NÃO é JSON válido (há uma diferença). Se você deseja o formato antigo, provavelmente precisará criar uma fachada e transformar o valor por conta própria, ou encontrar uma maneira de acessar o serializador para seu tipo JsonResulte usar um formato personalizado para datas.

Não é a maneira mais elegante, mas isso funcionou para mim:

var ms = date.substring(6, date.length - 2);
var newDate = formatDate(ms);


function formatDate(ms) {

    var date = new Date(parseInt(ms));
    var hour = date.getHours();
    var mins = date.getMinutes() + '';
    var time = "AM";

    // find time 
    if (hour >= 12) {
        time = "PM";
    }
    // fix hours format
    if (hour > 12) {
        hour -= 12;
    }
    else if (hour == 0) {
        hour = 12;
    }
    // fix minutes format
    if (mins.length == 1) {
        mins = "0" + mins;
    }
    // return formatted date time string
    return date.getMonth() + 1 + "/" + date.getDate() + "/" + date.getFullYear() + " " + hour + ":" + mins + " " + time;
}

Eu tenho trabalhado em uma solução para esse problema, pois nenhuma das respostas acima realmente me ajudou. Estou trabalhando com o calendário da semana do jquery e precisava que minhas datas tivessem informações de fuso horário no servidor e localmente na página. Depois de pesquisar um pouco, descobri uma solução que pode ajudar os outros.

Estou usando o asp.net 3.5, vs 2008, asp.net MVC 2 e jquery week calendar,

Primeiro, estou usando uma biblioteca escrita por Steven Levithan que ajuda a lidar com datas no lado do cliente, a biblioteca de datas de Steven Levithan . O formato isoUtcDateTime é perfeito para o que eu precisava. Na minha chamada AJAX do jquery, uso a função format fornecida com a biblioteca com o formato isoUtcDateTime e quando a chamada ajax atinge meu método de ação, o datetime Kind é definido como local e reflete a hora do servidor.

Quando envio datas para minha página via AJAX, as envio como sequências de texto formatando as datas usando "ddd, dd MMM aaaa HH ':' mm ':' ss 'GMT'zzzz". Esse formato é facilmente convertido no lado do cliente usando

var myDate = new Date(myReceivedDate);

Aqui está minha solução completa, menos a fonte de Steve Levithan, que você pode baixar:

Controlador:

public class HomeController : Controller
{
    public const string DATE_FORMAT = "ddd, dd MMM yyyy HH':'mm':'ss 'GMT'zzzz";

    public ActionResult Index()
    {
        ViewData["Message"] = "Welcome to ASP.NET MVC!";

        return View();
    }

    public ActionResult About()
    {
        return View();
    }


    public JsonResult GetData()
    {
        DateTime myDate = DateTime.Now.ToLocalTime();

        return new JsonResult { Data = new { myDate = myDate.ToString(DATE_FORMAT) } };
    }

    public JsonResult ReceiveData(DateTime myDate)
    {
        return new JsonResult { Data = new { myDate = myDate.ToString(DATE_FORMAT) } };
    }
}

Javascript:

<script type="text/javascript">

function getData() {
    $.ajax({
        url: "/Home/GetData",
        type: "POST",
        cache: "false",
        dataType: "json",
        success: function(data) {
            alert(data.myDate);
            var newDate = cleanDate(data.myDate);
            alert(newDate);
            sendData(newDate);
        }
    });
} 

function cleanDate(d) {
    if (typeof d == 'string') {
        return new Date(d) || Date.parse(d) || new Date(parseInt(d));
    }
    if (typeof d == 'number') {
        return new Date(d);
    }
    return d;
}

function sendData(newDate) {
    $.ajax({
        url: "/Home/ReceiveData",
        type: "POST",
        cache: "false",
        dataType: "json",
        data:
        {
            myDate: newDate.format("isoUtcDateTime")
        },
        success: function(data) {
            alert(data.myDate);
            var newDate = cleanDate(data.myDate);
            alert(newDate);
        }
    });
}

// bind myButton click event to call getData
$(document).ready(function() {
    $('input#myButton').bind('click', getData);
});
</script>

Espero que este exemplo rápido ajude outras pessoas na mesma situação em que eu estava. No momento, parece funcionar muito bem com a serialização JSON da Microsoft e mantém minhas datas corretas nos fusos horários.

A melhor maneira de lidar com datas no knockoutjs é usar a biblioteca de momentos e lidar com datas como o chefe. Você pode lidar facilmente com datas como / Data (-62135578800000) /. Não há necessidade de se preocupar com a data de serialização no controlador.

function jsonToDate(date,format) {
   return moment(date).format(format);
}

use-o como

var formattedDate = jsonToDate(date,'MM/DD/YYYY')

O momentjs suporta muitos formatos de data e funções utilitárias em datas.

Formate a data na consulta.

var _myModel = from _m in model.ModelSearch(word)
    select new { date = ((DateTime)_m.Date).ToShortDateString() };

O único problema com esta solução é que você não obterá nenhum resultado se QUALQUER valor da data for nulo. Para contornar isso, você pode colocar instruções condicionais na sua consulta ANTES de selecionar a data que ignora os valores nulos da data ou configurar uma consulta para obter todos os resultados e percorrer todas essas informações usando um loop foreach e atribuir um valor para todas as datas que são nulas ANTES de fazer seu SELECT novo.

Exemplo de ambos:

var _test = from _t in adc.ItemSearchTest(word)
                        where _t.Date != null
                        select new { date = ((DateTime)_t.Date).ToShortDateString() };

A segunda opção requer outra consulta inteiramente, para que você possa atribuir valores a todos os nulos. Esse e o loop foreach teriam que ser ANTES da sua consulta que seleciona os valores.

var _testA = from _t in adc.ItemSearchTest(word)
                         select _i;

            foreach (var detail in _testA)
            {
                if (detail.Date== null)
                {
                    detail.Date= Convert.ToDateTime("1/1/0001");
                }
            }

Apenas uma ideia que achei mais fácil do que todos os exemplos de javascript.

Você pode usar este método:

String.prototype.jsonToDate = function(){
    try{
        var date;
        eval(("date = new " + this).replace(/\//g,''));
        return date;
    } 
    catch(e){
        return new Date(0);
    }
};

0 0

No seu cshtml,

<tr ng-repeat="value in Results">                
 <td>{{value.FileReceivedOn | mydate | date : 'dd-MM-yyyy'}} </td>
</tr>

No seu arquivo JS, talvez app.js,

Fora do app.controller, adicione o filtro abaixo.

Aqui, a "minha data" é a função que você está chamando para analisar a data. Aqui, o "app" é a variável que contém o angular.module

app.filter("mydate", function () {
    var re = /\/Date\(([0-9]*)\)\//;
    return function (x) {
        var m = x.match(re);
        if (m) return new Date(parseInt(m[1]));
        else return null;
    };
});

adicione o plugin jquery ui na sua página.

function JsonDateFormate(dateFormate, jsonDateTime) {
    return $.datepicker.formatDate(dateFormate, eval('new ' + jsonDateTime.slice(1, -1)));
};

Não é por nada, mas existe outro caminho. Primeiro, construa sua consulta LINQ. Em seguida, construa uma consulta do resultado enumerado e aplique qualquer tipo de formatação que funcione para você.

var query = from t in db.Table select new { t.DateField };
var result = from c in query.AsEnumerable() select new { c.DateField.toString("dd MMM yyy") };

Devo dizer que o passo extra é irritante, mas funciona muito bem.

O que funcionou para mim foi criar um viewmodel que contivesse a propriedade date como uma string. Atribuindo a propriedade DateTime a partir do modelo de domínio e chamando o .ToString () na propriedade date enquanto atribui o valor ao viewmodel.

Um resultado JSON de um método de ação MVC retornará a data em um formato compatível com a visualização.

Ver modelo

public class TransactionsViewModel
{
    public string DateInitiated { get; set; }
    public string DateCompleted { get; set; }
}

Modelo de domínio

public class Transaction{
   public DateTime? DateInitiated {get; set;}
   public DateTime? DateCompleted {get; set;}
}

Método de Ação do Controlador

public JsonResult GetTransactions(){

var transactions = _transactionsRepository.All;
        var model = new List<TransactionsViewModel>();

        foreach (var transaction in transactions)
        {
            var item = new TransactionsViewModel
            {
                ...............
                DateInitiated = transaction.DateInitiated.ToString(),
                DateCompleted = transaction.DateCompleted.ToString(),
            };

            model.Add(item);
        }
        return Json(model, JsonRequestBehavior.AllowGet);
}

Substitua os controladores Json / JsonResult para retornar JSON.Net:

Isso funciona um tratamento

Irritante, não é?

Minha solução foi alterar meu serviço WCF para que ele retornasse o DateTimes em um formato mais legível (não Microsoft). Observe abaixo " UpdateDateOriginal", que é o formato padrão de datas do WCF, e meu " UpdateDate", que está formatado para algo mais legível.

Veja como fazê-lo:

Alterando o formato da data do WCF

Espero que isto ajude.

Eu achei que essa era a maneira mais fácil de mudar o lado do servidor.

using System.Collections.Generic;
using System.Web.Mvc;
using Newtonsoft.Json;
using Newtonsoft.Json.Converters;
using Newtonsoft.Json.Serialization;

namespace Website
{
    /// <summary>
    /// This is like MVC5's JsonResult but it uses CamelCase and date formatting.
    /// </summary>
    public class MyJsonResult : ContentResult
    {
        private static readonly JsonSerializerSettings Settings = new JsonSerializerSettings
        {
            ContractResolver = new CamelCasePropertyNamesContractResolver(),
            Converters = new List<JsonConverter> { new StringEnumConverter() }
        };

        public FindersJsonResult(object obj)
        {
            this.Content = JsonConvert.SerializeObject(obj, Settings);
            this.ContentType = "application/json";
        }
    }
}

Tive vários problemas com as datas JSON e decidi me livrar do problema resolvendo o problema de data no SQL. Alterar o formato da data para um formato de sequência

select flddate from tblName

select flddate, convert(varchar(12), flddate, 113) as fldDateStr from tblName

Usando o fldDateStr, o problema desapareceu e eu ainda poderia usar o campo de data para classificação ou outros fins.

Ele retorna o formato de data do servidor. Você precisa definir sua própria função.

function jsonDateFormat(jsonDate) {
  // Changed data format;
  return (new Date(parseInt(jsonDate.substr(6)))).format("mm-dd-yyyy / h:MM tt");
};

Aqui está um código JavaScript que escrevi que define um <input type="date">valor a partir de uma data passada do ASP.NET MVC.

var setDate = function(id, d) {
  if (d !== undefined && d !== null) {
    var date = new Date(parseInt(d.replace("/Date(", "").replace(")/", ""), 10));
    var day = ('0' + date.getDate()).slice(-2);
    var month = ('0' + (date.getMonth() + 1)).slice(-2);
    var parsedDate = date.getFullYear() + "-" + (month) + "-" + (day);
    $(id).val(parsedDate);
  }
};

Você chama essa função assim:

setDate('#productCommissionStartDate', data.commissionStartDate);

Onde commissionStartDateé a data JSON passada pelo MVC.

O mais fácil:

var milisegundos = parseInt (data.replace ("/ Date (", "") .replace (") /", "")));
Var newDate = new Date (milisegundos). toLocaleDateString ("en-UE");