[C#] Comment lier un Enum à un contrôle DropDownList dans ASP.NET?


Answers

Utilisez la classe d'utilitaires suivante Enumeration pour obtenir un IDictionary<int,string> (paire Enum value & name) d'une énumération ; Vous liez ensuite l' IDictionary à un contrôle pouvant être lié.

public static class Enumeration
{
    public static IDictionary<int, string> GetAll<TEnum>() where TEnum: struct
    {
        var enumerationType = typeof (TEnum);

        if (!enumerationType.IsEnum)
            throw new ArgumentException("Enumeration type is expected.");

        var dictionary = new Dictionary<int, string>();

        foreach (int value in Enum.GetValues(enumerationType))
        {
            var name = Enum.GetName(enumerationType, value);
            dictionary.Add(value, name);
        }

        return dictionary;
    }
}

Exemple: Utilisation de la classe d'utilitaire pour lier des données d'énumération à un contrôle

ddlResponse.DataSource = Enumeration.GetAll<Response>();
ddlResponse.DataTextField = "Value";
ddlResponse.DataValueField = "Key";
ddlResponse.DataBind();
Question

Disons que j'ai l'énumération simple suivante:

enum Response
{
    Yes = 1,
    No = 2,
    Maybe = 3
}

Comment puis-je lier cette énumération à un contrôle DropDownList afin que les descriptions soient affichées dans la liste ainsi que récupérer la valeur numérique associée (1,2,3) une fois qu'une option a été sélectionnée?




Je l'utilise pour ASP.NET MVC :

Html.DropDownListFor(o => o.EnumProperty, Enum.GetValues(typeof(enumtype)).Cast<enumtype>().Select(x => new SelectListItem { Text = x.ToString(), Value = ((int)x).ToString() }))



public enum Color
{
    RED,
    GREEN,
    BLUE
}

ddColor.DataSource = Enum.GetNames(typeof(Color));
ddColor.DataBind();






ASP.NET a depuis été mis à jour avec plus de fonctionnalités, et vous pouvez maintenant utiliser enum intégré à la liste déroulante.

Si vous voulez vous lier à l'Enum lui-même, utilisez ceci:

@Html.DropDownList("response", EnumHelper.GetSelectList(typeof(Response)))

Si vous liez une instance de Response, utilisez ceci:

// Assuming Model.Response is an instance of Response
@Html.EnumDropDownListFor(m => m.Response)



Comme d'autres l'ont déjà dit - ne pas envoyer de données à une énumération, à moins que vous ayez besoin de vous lier à des énumérations différentes en fonction de la situation. Il y a plusieurs façons de le faire, quelques exemples ci-dessous.

ObjectDataSource

Une manière déclarative de le faire avec ObjectDataSource. Tout d'abord, créez une classe BusinessObject qui retournera la liste pour lier la DropDownList à:

public class DropDownData
{
    enum Responses { Yes = 1, No = 2, Maybe = 3 }

    public String Text { get; set; }
    public int Value { get; set; }

    public List<DropDownData> GetList()
    {
        var items = new List<DropDownData>();
        foreach (int value in Enum.GetValues(typeof(Responses)))
        {
            items.Add(new DropDownData
                          {
                              Text = Enum.GetName(typeof (Responses), value),
                              Value = value
                          });
        }
        return items;
    }
}

Ajoutez ensuite un balisage HTML à la page ASPX pour pointer vers cette classe BO:

<asp:DropDownList ID="DropDownList1" runat="server" 
    DataSourceID="ObjectDataSource1" DataTextField="Text" DataValueField="Value">
</asp:DropDownList>
<asp:ObjectDataSource ID="ObjectDataSource1" runat="server" 
    SelectMethod="GetList" TypeName="DropDownData"></asp:ObjectDataSource>

Cette option ne nécessite aucun code derrière.

Code derrière DataBind

Pour réduire le code HTML dans la page ASPX et lier dans Code Behind:

enum Responses { Yes = 1, No = 2, Maybe = 3 }

protected void Page_Load(object sender, EventArgs e)
{
    if (!IsPostBack)
    {
        foreach (int value in Enum.GetValues(typeof(Responses)))
        {
            DropDownList1.Items.Add(new ListItem(Enum.GetName(typeof(Responses), value), value.ToString()));
        }
    }
}

Quoi qu'il en soit, l'astuce consiste à laisser les méthodes de type Enum de GetValues, GetNames etc. fonctionner pour vous.




Vous pouvez également utiliser des méthodes d'extension. Pour ceux qui ne connaissent pas les extensions, je suggère de vérifier la documentation VB et C # .

VB Extension:

Namespace CustomExtensions
    Public Module ListItemCollectionExtension

        <Runtime.CompilerServices.Extension()> _
        Public Sub AddEnum(Of TEnum As Structure)(items As System.Web.UI.WebControls.ListItemCollection)
            Dim enumerationType As System.Type = GetType(TEnum)
            Dim enumUnderType As System.Type = System.Enum.GetUnderlyingType(enumType)

            If Not enumerationType.IsEnum Then Throw New ArgumentException("Enumeration type is expected.")

            Dim enumTypeNames() As String = System.Enum.GetNames(enumerationType)
            Dim enumTypeValues() As TEnum = System.Enum.GetValues(enumerationType)

            For i = 0 To enumTypeNames.Length - 1
                items.Add(New System.Web.UI.WebControls.ListItem(saveResponseTypeNames(i), TryCast(enumTypeValues(i), System.Enum).ToString("d")))
            Next
        End Sub
    End Module
End Namespace

Pour utiliser l'extension:

Imports <projectName>.CustomExtensions.ListItemCollectionExtension

...

yourDropDownList.Items.AddEnum(Of EnumType)()

C # Extension:

namespace CustomExtensions
{
    public static class ListItemCollectionExtension
    {
        public static void AddEnum<TEnum>(this System.Web.UI.WebControls.ListItemCollection items) where TEnum : struct
        {
            System.Type enumType = typeof(TEnum);
            System.Type enumUnderType = System.Enum.GetUnderlyingType(enumType);

            if (!enumType.IsEnum) throw new Exception("Enumeration type is expected.");

            string[] enumTypeNames = System.Enum.GetNames(enumType);
            TEnum[] enumTypeValues = (TEnum[])System.Enum.GetValues(enumType);

            for (int i = 0; i < enumTypeValues.Length; i++)
            {
                items.add(new System.Web.UI.WebControls.ListItem(enumTypeNames[i], (enumTypeValues[i] as System.Enum).ToString("d")));
            }
        }
    }
}

Pour utiliser l'extension:

using CustomExtensions.ListItemCollectionExtension;

...

yourDropDownList.Items.AddEnum<EnumType>()

Si vous souhaitez définir l'élément sélectionné en même temps, remplacez

items.Add(New System.Web.UI.WebControls.ListItem(saveResponseTypeNames(i), saveResponseTypeValues(i).ToString("d")))

avec

Dim newListItem As System.Web.UI.WebControls.ListItem
newListItem = New System.Web.UI.WebControls.ListItem(enumTypeNames(i), Convert.ChangeType(enumTypeValues(i), enumUnderType).ToString())
newListItem.Selected = If(EqualityComparer(Of TEnum).Default.Equals(selected, saveResponseTypeValues(i)), True, False)
items.Add(newListItem)

En convertissant à System.Enum plutôt que la taille int et les problèmes de sortie sont évités. Par exemple 0xFFFF0000 serait 4294901760 comme uint mais serait -65536 comme un int.

TryCast et System.Enum sont légèrement plus rapides que Convert.ChangeType (enumTypeValues ​​[i], enumUnderType) .ToString () (12:13 dans mes tests de vitesse).




Je ne suis pas sûr de savoir comment le faire dans ASP.NET, mais vérifiez ce post ... il pourrait aider?

Enum.GetValues(typeof(Response));



C'est probablement une vieille question ... mais c'est comme ça que j'ai fait le mien.

Modèle:

public class YourEntity
{
   public int ID { get; set; }
   public string Name{ get; set; }
   public string Description { get; set; }
   public OptionType Types { get; set; }
}

public enum OptionType
{
    Unknown,
    Option1, 
    Option2,
    Option3
}

Puis dans la vue: voici comment utiliser le menu déroulant.

@Html.EnumDropDownListFor(model => model.Types, htmlAttributes: new { @class = "form-control" })

Cela devrait peupler tout dans votre liste enum. J'espère que cela t'aides..




Ceci est ma solution pour commander un Enum et DataBind (texte et valeur) à Dropdown en utilisant LINQ

var mylist = Enum.GetValues(typeof(MyEnum)).Cast<MyEnum>().ToList<MyEnum>().OrderBy(l => l.ToString());
foreach (MyEnum item in mylist)
    ddlDivisao.Items.Add(new ListItem(item.ToString(), ((int)item).ToString()));






Après avoir trouvé cette réponse, j'ai trouvé ce que je pense être une meilleure façon (au moins plus élégante) de le faire, je pensais que je reviendrais le partager ici.

Page_Load:

DropDownList1.DataSource = Enum.GetValues(typeof(Response));
DropDownList1.DataBind();

LoadValues:

Response rIn = Response.Maybe;
DropDownList1.Text = rIn.ToString();

SaveValues:

Response rOut = (Response) Enum.Parse(typeof(Response), DropDownList1.Text);