ASP.NET MVC JsonResult Date Format

Aquí está mi solución en Javascript, muy similar a la de JPot, pero más corta (y posiblemente un poco más rápida):

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

"valor.substr (6) "elimina la parte" /Date ( " , y la función parseInt ignora los caracteres no numéricos que aparecen al final.

EDITAR: He omitido intencionalmente la raíz (el segundo argumento a analizar); ver mi comentario a continuación. Además, tenga en cuenta que las fechas ISO-8601 son preferidas sobre este formato antiguo, por lo que este formato generalmente no debe usarse para nuevos desarrollos. Ver el excelente Json.NET biblioteca para una gran alternativa que serializa fechas usando el formato ISO-8601.

Para las fechas JSON con formato ISO-8601, simplemente pase la cadena al constructor Date:

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

Hay bastantes respuestas para manejarlo del lado del cliente, pero puede cambiar el lado del servidor de salida si lo desea.

Hay algunas maneras de abordar esto, comenzaré con lo básico. Tendrás que subclasificar la clase JsonResult y sobrescribir el método ExecuteResult. A partir de ahí puede tomar algunos enfoques diferentes para cambiar la serialización.

Enfoque 1: La implementación predeterminada utiliza el JsonScriptSerializer. Si usted echa un vistazo a la documentación, puede usar el método RegisterConverters para agregar custom JavaScriptConverters . Sin embargo, hay algunos problemas con esto: El JavaScriptConverter se serializa a un diccionario, es decir, toma un objeto y se serializa a un diccionario Json. Para hacer que el objeto se serialice a una cadena requiere un poco de hacker, ver post. Este truco en particular también escapará de la cadena.

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

Método 2 (recomendado): El segundo enfoque es: comience con el JsonResult anulado y vaya con otro serializador Json, en mi caso el Json.NET serializador. Esto no requiere el hackeo del enfoque 1. Aquí está mi implementación de la subclase 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));
        }
    }
}

Ejemplo de uso:

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

Créditos Adicionales: James Newton-King

Momento.js es una extensa biblioteca datetime que también soporta esto. http://momentjs.com/docs/#/parsing/asp-net-json-dates /

Ex: momento("/Fecha(1198908717056-0700)/")

Podría ayudar. salida del émbolo

Usando jQuery para convertir automáticamente fechas con $.parseJSON

Nota: esta respuesta proporciona una extensión jQuery que añade compatibilidad automática con formato de fecha ISO y. net.

Ya que estás usando Asp.net MVC Sospecho que está utilizando jQuery en el lado del cliente. Te sugiero que leas esta entrada de blog que tiene código de cómo usar $.parseJSON para convertir automáticamente las fechas para ti.

Soporte de código Asp.net fechas formateadas como las que mencionaste también como fechas con formato ISO. Todas las fechas se formatearán automáticamente usando $.parseJSON().

Encontré que crear un nuevo JsonResult y devolver eso es insatisfactorio - tener que reemplazar todas las llamadas a return Json(obj) con return new MyJsonResult { Data = obj } es un dolor.

Así que pensé, ¿por qué no secuestrar el JsonResult usando 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));
            }
        }
    }
}

Esto se puede aplicar a cualquier método que devuelva un JsonResult a usar JSON.Net en su lugar:

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

Que responderá con

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

Como se desee!

Puede, si no le importa llamar a la comparación is en cada solicitud, agregar esto a su FilterConfig:

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

Y todo tu JSON ahora será serializado con JSON.Net en lugar del JavaScriptSerializer incorporado.

La comunicación Ajax entre el cliente y el servidor a menudo involucra datos en formato JSON. Si bien JSON funciona bien para cadenas, números y booleanos, puede plantear algunas dificultades para las fechas debido a la forma ASP.NET los serializa. Como no tiene ninguna representación especial para las fechas, se serializan como cadenas simples. Como solución el mecanismo de serialización predeterminado de ASP.NET Formularios Web y MVC serializa las fechas en un formulario especial- / Date (ticks) / - donde ticks es el número de milisegundos desde el 1 de enero de 1970.

Este problema se puede resolver de 2 maneras:

Lado del cliente

Convierta la cadena de fecha recibida en un número y cree un objeto date usando el constructor de la clase date con las marcas 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 del servidor

La solución anterior utiliza un script del lado del cliente para convertir la fecha en un objeto de fecha JavaScript. También puede usar código del lado del servidor que serializa. NET DateTime instancias en el formato de su elección. Para realizar esta tarea, debe crear su propio ActionResult y luego serializar los datos de la manera que desee.

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

Tuve el mismo problema y en lugar de devolver el valor de fecha real, solo usé toString("dd MMM aaaa") en él. Luego en mi javascript utilicé nueva fecha (datevalue), donde datevalue puede ser "01 Jan 2009".

Ver este hilo:

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

Básicamente, mientras que el formato Date() es javascript válido, no es JSON válido (hay una diferencia). Si desea el formato antiguo, probablemente tendrá que crear una fachada y transformar el valor usted mismo, o encontrar una manera de llegar al serializador para su tipo en el JsonResult y hacer que use un formato personalizado para las fechas.

No es la manera más elegante, pero esto funcionó para mí:

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

He estado trabajando en una solución a este problema ya que ninguna de las respuestas anteriores realmente me ayudó. Estoy trabajando con el calendario semanal de jquery y necesitaba que mis fechas tuvieran información de zona horaria en el servidor y localmente en la página. Después de investigar un poco, descubrí una solución que puede ayudar a otros.

Estoy usando asp.net 3.5, vs 2008, asp.net MVC 2, y jquery week calendar,

Primero, estoy usando una biblioteca escrita por Steven Levithan que ayuda con el trato con fechas en el lado del cliente, La biblioteca de fechas de Steven Levithan. El formato isoUtcDateTime es perfecto para lo que necesitaba. En mi llamada AJAX jquery uso la función de formato proporcionada con la biblioteca con el formato isoUtcDateTime y cuando la llamada ajax golpea mi método de acción, el tipo datetime se establece en local y refleja la hora del servidor.

Cuando envío fechas a mi página a través de AJAX, las envío como cadenas de texto formateando las fechas usando "ddd, dd MMM aaaa HH':'mm':'ss 'GMT'zzzz". Este formato se convierte fácilmente en el lado del cliente usando

var myDate = new Date(myReceivedDate);

Aquí está mi solución completa menos la fuente de Steve Levithan, que puede descargar:

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 ejemplo rápido ayude a otros en la misma situación en la que yo estaba. En este momento parece funcionar muy bien con la serialización JSON de Microsoft y mantiene mis fechas correctas en todas las zonas horarias.

La mejor manera de manejar fechas en knockoutjs es usar la biblioteca de momentos y manejar fechas como boss. Puede tratar fácilmente con fechas como / Date (-62135578800000)/. No hay necesidad de preocuparse de cómo su serializar la fecha en el controlador.

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

Úsalo como

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

Momentjs admite muchos formatos de fecha y hora y funciones de utilidad en fechas.

Formatee la fecha dentro de la consulta.

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

El único problema con esta solución es que no obtendrá ningún resultado si CUALQUIERA de los valores de fecha son null. Para evitar esto, puede poner sentencias condicionales en su consulta ANTES de seleccionar la fecha que ignora los nulos de fecha o puede configurar una consulta para obtener todos los resultados y luego recorrer toda esa información utilizando un bucle foreach y asignar un valor a todas las fechas que son null ANTES de seleccionar nuevo.

Ejemplo de ambos:

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

La segunda opción requiere otra consulta completamente para que pueda asignar valores a todos los valores nulos. Esto y el bucle foreach tendrían que estar ANTES de su consulta que selecciona los 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");
                }
            }

Solo una idea que encontré más fácil que todos los ejemplos de javascript.

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

Añadir jquery ui plugin en su página.

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

Devuelve el Formato de Fecha del Servidor. Necesitas definir tu propia función.

function jsonDateFormat(jsonDate) {

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

};

Aquí hay un código JavaScript que escribí que establece un valor <input type="date"> a partir de una fecha pasada 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);
    }
};

Llamas a esta función de la siguiente manera:

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

Donde commissionStartDate es la fecha JSON pasada por MVC.

No por nada, pero hay otro camino. Primero, construye tu consulta LINQ. Luego, construya una consulta del resultado enumerado y aplique cualquier tipo de formato que funcione para usted.

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

Tengo que decir que el paso adicional es molesto, pero funciona muy bien.

Lo que funcionó para mí fue crear un viewmodel que contuviera la propiedad date como una cadena. Asignar la propiedad DateTime desde el modelo de dominio y llamar al .toString () en la propiedad date mientras asigna el valor al viewmodel.

Un resultado JSON de un método de acción MVC devolverá la fecha en un formato compatible con la vista.

Ver modelo

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

Modelo de dominio

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

Método de Acción del 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);
}

Invalida los controladores Json / JsonResult para devolver JSON.Net:

Esto funciona un tratamiento

Molesto, ¿no ?

Mi solución fue cambiar mi servicio WCF para que devolviera los horarios en un formato más legible (que no sea Microsoft). Observe a continuación, el " UpdateDateOriginal", que es el formato predeterminado de fechas de WCF, y mi "UpdateDate", que está formateado para algo más legible.

Aquí está cómo hacerlo:

Cambiar el formato de fecha WCF

Espero que esto ayude.

La más fácil:

Var milisegundos = parseInt (data.replace("/Date(", "").reemplazar(")/", ""));
Var newDate = nueva fecha (milisegundos). toLocaleDateString ("en-UE");