ASP.NET'te bir Enum'u bir DropDownList denetimine nasıl bağlarsınız?

Diyelim ki aşağıdaki basit numaralandırma var:

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

Bu numaralandırmayı bir DropDownList denetimine nasıl bağlayabilirim, böylece açıklamalar listede görüntülenir ve bir seçenek seçildikten sonra ilişkili sayısal değeri (1,2,3) alır?

Muhtemelen verileri bir sıralama olduğu için bağlamazdım ve derleme süresinden sonra değişmez (bu durgun anlardan birine sahip olmadıkça ).

Sıralamayı yinelemek daha iyidir:

Dim itemValues As Array = System.Enum.GetValues(GetType(Response))
Dim itemNames As Array = System.Enum.GetNames(GetType(Response))

For i As Integer = 0 To itemNames.Length - 1
    Dim item As New ListItem(itemNames(i), itemValues(i))
    dropdownlist.Items.Add(item)
Next

Veya C # 'da aynı

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

for (int i = 0; i <= itemNames.Length - 1 ; i++) {
    ListItem item = new ListItem(itemNames[i], itemValues[i]);
    dropdownlist.Items.Add(item);
}

Bir NumaralandırmadanEnumeration bir IDictionary<int,string>(Enum değeri ve ad çifti) almak için aşağıdaki yardımcı program sınıfını kullanın ; daha sonra kimlik sözlüğünü bağlanabilir bir Denetime bağlarsınız .

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

Örnek: Numaralandırma verilerini bir denetime bağlamak için yardımcı program sınıfını kullanma

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

Bunu ASP.NET MVC için kullanıyorum :

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

Benim versiyonum sadece yukarıdakilerin sıkıştırılmış bir şeklidir:

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
}

Her Enum türü System.Enum'dan türetilir. Verileri bir açılır liste denetimine bağlamaya (ve değeri almaya) yardımcı olan iki statik yöntem vardır. Bunlar Enum.GetNames ve Enum.Parse. GetNames'i kullanarak, açılır liste kontrolünüze aşağıdaki gibi bağlanabilirsiniz:

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

Şimdi Enum değerini Seçime Geri Dönmek istiyorsanız ...

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

Tüm gönderileri okuduktan sonra, açılır listede enum açıklamasını göstermenin yanı sıra Düzenleme modunda görüntülenirken açılır menüden Model'den uygun değeri seçmeyi desteklemek için kapsamlı bir çözüm buldum:

Sıralama:

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

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

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

enum uzantı sınıfı:

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

Model sınıfı:

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

ve Görüntüle:

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

ve bu açılır listeyi Model'e bağlamadan kullanıyorsanız, bunun yerine şunu kullanabilirsiniz:

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

Böylece, açılır listenizin enum değerleri yerine Açıklama görüntülemesini bekleyebilirsiniz. Ayrıca Düzenle söz konusu olduğunda, modeliniz sayfa gönderildikten sonra açılır listeden seçilen değer ile güncellenecektir.

Diğerlerinin daha önce de söylediği gibi - duruma bağlı olarak farklı numaralandırmalara bağlamanız gerekmedikçe bir numaralandırmaya bağlanmayın. Bunu yapmanın birkaç yolu vardır, aşağıda birkaç örnek.

ObjectDataSource

Bunu ObjectDataSource ile yapmanın bildirime dayalı bir yolu. İlk olarak, DropDownList'i şunlara bağlamak için List'i döndürecek bir BusinessObject sınıfı oluşturun:

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

Ardından, bu BO sınıfını işaret etmek için ASPX sayfasına biraz HTML işaretlemesi ekleyin:

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

Bu seçenek, arkasında kod gerektirmez.

DataBind Arkasındaki Kod

HTML'yi ASPX sayfasındaki en aza indirmek ve Code Behind'da bağlama yapmak için:

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

Her neyse, işin püf noktası GetValues, GetNames vb. Enum türü yöntemlerinin sizin için çalışmasını sağlamaktır.

Bunu ASP.NET'te nasıl yapacağımdan emin değilim ama bu gönderiye bakın ... yardımcı olabilir mi?

Enum.GetValues(typeof(Response));

Linq kullanabilirsiniz:

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

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

Altıncı Cevabı Kullanan Genel Kod.

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

}

Bu cevabı bulduktan sonra bunu yapmanın daha iyi (en azından daha zarif) bir yolu olduğunu düşündüğüm bir şey buldum, geri gelip burada paylaşacağımı düşündüm.

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

Bu muhtemelen eski bir sorudur .. ama benimkini böyle yaptım.

Model:

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
}

Ardından Görünümde: açılır menüyü nasıl kullanacağınız aşağıda açıklanmıştır.

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

Bu, sıralama listenizdeki her şeyi doldurmalıdır. Bu yardımcı olur umarım..

Tam olarak aradığınız bu değil, ancak yardımcı olabilir:

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

Her listeyi geçebilmek için neden böyle kullanmıyorsunuz?

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

ASP.NET o zamandan beri bazı daha fazla işlevsellikle güncellendi ve artık açılır listeye yerleşik enum kullanabilirsiniz.

Enum'un kendisine bağlanmak istiyorsanız, şunu kullanın:

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

Bir Response örneğine bağlıyorsanız, şunu kullanın:

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

Bu, LINQ kullanarak Açılır Menüye Enum ve DataBind (Metin ve Değer) Siparişi Verme çözümümdür

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

"ASP.NET MVC - Enums için DropDownList yardımcısı oluşturma" adlı özel bir yardımcı oluşturma hakkındaki yazıma göz atın: http://blogs.msdn.com/b/stuartleeks/archive/2010/05/21/asp-net-mvc -oluşturma-a-dropdownlist-yardımcı-için-enums.aspx

Birleşik giriş kutunuzda (veya başka bir kontrolde) daha kullanıcı dostu bir açıklama olmasını isterseniz, aşağıdaki işlevle Açıklama özniteliğini kullanabilirsiniz:

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

Burada, Açıklama özniteliklerinin uygulandığı bir enum örneği verilmiştir:

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

Sonra kontrole böyle bağlayın ...

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

Bu şekilde, değişken adı gibi görünmek zorunda kalmadan açılır menüye istediğiniz metni koyabilirsiniz.

Uzantı yöntemlerini de kullanabilirsiniz. Uzantılara aşina olmayanlar için VB ve C # belgelerine bakmanızı öneririm .

VB Uzantısı:

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

Uzantıyı kullanmak için:

Imports <projectName>.CustomExtensions.ListItemCollectionExtension

...

yourDropDownList.Items.AddEnum(Of EnumType)()

C # Uzantısı:

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

Uzantıyı kullanmak için:

using CustomExtensions.ListItemCollectionExtension;

...

yourDropDownList.Items.AddEnum<EnumType>()

Seçili öğeyi aynı anda ayarlamak istiyorsanız

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

ile

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)

İnt boyutu yerine System.Enum'a dönüştürülerek ve çıktı sorunları önlenir. Örneğin 0xFFFF0000, uint olarak 4294901760, ancak int olarak -65536 olur.

TryCast ve System.Enum olarak Convert.ChangeType'tan (enumTypeValues ​​[i], enumUnderType) .ToString () (hız testlerimde 12:13) biraz daha hızlı.

Comboox ve dropdownlist ile hem asp.net hem de winforms öğreticisi: C # WinForms ve Asp.Net'te Combobox ile Enum nasıl kullanılır

umut yardımcı olur

Kabul edilen çözüm işe yaramaz, ancak aşağıdaki kod diğerlerinin en kısa çözümü aramasına yardımcı olacaktır.

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

Bunu çok daha kısa sürede yapabilirsin

public enum Test
    {
        Test1 = 1,
        Test2 = 2,
        Test3 = 3
    }
    class Program
    {
        static void Main(string[] args)
        {

            var items = Enum.GetValues(typeof(Test));

            foreach (var item in items)
            {
                //Gives you the names
                Console.WriteLine(item);
            }


            foreach(var item in (Test[])items)
            {
                // Gives you the numbers
                Console.WriteLine((int)item);
            }
        }
    }