Modificare l’impostazione di formato DateTime analisi ASP.NET Core

Avuto lo stesso problema. Passando DateTime nella richiesta del corpo funziona bene (perché Json converter gestisce questo personale), passando DateTime nella stringa di query come parametro ha un po ‘ di cultura questioni.

Non mi piace il “cambiare tutte le richieste di cultura” approccio, perché questo potrebbe avere un impatto su un altro tipo di analisi, che non è desiderabile.

Quindi la mia scelta è stata per ignorare l’impostazione predefinita DateTime modello di associazione utilizzando IModelBinder: https://docs.microsoft.com/en-us/aspnet/core/mvc/advanced/custom-model-binding

Quello che ho fatto:

1) Definire personalizzato legante (c# 7 la sintassi per il ‘fuori’ il parametro è utilizzato):

public class DateTimeModelBinder : IModelBinder
{
    public Task BindModelAsync(ModelBindingContext bindingContext)
    {
        if (bindingContext == null)
            throw new ArgumentNullException(nameof(bindingContext));

        //Try to fetch the value of the argument by name
        var modelName = bindingContext.ModelName;
        var valueProviderResult = bindingContext.ValueProvider.GetValue(modelName);
        if (valueProviderResult == ValueProviderResult.None)
            return Task.CompletedTask;

        bindingContext.ModelState.SetModelValue(modelName, valueProviderResult);

        var dateStr = valueProviderResult.FirstValue;
        //Here you define your custom parsing logic, i.e. using "de-DE" culture
        if (!DateTime.TryParse(dateStr, new CultureInfo("de-DE"), DateTimeStyles.None, out DateTime date))
        {
            bindingContext.ModelState.TryAddModelError(bindingContext.ModelName, "DateTime should be in format 'dd.MM.yyyy HH:mm:ss'");
            return Task.CompletedTask;
        }

        bindingContext.Result = ModelBindingResult.Success(date);
        return Task.CompletedTask;
    }
}

2) Definire il fornitore per il vostro raccoglitore:

 public class DateTimeModelBinderProvider : IModelBinderProvider
{
    public IModelBinder GetBinder(ModelBinderProviderContext context)
    {
        if (context == null)
        {
            throw new ArgumentNullException(nameof(context));
        }

        if (context.Metadata.ModelType == typeof(DateTime) || 
            context.Metadata.ModelType == typeof(DateTime?))
        {
            return new DateTimeModelBinder();
        }

        return null;
    }
}

3) E, infine, registra il tuo provider per essere utilizzato da ASP.NET Core:

services.AddMvc(options =>
{
    options.ModelBinderProviders.Insert(0, new DateTimeModelBinderProvider());
});

Ora il tuo DateTime verrà analizzato come previsto.

OriginaleL’autore Igor Fedchenko

MVC ha sempre usato InvariantCulture per instradare i dati e le stringhe di query (parametri che vanno nell’URL). Il motivo è che gli Url in applicazione localizzata deve essere universale. In caso contrario, un url in grado di fornire dati diversi a seconda della localizzazione dell’utente.

È possibile sostituire la query e percorso ValueProviderFactories con la tua che rispetto la cultura corrente (o utilizzare method="POST" in moduli)

public class CustomValueProviderFactory : IValueProviderFactory
{
    public Task CreateValueProviderAsync(ValueProviderFactoryContext context)
    {
        if (context == null)
        {
            throw new ArgumentNullException(nameof(context));
        }

        var query = context.ActionContext.HttpContext.Request.Query;
        if (query != null && query.Count > 0)
        {
            var valueProvider = new QueryStringValueProvider(
                BindingSource.Query,
                query,
                CultureInfo.CurrentCulture);

            context.ValueProviders.Add(valueProvider);
        }

        return Task.CompletedTask;
    }
}

services.AddMvc(opts => {
    //2 - Index QueryStringValueProviderFactory
    opts.ValueProviderFactories[2] = new CustomValueProviderFactory(); 
})

P. S. è un comportamento ragionevole, ma non capisco perché la documentazione non coprire questa cosa molto importante.

OriginaleL’autore justserega

Se non ti dispiace utilizzando il generico StatusCode metodo per effettuare questa chiamata, si può fare qualcosa di simile:

internal IActionResult CreateResponse(int code, object content = null)
    {
        Type t = content?.GetType();
        bool textContent = t == typeof(string) || t == typeof(bool);
        //
        JsonSerializerSettings dateFormatSettings = new JsonSerializerSettings
        {

            DateFormatString = myDateFormat
        };

        string bodyContent = content == null || string.IsNullOrWhiteSpace(content + "")
                    ? null
                    : textContent
                        ? content + ""
                        : JsonConvert.SerializeObject(content, dateFormatSettings);

        ObjectResult or = base.StatusCode(code, bodyContent);
        string mediaType = 
                    !textContent
                        ? "application/json"
                        : "text/plain";
        or.ContentTypes.Add(new MediaTypeHeaderValue(mediaType));
        return or;
    }

Si può aggiungere a una classe di base e di chiamare le cose come:

return base.CreateResponse(StatusCodes.Status200OK, new { name = "My Name", age = 23});

Spetta a voi se si desidera creare il proprio Ok, BadRequest, ecc…metodi, ma per me questo funziona e spero che aiuta chiunque altro. Si potrebbe anche di default int codice = 200, se la maggior parte delle richieste Arriva. Questo codice si presuppone che si desidera rispondere con una stringa, booleano, o un oggetto personalizzato, ma si può facilmente gestire tutte le primitive controllando Tipo.GetTypeInfo().IsPrimitive e anche di fare alcuni controlli per il decimale, stringa, data e ora, Durata, DateTimeOffset o Guid.

OriginaleL’autore pqsk

Considerare l’utilizzo di un custom TypeConverter per il tuo datetime (Fonte):

using System;
using System.ComponentModel;
using System.Globalization;
using System.Drawing;

public class DeDateTimeConverter : TypeConverter {
   //Overrides the CanConvertFrom method of TypeConverter.
   //The ITypeDescriptorContext interface provides the context for the
   //conversion. Typically, this interface is used at design time to 
   //provide information about the design-time container.
   public override bool CanConvertFrom(ITypeDescriptorContext context, 
      Type sourceType) {

      if (sourceType == typeof(string)) {
         return true;
      }
      return base.CanConvertFrom(context, sourceType);
   }
   //Overrides the ConvertFrom method of TypeConverter.
   public override object ConvertFrom(ITypeDescriptorContext context, 
      CultureInfo culture, object value) {
      if (value is string) {
         if (DateTime.TryParse(((string)value), new CultureInfo("de-DE") /*or use culture*/, DateTimeStyles.None, out DateTime date))
             return date;
      }
      return base.ConvertFrom(context, culture, value);
   }
}

e utilizzare TypeConverter attributo proprietà:

[TypeConverter(typeof(DeDateTimeConverter))]
public DateTime CustomDateTime { get; set; }

Aggiornamento

Sulla base della mia esperienza e grazie a questa risposta e @zdeněk commento, TypeConverter attributo non funzionano e si dovrebbe registrare TypeConverter in Startup.cs:

TypeDescriptor.AddAttributes(typeof(DateTime), new TypeConverterAttribute(typeof(DeDateTimeConverter)));

OriginaleL’autore KiNG

DateTime dt = DateTime.ParseExact(dateString, "ddMMyyyy", CultureInfo.InvariantCulture);
dt.ToString("yyyyMMdd");

Come per https://stackoverflow.com/a/3477821/2914174

OriginaleL’autore Ryan