web-dev-qa-db-fra.com

Model Bind List of Enum Flags

J'ai une grille de drapeaux énumérés dans laquelle chaque enregistrement est une ligne de cases à cocher pour déterminer les valeurs d'indicateur de cet enregistrement. Il s'agit d'une liste de notifications que le système propose et l'utilisateur peut choisir (pour chacune) la façon dont il souhaite les recevoir:

[Flag]
public enum NotificationDeliveryType
{
  InSystem = 1,
  Email = 2,
  Text = 4
}

J'ai trouvé cela article mais il récupère une seule valeur de drapeau et il la lie dans le contrôleur comme ceci (avec un concept de jours de la semaine):

[HttpPost]
public ActionResult MyPostedPage(MyModel model)
{
  //I moved the logic for setting this into a helper 
  //because this could be re-used elsewhere.
  model.WeekDays = Enum<DayOfWeek>.ParseToEnumFlag(Request.Form, "WeekDays[]");
  ...
}

Je ne trouve nulle part où le classeur modèle MVC 3 peut gérer les drapeaux. Merci!

c#asp.net-mvcasp.net-mvc-3model-bindingenum-flags
34
Rikon

En général, j'évite d'utiliser des énumérations lors de la conception de mes modèles de vue, car ils ne jouent pas avec les assistants ASP.NET MVC et le classeur de modèles prêts à l'emploi. Ils sont parfaitement adaptés à vos modèles de domaine, mais pour les modèles de vue, vous pouvez utiliser d'autres types. Je laisse donc ma couche de mappage qui est responsable de la conversion entre mes modèles de domaine et les modèles de vue pour s'inquiéter de ces conversions.

Cela étant dit, si pour une raison quelconque vous décidez d'utiliser des énumérations dans cette situation, vous pouvez rouler un classeur de modèle personnalisé:

public class NotificationDeliveryTypeModelBinder : DefaultModelBinder
{
    public override object BindModel(ControllerContext controllerContext, ModelBindingContext bindingContext)
    {
        var value = bindingContext.ValueProvider.GetValue(bindingContext.ModelName);
        if (value != null )
        {
            var rawValues = value.RawValue as string[];
            if (rawValues != null)
            {
                NotificationDeliveryType result;
                if (Enum.TryParse<NotificationDeliveryType>(string.Join(",", rawValues), out result))
                {
                    return result;
                }
            }
        }
        return base.BindModel(controllerContext, bindingContext);
    }
}

qui sera enregistré dans Application_Start:

ModelBinders.Binders.Add(
    typeof(NotificationDeliveryType), 
    new NotificationDeliveryTypeModelBinder()
);

Jusqu'ici tout va bien. Maintenant, le truc standard:

Voir le modèle:

[Flags]
public enum NotificationDeliveryType
{
    InSystem = 1,
    Email = 2,
    Text = 4
}

public class MyViewModel
{
    public IEnumerable<NotificationDeliveryType> Notifications { get; set; }
}

Manette:

public class HomeController : Controller
{
    public ActionResult Index()
    {
        var model = new MyViewModel
        {
            Notifications = new[]
            {
                NotificationDeliveryType.Email,
                NotificationDeliveryType.InSystem | NotificationDeliveryType.Text
            }
        };
        return View(model);
    }

    [HttpPost]
    public ActionResult Index(MyViewModel model)
    {
        return View(model);
    }
}

Vue (~/Views/Home/Index.cshtml):

@model MyViewModel
@using (Html.BeginForm())
{
    <table>
        <thead>
            <tr>
                <th>Notification</th>
            </tr>
        </thead>
        <tbody>
            @Html.EditorFor(x => x.Notifications)
        </tbody>
    </table>
    <button type="submit">OK</button>
}

modèle d'éditeur personnalisé pour NotificationDeliveryType (~/Views/Shared/EditorTemplates/NotificationDeliveryType.cshtml):

@model NotificationDeliveryType

<tr>
    <td>
        @foreach (NotificationDeliveryType item in Enum.GetValues(typeof(NotificationDeliveryType)))
        {
            <label for="@ViewData.TemplateInfo.GetFullHtmlFieldId(item.ToString())">@item</label>
            <input type="checkbox" id="@ViewData.TemplateInfo.GetFullHtmlFieldId(item.ToString())" name="@(ViewData.TemplateInfo.GetFullHtmlFieldName(""))" value="@item" @Html.Raw((Model & item) == item ? "checked=\"checked\"" : "") />
        }
    </td>
</tr>

Il est évident qu'un développeur de logiciels (moi dans ce cas) qui écrit un tel code dans un modèle d'éditeur ne devrait pas être très fier de son travail. Je veux dire, regarde-le! Même moi qui ai écrit ce modèle Razor il y a 5 minutes, je ne comprends plus ce qu'il fait.

Nous refactorisons donc ce code spaghetti dans un assistant HTML personnalisé réutilisable:

public static class HtmlExtensions
{
    public static IHtmlString CheckBoxesForEnumModel<TModel>(this HtmlHelper<TModel> htmlHelper)
    {
        if (!typeof(TModel).IsEnum)
        {
            throw new ArgumentException("this helper can only be used with enums");
        }
        var sb = new StringBuilder();
        foreach (Enum item in Enum.GetValues(typeof(TModel)))
        {
            var ti = htmlHelper.ViewData.TemplateInfo;
            var id = ti.GetFullHtmlFieldId(item.ToString());
            var name = ti.GetFullHtmlFieldName(string.Empty);
            var label = new TagBuilder("label");
            label.Attributes["for"] = id;
            label.SetInnerText(item.ToString());
            sb.AppendLine(label.ToString());

            var checkbox = new TagBuilder("input");
            checkbox.Attributes["id"] = id;
            checkbox.Attributes["name"] = name;
            checkbox.Attributes["type"] = "checkbox";
            checkbox.Attributes["value"] = item.ToString();
            var model = htmlHelper.ViewData.Model as Enum;
            if (model.HasFlag(item))
            {
                checkbox.Attributes["checked"] = "checked";
            }
            sb.AppendLine(checkbox.ToString());
        }

        return new HtmlString(sb.ToString());
    }
}

et nous nettoyons le désordre dans notre modèle d'éditeur:

@model NotificationDeliveryType
<tr>
    <td>
        @Html.CheckBoxesForEnumModel()
    </td>
</tr>

ce qui donne le tableau:

enter image description here

Évidemment, cela aurait été bien si nous pouvions fournir des étiquettes plus conviviales pour ces cases à cocher. Comme par exemple:

[Flags]
public enum NotificationDeliveryType
{
    [Display(Name = "in da system")]
    InSystem = 1,

    [Display(Name = "@")]
    Email = 2,

    [Display(Name = "txt")]
    Text = 4
}

Tout ce que nous avons à faire est d'adapter l'assistant HTML que nous avons écrit plus tôt:

var field = item.GetType().GetField(item.ToString());
var display = field
    .GetCustomAttributes(typeof(DisplayAttribute), true)
    .FirstOrDefault() as DisplayAttribute;
if (display != null)
{
    label.SetInnerText(display.Name);
}
else
{
    label.SetInnerText(item.ToString());
}

ce qui nous donne un meilleur résultat:

enter image description here

72
Darin Dimitrov

Le code de Darin était génial mais j'ai rencontré des problèmes pour l'utiliser avec MVC4.

Dans l'extension HtmlHelper pour créer les boîtes, j'ai continué à obtenir des erreurs d'exécution que le modèle n'était pas une énumération (en particulier, en disant System.Object). J'ai retravaillé le code pour prendre une expression Lambda et nettoyé ce problème en utilisant la classe ModelMetadata:

public static IHtmlString CheckBoxesForEnumFlagsFor<TModel, TEnum>(this HtmlHelper<TModel> htmlHelper, Expression<Func<TModel, TEnum>> expression)
{
    ModelMetadata metadata = ModelMetadata.FromLambdaExpression(expression, htmlHelper.ViewData);
    Type enumModelType = metadata.ModelType;

    // Check to make sure this is an enum.
    if (!enumModelType.IsEnum)
    {
        throw new ArgumentException("This helper can only be used with enums. Type used was: " + enumModelType.FullName.ToString() + ".");
    }

    // Create string for Element.
    var sb = new StringBuilder();
    foreach (Enum item in Enum.GetValues(enumModelType))
    {
        if (Convert.ToInt32(item) != 0)
        {
            var ti = htmlHelper.ViewData.TemplateInfo;
            var id = ti.GetFullHtmlFieldId(item.ToString());
            var name = ti.GetFullHtmlFieldName(string.Empty);
            var label = new TagBuilder("label");
            label.Attributes["for"] = id;
            var field = item.GetType().GetField(item.ToString());

            // Add checkbox.
            var checkbox = new TagBuilder("input");
            checkbox.Attributes["id"] = id;
            checkbox.Attributes["name"] = name;
            checkbox.Attributes["type"] = "checkbox";
            checkbox.Attributes["value"] = item.ToString();
            var model = htmlHelper.ViewData.Model as Enum;
            if (model.HasFlag(item))
            {
                checkbox.Attributes["checked"] = "checked";
            }
            sb.AppendLine(checkbox.ToString());

            // Check to see if DisplayName attribute has been set for item.
            var displayName = field.GetCustomAttributes(typeof(DisplayNameAttribute), true)
                .FirstOrDefault() as DisplayNameAttribute;
            if (displayName != null)
            {
                // Display name specified.  Use it.
                label.SetInnerText(displayName.DisplayName);
            }
            else
            {
                // Check to see if Display attribute has been set for item.
                var display = field.GetCustomAttributes(typeof(DisplayAttribute), true)
                    .FirstOrDefault() as DisplayAttribute;
                if (display != null)
                {
                    label.SetInnerText(display.Name);
                }
                else
                {
                    label.SetInnerText(item.ToString());
                }
            }
            sb.AppendLine(label.ToString());

            // Add line break.
            sb.AppendLine("<br />");
        }                
    }

    return new HtmlString(sb.ToString());
}

J'ai également étendu le classeur de modèles pour qu'il fonctionne avec tout type d'énumération générique.

public override object BindModel(ControllerContext controllerContext, ModelBindingContext bindingContext)
{
    // Fetch value to bind.
    var value = bindingContext.ValueProvider.GetValue(bindingContext.ModelName);
    if (value != null)
    {
        // Get type of value.
        Type valueType = bindingContext.ModelType;

        var rawValues = value.RawValue as string[];
        if (rawValues != null)
        {
            // Create instance of result object.
            var result = (Enum)Activator.CreateInstance(valueType);

            try
            {
                // Parse.
                result = (Enum)Enum.Parse(valueType, string.Join(",", rawValues));
                return result;
            }
            catch
            {
                return base.BindModel(controllerContext, bindingContext);
            }
        }
    }
    return base.BindModel(controllerContext, bindingContext);
}

Vous devez toujours enregistrer chaque type d'énumération dans Application_Start, mais au moins cela élimine le besoin de classes de classeur distinctes. Vous pouvez l'enregistrer en utilisant:

ModelBinders.Binders.Add(typeof(MyEnumType), new EnumFlagsModelBinder());

J'ai publié mon code sur Github à https://github.com/Bitmapped/MvcEnumFlags .

14
Bitmapped

Vous pouvez essayer le package MVC Enum Flags (disponible via nuget ). Il ignore automatiquement les choix d'énumération à valeur zéro, ce qui est une bonne touche.

[Ce qui suit est tiré de Documentation et de ses commentaires; voir là si cela ne vous lie pas correctement]

Après l'installation, ajoutez ce qui suit à Global.asax.cs\Application_Start:

ModelBinders.Binders.Add(typeof(MyEnumType), new EnumFlagsModelBinder());

Ensuite, dans la vue, placez @using MvcEnumFlags En haut et @Html.CheckBoxesForEnumFlagsFor(model => model.MyEnumTypeProperty) pour le code réel.

7
Arithmomaniac

J'utilise l'approche décrite dans MVVM Framework .

 enum ActiveFlags
{
    None = 0,
    Active = 1,
    Inactive = 2,
}

class ActiveFlagInfo : EnumInfo<ActiveFlags>
{
    public ActiveFlagInfo(ActiveFlags value)
        : base(value)
    {
        // here you can localize or set user friendly name of the enum value
        if (value == ActiveFlags.Active)
            this.Name = "Active";
        else if (value == ActiveFlags.Inactive)
            this.Name = "Inactive";
        else if (value == ActiveFlags.None)
            this.Name = "(not set)";
    }
}

   // Usage of ActiveFlagInfo class:
   // you can use collection of ActiveFlagInfo for binding in your own view models
   // also you can use this ActiveFlagInfo as property for your  classes to wrap enum properties

   IEnumerable<ActiveFlagInfo> activeFlags = ActiveFlagInfo.GetEnumInfos(e => 
                    e == ActiveFlags.None ? null : new ActiveFlagInfo(e));
2
Dmitry

En utilisant Darin et du code bitmap, j'écris la réponse, mais cela n'a pas fonctionné pour moi, donc j'ai d'abord corrigé des trucs nullables, puis j'ai toujours eu un problème de bining, j'ai découvert qu'il y avait quelque chose de mal avec le html, donc je perds confiance en cette réponse , en chercher un autre, que j'ai trouvé quelque chose dans un forum de mon pays, qui utilise le même code qu'ici, mais avec très peu de changement, donc je fusionne ça avec mon code, et tout s'est bien passé, mon projet utilise nullable, donc je ne sais pas comment ça va fonctionner dans d'autres endroits, j'ai peut-être besoin d'une petite correction, mais j'ai essayé de penser à nullable et au modèle étant l'énumération elle-même.

public static class Extensions
{
    public static IHtmlString CheckBoxesForEnumFlagsFor<TModel, TEnum>(this HtmlHelper<TModel> htmlHelper, Expression<Func<TModel, TEnum>> expression)
    {
        ModelMetadata metadata = ModelMetadata.FromLambdaExpression(expression, htmlHelper.ViewData);
        Type enumModelType = metadata.ModelType;

        var isEnum = enumModelType.IsEnum;
        var isNullableEnum = enumModelType.IsGenericType &&
                             enumModelType.GetGenericTypeDefinition() == typeof (Nullable<>) &&
                             enumModelType.GenericTypeArguments[0].IsEnum;

        // Check to make sure this is an enum.
        if (!isEnum && !isNullableEnum)
        {
            throw new ArgumentException("This helper can only be used with enums. Type used was: " + enumModelType.FullName.ToString() + ".");
        }

        // Create string for Element.
        var sb = new StringBuilder();

        Type enumType = null;
        if (isEnum)
        {
            enumType = enumModelType;
        }
        else if (isNullableEnum)
        {
            enumType = enumModelType.GenericTypeArguments[0];
        }

        foreach (Enum item in Enum.GetValues(enumType))
        {
            if (Convert.ToInt32(item) != 0)
            {
                var ti = htmlHelper.ViewData.TemplateInfo;
                var id = ti.GetFullHtmlFieldId(item.ToString());

                //Derive property name for checkbox name
                var body = expression.Body as MemberExpression;
                var propertyName = body.Member.Name;
                var name = ti.GetFullHtmlFieldName(propertyName);

                //Get currently select values from the ViewData model
                //TEnum selectedValues = expression.Compile().Invoke(htmlHelper.ViewData.Model);

                var label = new TagBuilder("label");
                label.Attributes["for"] = id;
                label.Attributes["style"] = "display: inline-block;";
                var field = item.GetType().GetField(item.ToString());

                // Add checkbox.
                var checkbox = new TagBuilder("input");
                checkbox.Attributes["id"] = id;
                checkbox.Attributes["name"] = name;
                checkbox.Attributes["type"] = "checkbox";
                checkbox.Attributes["value"] = item.ToString();

                var model = (metadata.Model as Enum);

                //var model = htmlHelper.ViewData.Model as Enum; //Old Code
                if (model != null && model.HasFlag(item))
                {
                    checkbox.Attributes["checked"] = "checked";
                }
                sb.AppendLine(checkbox.ToString());

                // Check to see if DisplayName attribute has been set for item.
                var displayName = field.GetCustomAttributes(typeof(DisplayNameAttribute), true)
                    .FirstOrDefault() as DisplayNameAttribute;
                if (displayName != null)
                {
                    // Display name specified.  Use it.
                    label.SetInnerText(displayName.DisplayName);
                }
                else
                {
                    // Check to see if Display attribute has been set for item.
                    var display = field.GetCustomAttributes(typeof(DisplayAttribute), true)
                        .FirstOrDefault() as DisplayAttribute;
                    if (display != null)
                    {
                        label.SetInnerText(display.Name);
                    }
                    else
                    {
                        label.SetInnerText(item.ToString());
                    }
                }
                sb.AppendLine(label.ToString());

                // Add line break.
                sb.AppendLine("<br />");
            }
        }

        return new HtmlString(sb.ToString());
    }
}


public class FlagEnumerationModelBinder : DefaultModelBinder
{
    public override object BindModel(ControllerContext controllerContext, ModelBindingContext bindingContext)
    {
        if (bindingContext == null) throw new ArgumentNullException("bindingContext");

        if (bindingContext.ValueProvider.ContainsPrefix(bindingContext.ModelName))
        {
            var values = GetValue<string[]>(bindingContext, bindingContext.ModelName);

            if (values.Length > 1 && (bindingContext.ModelType.IsEnum && bindingContext.ModelType.IsDefined(typeof(FlagsAttribute), false)))
            {
                long byteValue = 0;
                foreach (var value in values.Where(v => Enum.IsDefined(bindingContext.ModelType, v)))
                {
                    byteValue |= (int)Enum.Parse(bindingContext.ModelType, value);
                }

                return Enum.Parse(bindingContext.ModelType, byteValue.ToString());
            }
            else
            {
                return base.BindModel(controllerContext, bindingContext);
            }
        }

        return base.BindModel(controllerContext, bindingContext);
    }

    private static T GetValue<T>(ModelBindingContext bindingContext, string key)
    {
        if (bindingContext.ValueProvider.ContainsPrefix(key))
        {
            ValueProviderResult valueResult = bindingContext.ValueProvider.GetValue(key);
            if (valueResult != null)
            {
                bindingContext.ModelState.SetModelValue(key, valueResult);
                return (T)valueResult.ConvertTo(typeof(T));
            }
        }
        return default(T);
    }
}


ModelBinders.Binders.Add(
            typeof (SellTypes),
            new FlagEnumerationModelBinder()
            );
ModelBinders.Binders.Add(
            typeof(SellTypes?),
            new FlagEnumerationModelBinder()
            );
1
deadManN

Bitmap, vous avez posé des questions importantes et je peux suggérer la solution suivante: vous devez remplacer la méthode BindProperty de votre ModelBinder et vous devez ensuite remplacer la valeur de la propriété du modèle:

protected override void BindProperty(ControllerContext controllerContext, ModelBindingContext bindingContext, System.ComponentModel.PropertyDescriptor propertyDescriptor)
{
    if (propertyDescriptor.PropertyType.IsEnum && propertyDescriptor.PropertyType.GetCustomAttributes(typeof(FlagsAttribute), false).Any())
    {
        var value = bindingContext.ValueProvider.GetValue(propertyDescriptor.Name);
        if (value != null)
        {
            // Get type of value.
            var rawValues = value.RawValue as string[];
            if (rawValues != null)
            {
                // Create instance of result object.
                var result = (Enum)Activator.CreateInstance(propertyDescriptor.PropertyType);
                try
                {
                    // Try parse enum
                    result = (Enum)Enum.Parse(propertyDescriptor.PropertyType, string.Join(",", rawValues));
                    // Override property with flags value
                    propertyDescriptor.SetValue(bindingContext.Model, result);
                    return;
                }
                catch
                {                               
                }
            }
        }
        base.BindProperty(controllerContext, bindingContext, propertyDescriptor);
    }
    else
        base.BindProperty(controllerContext, bindingContext, propertyDescriptor);
}
1
JMS