Formato data ASP.NET MVC JsonResult


248

Ho un'azione del controller che restituisce semplicemente un JsonResult del mio modello. Quindi, nel mio metodo ho qualcosa di simile al seguente:

return new JsonResult(myModel);

Funziona bene, tranne per un problema. C'è una proprietà date nel modello e questa sembra essere restituita nel risultato Json in questo modo:

"\/Date(1239018869048)\/"

Come devo gestire le date in modo che vengano restituite nel formato richiesto? O come gestisco questo formato sopra nello script?


Ho pubblicato il mio risultato netto json sullo stesso problema, converte la data in formato iso rendendolo molto più facile da lavorare. stackoverflow.com/questions/15778599/…
Kieran,

Si prega di guardare in questo link qui sotto. Dritto. stackoverflow.com/a/60392503/5962626
Mohamedasiq

Risposte:


195

Solo per espandere la risposta di casperOne .

Le specifiche JSON non tengono conto dei valori di Data. MS ha dovuto effettuare una chiamata e il percorso scelto è stato quello di sfruttare un piccolo trucco nella rappresentazione javascript delle stringhe: la stringa letterale "/" è uguale a "\ /" e una stringa letterale non verrà mai serializzata su " \ / "(anche" \ / "deve essere mappato su" \\ / ").

Consulta http://msdn.microsoft.com/en-us/library/bb299886.aspx#intro_to_json_topic2 per una spiegazione migliore (scorri verso il basso fino a "From JavaScript Literals to JSON")

Uno dei punti dolenti di JSON è la mancanza di una data / ora letterale. Molte persone sono sorprese e deluse nell'apprendere ciò quando incontrano per la prima volta JSON. La semplice spiegazione (consolante o no) dell'assenza di un valore letterale di data / ora è che JavaScript non ne ha mai avuto uno: Il supporto per i valori di data e ora in JavaScript è interamente fornito tramite l'oggetto Date. La maggior parte delle applicazioni che utilizzano JSON come formato di dati, pertanto, generalmente tendono a utilizzare una stringa o un numero per esprimere i valori di data e ora. Se viene utilizzata una stringa, generalmente ci si può aspettare che sia nel formato ISO 8601. Se viene utilizzato un numero, invece, il valore viene generalmente utilizzato per indicare il numero di millisecondi in Universal Coordinated Time (UTC) dall'epoca, in cui l'epoca è definita come mezzanotte del 1 gennaio 1970 (UTC). Ancora, questa è una semplice convenzione e non fa parte dello standard JSON. Se si scambiano dati con un'altra applicazione, sarà necessario controllare la sua documentazione per vedere come codifica i valori di data e ora all'interno di un valore letterale JSON. Ad esempio, ASP.NET AJAX di Microsoft non utilizza nessuna delle convenzioni descritte. Piuttosto, codifica i valori .NET DateTime come una stringa JSON, dove il contenuto della stringa è / Date (tick) / e dove tick rappresenta millisecondi dall'epoca (UTC). Quindi il 29 novembre 1989, alle 4:55:30, in UTC è codificato come "\ / Date (628318530718) \ /". NET AJAX non utilizza nessuna delle convenzioni descritte. Piuttosto, codifica i valori .NET DateTime come una stringa JSON, dove il contenuto della stringa è / Date (tick) / e dove tick rappresenta millisecondi dall'epoca (UTC). Quindi il 29 novembre 1989, alle 4:55:30, in UTC è codificato come "\ / Date (628318530718) \ /". NET AJAX non utilizza nessuna delle convenzioni descritte. Piuttosto, codifica i valori .NET DateTime come una stringa JSON, dove il contenuto della stringa è / Date (tick) / e dove tick rappresenta millisecondi dall'epoca (UTC). Quindi il 29 novembre 1989, alle 4:55:30, in UTC è codificato come "\ / Date (628318530718) \ /".

Una soluzione sarebbe semplicemente analizzarla:

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

Tuttavia ho sentito che esiste un'impostazione da qualche parte per consentire al serializzatore di produrre DateTimeoggetti con la new Date(xxx)sintassi. Proverò a scavarlo.


Il secondo parametro JSON.parse()accetta una reviverfunzione in cui prescrive come il valore originariamente prodotto da, prima di essere restituito.

Ecco un esempio per 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;
});

Consulta i documenti di JSON.parse ()


1
Grazie, dove andrebbe comunque l'analisi?
Jon Archway,

Il codice che ho pubblicato è JavaScript. Lo inseriresti nel tuo codice cliente.
JPot

6
Puoi accorciare js alla nuova Data (parseInt (dateString.replace (/ \ / Date \ ((\ d +) \) \ // gi, "$ 1")))
kͩeͣmͮpͥ ͩ

6
In effetti la regex è più corretta in quanto sostituisce (/ \ / Date \ ((-? \ D +) \) \ // gi, "$ 1") poiché la data può essere rappresentata anche come un numero
-ve

1
@HarshilShah Questo è il secondo argomento per parseInt(). Indica alla funzione di estrarre un numero intero nel sistema numerico di base 10. È un radix. Se lo metti 8lì, estrarrebbe un numero ottale.
AnalogWeapon

99

Ecco la mia soluzione in Javascript - molto simile a quella di JPot, ma più corta (e forse un po 'più veloce):

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

"value.substr (6)" estrae la parte "/ Date (" e la funzione parseInt ignora i caratteri non numerici che si presentano alla fine.

EDIT: ho intenzionalmente escluso il radix (il secondo argomento da analizzare); vedi il mio commento qui sotto . Inoltre, tieni presente che le date ISO-8601 sono preferite rispetto a questo vecchio formato, quindi questo formato generalmente non dovrebbe essere usato per nuovi sviluppi. Guarda l'eccellente libreria Json.NET per un'ottima alternativa che serializza le date usando il formato ISO-8601.

Per le date JSON formattate ISO-8601, basta passare la stringa nel costruttore Date:

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

1
+1 Ho preso la tua soluzione semplice e l'ho messa in una funzione ricorsiva. Vedi qui: danielsadventure.info/dotnetdatetime
Fiume Vivian,

7
Dovresti sempre specificare una radice quando usi parseInt. [Fonte]: developer.mozilla.org/en-US/docs/JavaScript/Reference/…
John Zabroski,

6
@JohnZabroski: ogni regola ha le sue eccezioni. Il serializzatore di date .NET non restituisce mai numeri interi con zeri iniziali, quindi possiamo tranquillamente tralasciare Radix.
Roy Tinker,

4
Avevamo quasi la stessa cosa. Abbiamo usato value.substr(6, 13)per rimuovere gli altri caratteri non numerici. Ma se lo fai, tutte le date PRIMA del 26/04/1938 non sono valide! Non sapevamo che parseIntavrebbe ignorato i caratteri non numerici. Grazie!
Ralph Jansen,

2
@ JohnZabroski— parseIntdovrebbe ignorare gli zeri iniziali a partire da ECMAScript ed 5 (2011).
RobG,

69

Ci sono un bel po 'di risposte per gestirlo lato client, ma se lo desideri puoi cambiare il lato server di output.

Ci sono alcuni modi per affrontare questo, inizierò con le basi. Dovrai sottoclassare la classe JsonResult e sovrascrivere il metodo ExecuteResult. Da lì è possibile adottare alcuni approcci diversi per modificare la serializzazione.

Approccio 1: l'implementazione predefinita utilizza JsonScriptSerializer . Se dai un'occhiata alla documentazione, puoi utilizzare il metodo RegisterConverters per aggiungere JavaScriptConverter personalizzati . Tuttavia, ci sono alcuni problemi: JavaScriptConverter serializza su un dizionario, ovvero prende un oggetto e serializza su un dizionario Json. Per rendere l'oggetto serializzato su una stringa richiede un po 'di hacker, vedi post . Questo particolare hack sfuggirà anche alla stringa.

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

Approccio 2 (consigliato): il secondo approccio è iniziare con JsonResult ignorato e passare a un altro serializzatore Json, nel mio caso il serializzatore Json.NET . Questo non richiede la pirateria informatica dell'approccio 1. Ecco la mia implementazione della sottoclasse 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));
        }
    }
}

Esempio di utilizzo:

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

Crediti aggiuntivi: James Newton-King


E gli altri formati come monetari, numeri di identificazione, telefono e così via? Non è un approccio migliore per ottenere questi formati da ModelMetadata e usarli per serializzare i modelli su Json? Come ?
Luciano,

1
Questa è la soluzione migliore (la risposta di Perishable Dave). Il server è responsabile di fornire il formato data corretto. Anche avere un JsonResult personalizzato offre molti più vantaggi e controllo. Suggerirei di implementare un metodo di supporto "CustomJson (dati)" che crea un'istanza di CustomJsonResult in quanto esiste "Json (dati)", che crea un'istanza di JsonResult con i suoi dati.
sport

2
È necessaria una correzione se si utilizza uno di questi approcci: la prima riga dovrebbe essere: private const string _dateFormat = "yyyy-MM-ddTHH: mm: ss"; Ho aggiunto la "T".
Dominick,


20

Ho scoperto che creare un nuovo JsonResulte tornare che non è soddisfacente - dover sostituire tutte le chiamate return Json(obj)con return new MyJsonResult { Data = obj }è un dolore.


Quindi ho pensato, perché non dirottare semplicemente JsonResultusando un 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));
            }
        }
    }
}

Questo può essere applicato a qualsiasi metodo che restituisca a JsonResultper usare JSON.Net invece:

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

che risponderà con

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

come desiderato!


Se non ti dispiace chiamare il isconfronto ad ogni richiesta, puoi aggiungerlo al tuo FilterConfig:

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

e tutto il tuo JSON sarà ora serializzato con JSON.Net invece che incorporato JavaScriptSerializer.


Questa è l'unica risposta che fornisce un approccio solido (può essere impostato come globale o granulare) senza strani javascript in linea. Posso votare due volte?
T-moty,

19

Utilizzando jQuery per convertire automaticamente le date con $.parseJSON

Nota : questa risposta fornisce un'estensione jQuery che aggiunge il supporto automatico per il formato data ISO e .net.

Dal momento che stai usando Asp.net MVC sospetto che tu stia usando jQuery sul lato client. Ti suggerisco di leggere questo post sul blog che ha il codice su come usare$.parseJSON per convertire automaticamente le date per te.

Il codice supporta date formattate Asp.net come quelle che hai citato, nonché date formattate ISO. Tutte le date verranno formattate automaticamente per te utilizzando $.parseJSON().


2
All'inizio ho pensato che questo approccio funzionasse molto bene. (Vedi i commenti alla fine dell'articolo su come registrare un convertitore in $ .ajaxSetup ()) Tuttavia, un grande svantaggio di questa soluzione è che non supporta le date precedenti a Epoc (1970) ..... quindi ora ho ha deciso di rinunciare ai file .asmx e passare a WebAPI quali formati risale meglio (usando JSON.NET) e aggirerà tutti questi problemi.
ClearCloud8,

11

La comunicazione Ajax tra il client e il server comporta spesso dati in formato JSON. Mentre JSON funziona bene per stringhe, numeri e valori booleani, può comportare alcune difficoltà per le date a causa del modo in cui ASP.NET li serializza. Poiché non ha alcuna rappresentazione speciale per le date, sono serializzate come stringhe semplici. Come soluzione, il meccanismo di serializzazione predefinito di ASP.NET Web Form e MVC serializza le date in un modulo speciale - / Data (tick) / - dove tick è il numero di millisecondi dal 1 ° gennaio 1970.

Questo problema può essere risolto in 2 modi:

dalla parte del cliente

Converti la stringa di data ricevuta in un numero e crea un oggetto data usando il costruttore della classe di data con i segni di spunta come parametro.

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

lato server

La soluzione precedente utilizza uno script lato client per convertire la data in un oggetto Date JavaScript. È inoltre possibile utilizzare il codice lato server che serializza le istanze di DateTime .NET nel formato desiderato. Per eseguire questa operazione è necessario creare il proprio ActionResult e quindi serializzare i dati nel modo desiderato.

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


7

Ho avuto lo stesso problema e invece di restituire il valore della data effettiva ho usato ToString ("gg MMM yyyy"). Quindi nel mio javascript ho usato la nuova data (datevalue), dove datevalue potrebbe essere "01 Jan 2009".


1
Questo dovrebbe avere molti più voti. È almeno buono come quelli più votati. Un po 'più elegante di tagliare le corde. Personalmente, l'ho usato ma non ho ricreato l'oggetto data sul front-end in quanto avevo solo bisogno di visualizzarlo, quindi ho appena visualizzato la stringa (leggermente diversa) formattata. Grazie per la punta, @Joe!
Vbullinger,

1
Si rompe la separazione delle preoccupazioni, vale a dire ponendo la preoccupazione di come una data viene mostrata sul front-end nel back-end. Ma meh, è ​​ancora più elegante.
A. Murray,

1
Perché non usare qualcosa di meno fragile, come ToString("o")?
binki,

"dd MMM yyyy" non è supportato da ECMA-262, quindi non dovresti aspettarti che il parser incorporato lo
analizzi

3

Vedi questa discussione:

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

Fondamentalmente, mentre il Date()formato è javascript valido, NON è JSON valido (c'è una differenza). Se vuoi il vecchio formato, probabilmente dovrai creare una facciata e trasformare il valore da solo, o trovare un modo per ottenere il serializzatore per il tuo tipo nel JsonResulte farlo usare un formato personalizzato per le date.


Pensi di voler dire "mentre il nuovo formato Date () è javascript valido" [nota la "nuova" parola chiave]?
JPot

2

Non è il modo più elegante ma questo ha funzionato per me:

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

2

Ho lavorato su una soluzione a questo problema in quanto nessuna delle risposte di cui sopra mi ha davvero aiutato. Sto lavorando con il calendario della settimana jquery e avevo bisogno che le mie date avessero le informazioni sul fuso orario sul server e localmente sulla pagina. Dopo un bel po 'di ricerche, ho scoperto una soluzione che potrebbe aiutare gli altri.

Sto usando asp.net 3.5, vs 2008, asp.net MVC 2 e il calendario settimanale jquery,

In primo luogo, sto usando una libreria scritta da Steven Levithan che aiuta a gestire le date sul lato client, la libreria di date di Steven Levithan . Il formato isoUtcDateTime è perfetto per quello di cui avevo bisogno. Nella mia chiamata AJAX jquery utilizzo la funzione di formato fornita con la libreria con il formato isoUtcDateTime e quando la chiamata ajax raggiunge il mio metodo di azione, il datetime Kind è impostato su local e riflette l'ora del server.

Quando invio le date alla mia pagina tramite AJAX, le invio come stringhe di testo formattando le date usando "ddd, dd MMM yyyy HH ':' mm ':' ss 'GMT'zzzz". Questo formato può essere facilmente convertito dal lato client utilizzando

var myDate = new Date(myReceivedDate);

Ecco la mia soluzione completa meno la fonte di Steve Levithan, che puoi scaricare:

controller:

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>

Spero che questo rapido esempio aiuti gli altri nella stessa situazione in cui mi trovavo. In questo momento sembra funzionare molto bene con la serializzazione Microsoft JSON e mantiene le mie date corrette su più fusi orari.


Se è possibile specificare il formato della data, è necessario utilizzare ISO 8601 esteso in quanto è l'unico formato per cui ECMA-262 richiede supporto.
RobG

2

Il modo migliore per gestire le date in knockoutjs è usare la libreria dei momenti e gestire le date come boss. Puoi facilmente gestire date come / Date (-62135578800000) /. Non c'è bisogno di preoccuparsi di come la data di serializzazione nel controller.

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

usalo come

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

momentjs supporta molti formati di data e ora e funzioni di utilità per le date.


1

Formatta la data all'interno della query.

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

L'unico problema con questa soluzione è che non otterrai alcun risultato se QUALUNQUE dei valori di data sono nulli. Per ovviare a questo problema, è possibile inserire istruzioni condizionali nella query PRIMA di selezionare la data che ignora i valori null della data oppure è possibile impostare una query per ottenere tutti i risultati e quindi scorrere tutte le informazioni utilizzando un ciclo foreach e assegnare un valore a tutte le date che sono null PRIMA di eseguire il nuovo SELECT.

Esempio di entrambi:

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

La seconda opzione richiede un'altra query interamente in modo da poter assegnare valori a tutti i valori null. Questo e il ciclo foreach dovrebbero essere PRIMA della tua query che seleziona i valori.

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

Solo un'idea che ho trovato più semplice di tutti gli esempi javascript.


1

Puoi usare questo metodo:

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

1

0

Nel tuo cshtml,

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

Nel tuo file JS, forse app.js,

Al di fuori di app.controller, aggiungi il filtro in basso.

Qui "mydate" è la funzione che stai chiamando per analizzare la data. Qui "app" è la variabile che contiene 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;
    };
});

Questo è molto specifico per angularjs, non tutte le persone lo usano, ma ha funzionato per me, grazie.
Lauro182,

0

aggiungi il plugin dell'interfaccia utente jquery nella tua pagina.

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

0

Non per niente, ma c'è un altro modo. Innanzitutto, crea la tua query LINQ. Quindi, crea una query del risultato Enumerato e applica qualunque tipo di formattazione funzioni per te.

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 dire che il passaggio in più è fastidioso, ma funziona bene.


0

Ciò che ha funzionato per me è stato creare un viewmodel che contenesse la proprietà date come stringa. Assegnare la proprietà DateTime dal modello di dominio e chiamare .ToString () sulla proprietà date mentre si assegna il valore al viewmodel.

Un risultato JSON da un metodo di azione MVC restituirà la data in un formato compatibile con la vista.

Vedi modello

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

Modello di dominio

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

Metodo di azione del controller

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


0

Fastidioso, vero?

La mia soluzione era quella di cambiare il mio servizio WCF per farlo restituire DateTimes in un formato più leggibile (non Microsoft). Si noti di seguito, il " UpdateDateOriginal", che è il formato predefinito delle date di WCF, e il mio " UpdateDate", che è formattato in qualcosa di più leggibile.

inserisci qui la descrizione dell'immagine

Ecco come farlo:

Modifica del formato della data WCF

Spero che questo ti aiuti.


0

Ho trovato che questo è il modo più semplice per cambiarlo lato server.

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

0

Ho avuto una serie di problemi con le date JSON e ho deciso di sbarazzarmi del problema risolvendo il problema della data nell'SQL. Cambia il formato della data in un formato stringa

select flddate from tblName

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

Usando fldDateStr il problema è scomparso e potrei ancora utilizzare il campo data per l'ordinamento o altri scopi.


0

Restituisce il formato data del server. Devi definire la tua funzione.

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

0

Ecco un codice JavaScript che ho scritto che imposta un <input type="date">valore da una data passata da 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);
  }
};

Questa funzione viene chiamata in questo modo:

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

Dove si commissionStartDatetrova la data JSON passata da MVC.


-1

Il più semplice:

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

Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.