ASP.NET MVC JsonResult date Format

voici ma solution en Javascript - tout comme JPot, mais plus court (et peut-être un tout petit peu plus rapide):

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

valeur".substr (6) "prend la partie" /Date ( " , et la fonction parseInt ignore les caractères non-nombre qui se produisent à la fin.

EDIT: j'ai volontairement laissé de côté l'radix (le 2ème argument de parseInt); voir mon commentaire ci-dessous . Veuillez également noter que les dates ISO-8601 sont préférées. sur cet ancien format -- donc ce format ne devrait généralement pas être utilisé pour un nouveau développement. Voir l'excellent Json.NET bibliothèque pour une excellente alternative qui sérialise les dates en utilisant le format ISO-8601.

pour les dates JSON formatées ISO-8601, il suffit de passer la chaîne dans le constructeur de Date:

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

il y a pas mal de réponses pour gérer le côté client, mais vous pouvez changer le côté serveur de sortie si vous le souhaitez.

il y a plusieurs façons d'aborder cela, je vais commencer par les bases. Vous devrez classer la classe JsonResult et remplacer la méthode ExecuteResult. De là, vous pouvez prendre quelques approches différentes pour changer la sérialisation.

approche 1: La mise en œuvre par défaut utilise JsonScriptSerializer . Si vous regardez la documentation, vous pouvez utiliser la méthode RegisterConverters pour ajouter custom Javasriptconverters . Il y a quelques problèmes avec ceci cependant: le javascriptconverter serialise à un dictionnaire, c'est-à-dire qu'il prend un objet et serialise à un dictionnaire Json. Afin de rendre l'objet sérialize à une chaîne, il nécessite un peu de hackery, voir post . Ce piratage particulier va aussi échapper à la chaîne.

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

approche 2 (recommandée): La deuxième approche est de commencer avec le JsonResult surchargé et aller avec un autre serializer Json, dans mon cas le Json.NET serializer. Cela ne nécessite pas le hackery de l'approche 1. Voici ma mise en œuvre de la sous-classe 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));
        }
    }
}

Exemple D'Utilisation:

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

Crédits supplémentaires: James Newton-King

Moment.js est une bibliothèque de datetime étendue qui supporte aussi cela. http://momentjs.com/docs/#/parsing/asp-net-json-dates/

ex: ("/Date(1198908717056-0700)/")

ça pourrait aider. sortie plunker

utilisant jQuery pour auto-convertir les dates avec $.parseJSON

Note : cette réponse fournit une extension jQuery qui ajoute automatiquement la prise en charge des formats ISO et .net date.

puisque vous utilisez Asp.net MVC je soupçonne que vous utilisez jQuery du côté du client. Je vous suggère de lire ce billet de blog qui a le code comment utiliser $.parseJSON pour convertir automatiquement les dates pour vous.

Asp.net les dates formatées comme celles que vous avez mentionnées ainsi que les dates formatées ISO. Toutes les dates seront automatiquement formatées pour vous en utilisant $.parseJSON() .

j'ai trouvé que la création d'un nouveau JsonResult et le retour qui est insatisfaisant - avoir à remplacer tous les appels à return Json(obj) par return new MyJsonResult { Data = obj } est une douleur.

alors j'ai pensé, pourquoi ne pas détourner le JsonResult en utilisant 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));
            }
        }
    }
}

ceci peut être appliqué à n'importe quelle méthode retournant un JsonResult à utiliser JSON.Net à la place:

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

qui répondra par

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

comme vous le souhaitez!

vous pouvez, si cela ne vous dérange pas d'appeler la comparaison is à chaque demande, ajouter ceci à votre FilterConfig :

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

et tout votre JSON sera maintenant sérialisé avec JSON.Net au lieu du JavaScriptSerializer intégré .

communication Ajax entre le client et le serveur implique souvent des données dans le format JSON. Bien que JSON fonctionne bien pour les chaînes, les nombres et les booléens, il peut poser quelques difficultés pour les dates en raison de la façon ASP.NET les sérialise. Comme il n'y a pas de représentation spéciale pour les dates, elles sont sérialisées en chaînes simples. Comme solution le mécanisme de sérialisation par défaut de ASP.NET formulaires Web et MVC sérialise les dates dans un formulaire spécial - / Date (tiques) / - où le nombre de tiques est le nombre de millisecondes depuis le 1er janvier 1970.

ce problème peut être résolu de 2 façons:

côté client

convertissez la chaîne de date reçue en un nombre et créez un objet date en utilisant le constructeur de la classe date avec les tiques comme paramètre.

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

}

côté serveur

la solution précédente utilise script côté client pour convertir la date en objet Date JavaScript. Vous pouvez également utiliser le code côté serveur qui sérialise les instances .net DateTime dans le format de votre choix. Pour accomplir cette tâche, vous devez créer votre propre ActionResult puis sérialiser les données comme vous le souhaitez.

de référence : http://www.developer.com/net/dealing-with-json-dates-in-asp.net-mvc.html

j'ai eu le même problème et au lieu de retourner la valeur réelle de la date j'ai juste utilisé ToString ("JJ MMM AAAA") sur elle. Puis dans mon javascript j'ai utilisé la nouvelle Date (datevalue), où datevalue peut être "01 Jan 2009".

voir ce fil:

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

essentiellement, alors que le format Date() est valide javascript, il n'est pas valide JSON (il y a une différence). Si vous voulez l'ancien format, vous devrez probablement créer une façade et de transformer cette valeur vous-même, ou de trouver un moyen d'obtenir le sérialiseur pour votre type dans le JsonResult et l'avoir utiliser un format personnalisé pour les dates.

pas la manière la plus élégante mais cela a fonctionné pour moi:

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

j'ai travaillé sur une solution à ce problème car aucune des réponses ci-dessus m'a vraiment aidé. Je travaille avec le calendrier de la semaine de jquery et j'avais besoin de mes dates pour avoir des informations sur les fuseaux horaires sur le serveur et localement sur la page. Après avoir creusé un peu, j'ai trouvé une solution qui pourrait aider les autres.

j'utilise asp.net 3.5, vs 2008, asp.net MVC 2, et jQuery Week calendar,

tout d'abord, j'utilise une bibliothèque écrite par Steven Levithan qui aide à traiter avec des dates sur le côté client, Steven Levithan date de bibliothèque . Le format isoUtcDateTime est parfait pour ce dont j'avais besoin. Dans mon appel AJAX jquery j'utilise la fonction format fournie avec la bibliothèque avec le format isoUtcDateTime et lorsque l'appel ajax touche ma méthode d'action, le type datetime est défini à local et reflète l'heure du serveur.

lorsque j'envoie des dates à ma page via AJAX, je les envoie sous forme de chaînes de texte en formatant les dates en utilisant "ddd, JJ MMM aaaa HH':'mm':'ss 'GMT'zzz". Ce format est facilement converti côté client en utilisant

var myDate = new Date(myReceivedDate);

voici ma solution complète moins la source de Steve Levithan, que vous pouvez télécharger:

contrôleur:

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>

j'espère que cet exemple rapide aidera d'autres dans la même situation que moi. A cette époque, il semble fonctionner très bien avec la sérialisation JSON de Microsoft et garde mes dates correctes à travers les fuseaux horaires.

la meilleure façon de gérer les dates dans knockoutjs est d'utiliser la bibliothèque des moments et de gérer les dates comme boss. Vous pouvez facilement traiter avec des dates comme / Date (-62135578800000)/. Pas besoin de se soucier de la façon dont votre date serialize dans le contrôleur.

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

utiliser comme

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

momentjs prend en charge de nombreux formats de date time et des fonctions d'utilité sur les dates.

formater la date dans la requête.

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

le seul problème avec cette solution est que vous n'obtiendrez aucun résultat si L'une des valeurs de date est nulle. Pour contourner cela, vous pouvez soit mettre des énoncés conditionnels dans votre requête avant de sélectionner la date qui ignore la date nulls ou vous pouvez configurer une requête pour obtenir tous les résultats et ensuite boucler toute l'information en utilisant une boucle foreach et attribuer une valeur à toutes les dates qui sont null avant de le faire votre SÉLECTIONNEZ nouveau.

exemple des deux:

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

la seconde option nécessite une autre requête entièrement pour que vous puissiez attribuer des valeurs à tous les nulls. Ceci et la boucle foreach devraient être avant votre requête qui sélectionne les valeurs.

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

juste une idée que j'ai trouvé plus facile que tous les exemples javascript.

Vous pouvez utiliser cette méthode:

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

ajouter jQuery ui plugin dans votre page.

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

retourne le format Date du serveur. Vous devez définir votre propre fonction.

function jsonDateFormat(jsonDate) {

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

};

voici un code JavaScript que j'ai écrit qui définit une valeur <input type="date"> à partir d'une date passée de 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);
    }
};

vous appelez cette fonction comme ceci:

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

où commissionStartDate est la date JSON passée par MVC.

pas pour rien, mais il y a un autre chemin. Tout d'abord, construisez votre requête LINQ. Ensuite, construisez une requête du résultat énuméré et appliquez n'importe quel type de formatage fonctionne pour vous.

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

je dois dire, le pas supplémentaire est ennuyeux, mais il fonctionne bien.

ce qui a fonctionné pour moi était de créer un viewmodel qui contenait la propriété date comme une chaîne. Attribution de la date de la propriété à partir du modèle de domaine et l'appel de la .ToString() sur la date de la propriété, tout en affectant la valeur pour le viewmodel.

un résultat JSON d'une méthode D'action MVC retournera la date dans un format compatible avec la vue.

Modèle De Vue

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

Modèle De Domaine

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

Méthode D'Action Du Contrôleur

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

outrepasser les contrôleurs Json/JsonResult pour revenir JSON.Net:

cette oeuvre traite

Ennuyeux, n'est-ce pas ?

ma solution était de changer mon service WCF pour le faire retourner DateTimes dans un format plus lisible (non-Microsoft). Notez ci-dessous, le " UpdateDateOriginal ", qui est le format par défaut de la WCF des dates, et mon " UpdateDate ", qui est formaté à quelque chose de plus lisible.

Voici comment le faire:

Modification du format de la date de la WCF

Espérons que cette aide.

le plus facile:

var milisegundos = parseInt (data.remplacer ("/Date (","").remplacer(")/", ""));

Var newDate = new Date (milisegundos). tolocaledestring ("en-UE");