¿Cómo enlaza una enumeración a un control de lista desplegable en ASP.NET?

Use la siguiente clase de utilidad Enumeration para obtener un IDictionary<int,string> (Par de nombres y valores de enumeración) de una Enumeración ; luego vincule el IDictionary a un Control enlazable.

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

Ejemplo: Usando la clase de utilidad para enlazar datos de enumeración a un control

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

Uso esto para 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() }))

Mi versión es solo una forma comprimida de lo anterior:

foreach (Response r in Enum.GetValues(typeof(Response)))
{
    ListItem item = new ListItem(Enum.GetName(typeof(Response), r), r.ToString());
    DropDownList1.Items.Add(item);
}

public enum Color
{
    RED,
    GREEN,
    BLUE
}

Cada tipo de enumeración deriva de System.Enum. Hay dos métodos estáticos que ayudan a enlazar datos a un control de lista desplegable (y recuperar el valor). Estos son Enum.GetNames y Enum.Analizar. Usando GetNames, puede enlazar a su control de lista desplegable de la siguiente manera:

protected System.Web.UI.WebControls.DropDownList ddColor;

private void Page_Load(object sender, System.EventArgs e)
{
     if(!IsPostBack)
     {
        ddColor.DataSource = Enum.GetNames(typeof(Color));
        ddColor.DataBind();
     }
}

Ahora si desea que el valor de Enumeración vuelva a la Selección ....

  private void ddColor_SelectedIndexChanged(object sender, System.EventArgs e)
  {
   Color selectedColor = (Color)Enum.Parse(ddColor.SelectedValue); 
  }

Después de leer todos los mensajes que se me ocurrió una solución completa para apoyar mostrando descripción enum en la lista desplegable, así como seleccionar el valor adecuado del Modelo en el menú desplegable cuando se muestra en el modo de edición:

Enumeración:

using System.ComponentModel;
public enum CompanyType
{
    [Description("")]
    Null = 1,

    [Description("Supplier")]
    Supplier = 2,

    [Description("Customer")]
    Customer = 3
}

Clase de extensión de enumeración:

using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Web.Mvc;

public static class EnumExtension
{
    public static string ToDescription(this System.Enum value)
    {
        var attributes = (DescriptionAttribute[])value.GetType().GetField(value.ToString()).GetCustomAttributes(typeof(DescriptionAttribute), false);
        return attributes.Length > 0 ? attributes[0].Description : value.ToString();
    }

    public static IEnumerable<SelectListItem> ToSelectList<T>(this System.Enum enumValue)
    {
        return
            System.Enum.GetValues(enumValue.GetType()).Cast<T>()
                  .Select(
                      x =>
                      new SelectListItem
                          {
                              Text = ((System.Enum)(object) x).ToDescription(),
                              Value = x.ToString(),
                              Selected = (enumValue.Equals(x))
                          });
    }
}

Clase modelo:

public class Company
{
    public string CompanyName { get; set; }
    public CompanyType Type { get; set; }
}

Y Ver:

@Html.DropDownListFor(m => m.Type,
@Model.Type.ToSelectList<CompanyType>())

Y si está utilizando ese menú desplegable sin vincularse al Modelo, puede usar esto en su lugar:

@Html.DropDownList("type",                  
Enum.GetValues(typeof(CompanyType)).Cast<CompanyType>()
.Select(x => new SelectListItem {Text = x.ToDescription(), Value = x.ToString()}))

Así que al hacerlo, puede esperar su menú desplegable muestra la descripción en lugar de los valores de enumeración. También cuando se trata de Editar, su modelo se actualizará mediante el valor seleccionado desplegable después de publicar la página.

Como ya han dicho otros, no asocie datos a una enumeración, a menos que necesite enlazar a diferentes enumeraciones dependiendo de la situación. Hay varias maneras de hacer esto, un par de ejemplos a continuación.

ObjectDataSource

Una forma declarativa de hacerlo con ObjectDataSource. Primero, cree una clase BusinessObject que devolverá la Lista para enlazar la lista desplegable a:

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

Luego agrega algo de marcado HTML a la página ASPX para apuntar a esta clase 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>

Esto opción no requiere código detrás.

Código detrás de DataBind

Para minimizar el HTML en la página ASPX y hacer enlace en el código Detrás:

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

De todos modos, el truco es dejar que los métodos de tipo Enum de getValues, GetNames, etc. para trabajar para ti.

No estoy seguro de cómo hacerlo en ASP.NET pero echa un vistazo este post... podría ayudar?

Enum.GetValues(typeof(Response));

Array itemValues = Enum.GetValues(typeof(TaskStatus));
Array itemNames = Enum.GetNames(typeof(TaskStatus));

for (int i = 0; i <= itemNames.Length; i++)
{
    ListItem item = new ListItem(itemNames.GetValue(i).ToString(),
    itemValues.GetValue(i).ToString());
    ddlStatus.Items.Add(item);
}

public enum Color
{
    RED,
    GREEN,
    BLUE
}

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

Podrías usar linq:

var responseTypes= Enum.GetNames(typeof(Response)).Select(x => new { text = x, value = (int)Enum.Parse(typeof(Response), x) });
    DropDownList.DataSource = responseTypes;
    DropDownList.DataTextField = "text";
    DropDownList.DataValueField = "value";
    DropDownList.DataBind();

Código Genérico Usando La Respuesta seis.

public static void BindControlToEnum(DataBoundControl ControlToBind, Type type)
{
    //ListControl

    if (type == null)
        throw new ArgumentNullException("type");
    else if (ControlToBind==null )
        throw new ArgumentNullException("ControlToBind");
    if (!type.IsEnum)
        throw new ArgumentException("Only enumeration type is expected.");

    Dictionary<int, string> pairs = new Dictionary<int, string>();

    foreach (int i in Enum.GetValues(type))
    {
        pairs.Add(i, Enum.GetName(type, i));
    }
    ControlToBind.DataSource = pairs;
    ListControl lstControl = ControlToBind as ListControl;
    if (lstControl != null)
    {
        lstControl.DataTextField = "Value";
        lstControl.DataValueField = "Key";
    }
    ControlToBind.DataBind();

}

Después de encontrar esta respuesta se me ocurrió lo que creo que es una mejor (al menos más elegante) manera de hacer esto, pensé en volver y compartirlo aquí.

Page_Load:

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

Valores de carga:

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

SaveValues:

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

Eso no es exactamente lo que estás buscando, pero podría ayudar:

Http://blog.jeffhandley.com/archive/2008/01/27/enum-list-dropdown-control.aspx

¿Por qué no usar así para poder pasar cada listControle :

public static void BindToEnum(Type enumType, ListControl lc)
        {
            // get the names from the enumeration
            string[] names = Enum.GetNames(enumType);
            // get the values from the enumeration
            Array values = Enum.GetValues(enumType);
            // turn it into a hash table
            Hashtable ht = new Hashtable();
            for (int i = 0; i < names.Length; i++)
                // note the cast to integer here is important
                // otherwise we'll just get the enum string back again
                ht.Add(names[i], (int)values.GetValue(i));
            // return the dictionary to be bound to
            lc.DataSource = ht;
            lc.DataTextField = "Key";
            lc.DataValueField = "Value";
            lc.DataBind();
        }

BindToEnum(typeof(NewsType), DropDownList1);
BindToEnum(typeof(NewsType), CheckBoxList1);
BindToEnum(typeof(NewsType), RadoBuuttonList1);

Esta es mi solución para Ordenar una Enumeración y DataBind(Texto y Valor)a Desplegable usando 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()));

Por alguna razón la respuesta proporcionada por Mark Glorie no funcionó para mí. Como los getValues devuelven un objeto de matriz y no pude usar indexer para obtener su valor de elementos. Traté de itemsValue.getValue (i) y funcionó, pero desafortunadamente, no llenó el valor de la enumeración al valor del elemento de la lista desplegable. Simplemente rellenó el nombre del elemento enum como el texto y el valor de la lista desplegable.

Modifiqué el código de Mark aún más y lo he publicado como la solución aquí Cómo atar una enumeración con su valor a la lista desplegable en ASP.NET?

Espero que esto ayude.

Gracias

Echa un vistazo a mi post sobre la creación de un ayudante personalizado "ASP.NET MVC-Crear un ayudante de lista desplegable para enumeraciones":http://blogs.msdn.com/b/stuartleeks/archive/2010/05/21/asp-net-mvc-creating-a-dropdownlist-helper-for-enums.aspx

Si desea tener una descripción más fácil de usar en su cuadro combinado (u otro control), puede usar el atributo Description con la siguiente función:

    public static object GetEnumDescriptions(Type enumType)
    {
        var list = new List<KeyValuePair<Enum, string>>();
        foreach (Enum value in Enum.GetValues(enumType))
        {
            string description = value.ToString();
            FieldInfo fieldInfo = value.GetType().GetField(description);
            var attribute = fieldInfo.GetCustomAttributes(typeof(DescriptionAttribute), false).First();
            if (attribute != null)
            {
                description = (attribute as DescriptionAttribute).Description;
            }
            list.Add(new KeyValuePair<Enum, string>(value, description));
        }
        return list;
    }

Aquí hay un ejemplo de una enumeración con atributos de descripción aplicados:

    enum SampleEnum
    {
        NormalNoSpaces,
        [Description("Description With Spaces")]
        DescriptionWithSpaces,
        [Description("50%")]
        Percent_50,
    }

Luego Enlazar a control de esta manera...

        m_Combo_Sample.DataSource = GetEnumDescriptions(typeof(SampleEnum));
        m_Combo_Sample.DisplayMember = "Value";
        m_Combo_Sample.ValueMember = "Key";

De esta manera puede poner cualquier texto que desee en el menú desplegable sin que tenga que parecerse a un nombre de variable

También podría usar métodos de extensión. Para aquellos que no están familiarizados con extensiones, sugiero revisar la documentación VB y C#.

Extensión VB:

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

Para usar la extensión:

Imports <projectName>.CustomExtensions.ListItemCollectionExtension

...

yourDropDownList.Items.AddEnum(Of EnumType)()

Extensión C#:

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

Para usar la extensión:

using CustomExtensions.ListItemCollectionExtension;

...

yourDropDownList.Items.AddEnum<EnumType>()

Si desea establecer el elemento seleccionado al mismo tiempo, reemplace

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

Con

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)

Mediante la conversión a Sistema.Enum en lugar de int tamaño y salida se evitan los problemas. Por ejemplo 0xFFFF0000 sería 4294901760 como un uint pero sería -65536 como un int.

TryCast y como Sistema.Enum son ligeramente más rápidos que Convert.ChangeType (enumTypeValues[i], enumUnderType).toString () (12: 13 en mis pruebas de velocidad).

Ambos asp.net y winforms tutorial con combobox y dropdownlist: Cómo usar Enum con Combobox en WinForms de C# y Asp.Net

La esperanza ayuda

ASP.NET desde entonces se ha actualizado con un poco más de funcionalidad, y ahora se puede utilizar incorporado enum a desplegable.

Si quieres enlazar la enumeración misma, usa esto:

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

Si estás enlazando una instancia de Respuesta, usa esto:

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

La solución aceptada no funciona, pero el siguiente código ayudará a otros que buscan la solución más corta.

 foreach (string value in Enum.GetNames(typeof(Response)))
                    ddlResponse.Items.Add(new ListItem()
                    {
                        Text = value,
                        Value = ((int)Enum.Parse(typeof(Response), value)).ToString()
                    });

Esta es probablemente una vieja pregunta.. pero así es como hice el mío.

Modelo:

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
}

Luego en la vista: aquí está cómo usar rellenar el menú desplegable.

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

Esto debería llenar todo en su lista de enumeraciones. Espero que esto ayude..