Est-il correct d'utiliser ModelState.Remove pour gérer ModelState?

Je travaille sur un gros MVC3 application web et avoir une gêne au sujet de la ModelState.IsValid méthode.

ModelState est utilisé dans presque tous mes contrôleurs afin de valider les données affichées.
Les points de vue sont tous basés sur le Viewmodel qui contiennent différentes classes et ces classes contiennent des propriétés qui pourraient être marqués comme [Required].

Le problème que j'ai est les propriétés requises sont parfois pas nécessaire, et je vais avoir à utiliser la ModelState.Remove méthode afin que ModelState.IsValid devient vrai.

Ma question est par l'utilisation de ModelState.Removeest-ce la bonne façon de faire les choses ou est-il une approche plus efficace.

source d'informationauteur Hesky

  1. 12

    Si vous êtes en utilisant le même modèle de vue avec un [Required] propriété dans deux contextes différents, l'un où la propriété est obligatoire et celui où il ne l'est pas, alors vous aurez besoin de modifier manuellement la ModelState que vous êtes en train de faire.

    Une alternative est d'utiliser un autre modèle de vue. Peut-être avoir une classe de base de toutes les propriétés à l'exception de la propriété en question. Ensuite dériver deux modèles, l'un avec le bien, où est-il, et avec la propriété où il ne l'est pas (c'est la duplication, je sais). Vous pouvez décider de les maintenir entièrement distincte de tout et de ne pas utiliser l'héritage.

  2. 17

    Voici ma solution - un RemoveFor() méthode d'extension sur ModelStatesur le modèle MVC, HTML helpers:

        public static void RemoveFor<TModel>(this ModelStateDictionary modelState, 
                                         Expression<Func<TModel, object>> expression)
    {
        string expressionText = ExpressionHelper.GetExpressionText(expression);

        foreach (var ms in modelState.ToArray())
        {
            if (ms.Key.StartsWith(expressionText + ".") || ms.Key == expressionText)
            {
                modelState.Remove(ms);
            }
        }
    }

    Voici comment il est utilisé :

    if (model.CheckoutModel.ShipToBillingAddress == true) 
{
    //REUSE BILLING ADDRESS FOR SHIPPING ADDRESS
    ShoppingCart.ShippingAddress = ShoppingCart.BillingAddress;

    //REMOVE MODELSTATE ERRORS FOR SHIPPING ADDRESS
    ModelState.RemoveFor<SinglePageStoreModel>(x => model.CheckoutModel.ShippingAddress);
}

    Donc pour répondre à votre question, je crois qu'il y a certainement des cas d'utilisation où c'est la bonne façon de le faire, et fortement typé aide comme cela le rend beaucoup plus agréable à regarder et facile de justifier si vous êtes inquiet au sujet de beaucoup de chaînes magiques.

  3. 10

    Fondamentalement, le problème est que si vos cours sont décorées avec [Nécessaire], il n'est pas toujours vrai. Si vous êtes d'exploitation dans un contexte où il n'est pas vrai, vous devriez vraiment être à l'aide d'une classe qui ne définit pas la propriété comme étant [Obligatoire].

    Vous devriez vraiment utiliser un ViewModel qui est correctement défini pour son utilisation spécifique et que peut signifier la duplication de certaines classes. Un ViewModel est associée à la mise en œuvre de l'INTERFACE utilisateur et tandis qu'il peut utiliser des classes de modèle de domaine, il n'est pas toujours la bonne chose à faire.

    À défaut, les options sont soit de ne pas utiliser ModelState.IsValid, ou de continuer à utiliser ModelState.Retirez.

    Mais logiquement, il fait sens pour votre ViewModel pour être "traitement pouvant être validé', de ne pas avoir à ignorer certaines erreurs de validation.

  4. 1

    Je suis totalement avec M. Steve Morgan

    Donc, si votre Dernier n'a pas toujours besoin d'un certain bien être Requiredalors vous ne devriez pas le décorer comme Requis.

    Je ne sais pas pourquoi vous voulez cette question, mais je suppose que, dans certains cas, vous avez besoin PropertyOne être Required si PropertyTwo a de la valeur.
    Dans ce cas, vous pouvez avoir besoin pour rendre votre CustomValidationAttribute pour vérifier ces deux propriétés.

    Je suis en utilisant quelque chose comme ceci :

    [AttributeUsage(AttributeTargets.Class, AllowMultiple = true, Inherited = true)]
public class PropertyNeededAttribute : ValidationAttribute
{
    private const string defaultErrorMessage = "'{0}' needs '{1}' to be valid.";

    public PropertyNeededAttribute(string originalProperty, string neededProperty)
        : base(defaultErrorMessage)
    {
        NeededProperty = neededProperty;
        OriginalProperty = originalProperty;
    }

    public string NeededProperty { get; private set; }
    public string OriginalProperty { get; private set; }

    public override object TypeId
    {
        get { return new object(); }
    }

    public override string FormatErrorMessage(string name)
    {
        return String.Format(CultureInfo.CurrentUICulture, ErrorMessageString,
                             OriginalProperty, NeededProperty);
    }

    public override bool IsValid(object value)
    {
        object neededValue = Statics.GetPropertyValue(value, NeededProperty);
        object originalValue = Statics.GetPropertyValue(value, OriginalProperty);
        if (originalValue != null && neededValue == null)
            return false;
        return true;
    }
}

    remarque: Statics.GetPropertyValue(...) ne rien faire, mais obtenir la valeur de la propriété de les comparer.

    Espère que cela a aidé 🙂

  5. 1

    Si votre propriété n'est pas toujours nécessaire, vous ne devriez pas le décorer avec des [Required].

    Une bonne alternative pour faire de votre validation est d'implémenter l'interface Ivalidatableobjet.

    Par exemple, disons que vous voulez faire sur le terrain State nécessaire seulement lorsque le pays est United States. Vous pourriez le faire de cette façon :

    public class AddressModel : IValidatableObject
{
    [Required]
    public string Country { get; set; }
    public string State { get; set; }

    public IEnumerable<ValidationResult> Validate(ValidationContext validationContext)
    {
        if(Country == "United States" && String.IsNullOrEmpty(State))
        {
            yield return new ValidationResult("State is required for United States", new [] { nameof(State) });
        }
    }
}

    Remarque : Ce type de validation ne fonctionne que sur le côté serveur.

    D'autres alternatives?

    Comme mentionné dans d'autres réponses, c'est parfois une bonne idée de créer 2 ou plus de modèles si les points de vue et les validations sont très différents.