Changement de format par défaut pour le type DateTime l'analyse en ASP.NET de Base

Eu le même problème. En passant DateTime dans le corps de la requête fonctionne très bien (parce que Json convertisseur gère le personnel), en passant DateTime dans la chaîne de requête comme un paramètre a une certaine culture de questions.

Je n'aime pas le "changement de toutes les demandes de la culture", car cela pourrait avoir un impact sur un autre type d'analyse, qui n'est pas souhaitable.

Donc mon choix a été de remplacer la valeur par défaut DateTime modèle de liaison à l'aide de IModelBinder: https://docs.microsoft.com/en-us/aspnet/core/mvc/advanced/custom-model-binding

Ce que j'ai fait:

1) Définir un liant (c# 7 syntaxe pour 'sortir' le paramètre est utilisé):

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) Définir le fournisseur de votre classeur:

 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) Et enfin, enregistrez votre fournisseur pour être utilisé par ASP.NET Core:

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

Maintenant votre DateTime sera analysée comme prévu.

OriginalL'auteur Igor Fedchenko

MVC a toujours utilisé InvariantCulture pour les données d'itinéraire et des chaînes de requête (paramètres qui vont dans l'URL). La raison derrière cela est que les Url en application localisée doit être universelle. Sinon, une url peut fournir des données différentes selon les paramètres régionaux de l'utilisateur.

Vous pouvez remplacer la requête et de la route ValueProviderFactories avec votre propre que le respect de la culture actuelle (ou utilisez method="POST" dans les formulaires)

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. C'est un comportement raisonnable, mais je ne comprends pas pourquoi la documentation ne couvre pas cette chose très importante.

OriginalL'auteur Sergei Shvets

Si vous n'avez pas l'esprit en utilisant le générique StatusCode méthode pour faire cet appel, vous pouvez faire quelque chose comme ce qui suit:

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

Vous pouvez ajouter à une classe de base et de l'appeler comme:

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

C'est à vous, si vous voulez créer votre propre Ok, BadRequest, etc...méthodes, mais pour moi cela fonctionne, et j'espère que cela aide quelqu'un d'autre. Vous pourriez même par défaut int code = 200, si la plupart de vos demandes Obtient. Ce code suppose que vous voulez répondre avec une chaîne de caractères, booléen ou un objet personnalisé, mais vous pouvez facilement gérer toutes les primitives par la vérification de Type.GetTypeInfo().IsPrimitive et même de faire quelques vérifications pour les décimales, chaîne, DateTime, TimeSpan, DateTimeOffset, ou le Guid.

OriginalL'auteur pqsk

Envisager d'utiliser un custom TypeConverter pour votre datetime (Source):

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

et l'utilisation TypeConverter attribut sur votre propriété:

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

Mise à jour

Basé sur mon expérience et grâce à cette réponse et @zdeněk commentaire, TypeConverter attribut ne fonctionne pas et que vous devriez vous inscrire TypeConverter dans Startup.cs:

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

OriginalL'auteur Shahab

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

Comme par https://stackoverflow.com/a/3477821/2914174

OriginalL'auteur Ryan