Eine Aufzählung an ein WinForms-Kombinationsfeld binden und dann festlegen

Das Enum

public enum Status { Active = 0, Canceled = 3 }; 

Einstellen der Dropdown-Werte davon

cbStatus.DataSource = Enum.GetValues(typeof(Status));

Das Enum vom ausgewählten Element abrufen

Status status; 
Enum.TryParse<Status>(cbStatus.SelectedValue.ToString(), out status); 

Vereinfachen:

Initialisieren Sie diesen Befehl zuerst: (z. B. nach InitalizeComponent())

yourComboBox.DataSource =  Enum.GetValues(typeof(YourEnum));

So rufen Sie ein ausgewähltes Objekt aus der Combobox ab:

YourEnum enum = (YourEnum) yourComboBox.SelectedItem;

Wenn Sie einen Wert für die Combobox festlegen möchten: 

yourComboBox.SelectedItem = YourEnem.Foo;

Der Code

comboBox1.SelectedItem = MyEnum.Something;

ist in Ordnung, das Problem muss in der Datenbindung liegen. DataBinding-Zuweisungen erfolgen nach dem Konstruktor, hauptsächlich beim ersten Anzeigen der Combobox. Versuchen Sie, den Wert im Load-Ereignis festzulegen. Fügen Sie beispielsweise diesen Code hinzu:

protected override void OnLoad(EventArgs e)
{
    base.OnLoad(e);
    comboBox1.SelectedItem = MyEnum.Something;
}

Und prüfen, ob es funktioniert.

Nehmen wir an, Sie haben die folgende Aufzählung

public enum Numbers {Zero = 0, One, Two};

Sie benötigen eine Struktur, um diese Werte einer Zeichenfolge zuzuordnen:

public struct EntityName
{
    public Numbers _num;
    public string _caption;

    public EntityName(Numbers type, string caption)
    {
        _num = type;
        _caption = caption;
    }

    public Numbers GetNumber() 
    {
        return _num;
    }

    public override string ToString()
    {
        return _caption;
    }
}

Geben Sie jetzt ein Array von Objekten zurück, bei dem alle Enummen einem String zugeordnet sind:

public object[] GetNumberNameRange()
{
    return new object[]
    {
        new EntityName(Number.Zero, "Zero is chosen"),
        new EntityName(Number.One, "One is chosen"),
        new EntityName(Number.Two, "Two is chosen")
    };
}

Und füllen Sie Ihr Kombinationsfeld folgendermaßen aus:

ComboBox numberCB = new ComboBox();
numberCB.Items.AddRange(GetNumberNameRange());

Erstellen Sie eine Funktion, um den Aufzählungstyp abzurufen, für den Fall, dass Sie sie an eine Funktion übergeben möchten

public Numbers GetConversionType() 
{
    EntityName type = (EntityName)numberComboBox.SelectedItem;
    return type.GetNumber();           
}

und dann solltest du ok sein :)

Versuchen:

comboBox1.SelectedItem = MyEnum.Something;

EDITS:

Whoops, das hast du schon probiert. Es hat jedoch für mich funktioniert, als meine ComboBox als DropDownList festgelegt wurde. 

Hier ist mein vollständiger Code, der für mich funktioniert (sowohl mit DropDown als auch mit DropDownList):

public partial class Form1 : Form
{
    public enum BlahEnum
    { 
        Red,
        Green,
        Blue,
        Purple
    }

    public Form1()
    {
        InitializeComponent();

        comboBox1.DataSource = Enum.GetValues(typeof(BlahEnum));

    }

    private void button1_Click(object sender, EventArgs e)
    {
        comboBox1.SelectedItem = BlahEnum.Blue;
    }
}

Versuche dies:

// fill list
MyEnumDropDownList.DataSource = Enum.GetValues(typeof(MyEnum));

// binding
MyEnumDropDownList.DataBindings.Add(new Binding("SelectedValue", StoreObject, "StoreObjectMyEnumField"));

StoreObject ist mein Objektbeispiel mit der StoreObjectMyEnumField-Eigenschaft für den Store-MyEnum-Wert.

dies ist die Lösung.

comboBox1.Items.AddRange( Enum.GetNames(typeof(Border3DStyle)));

Und dann verwenden Sie das Aufzählungselement als Text:

toolStripStatusLabel1.BorderStyle = (Border3DStyle)Enum.Parse(typeof(Border3DStyle),comboBox1.Text);

Basierend auf der Antwort von @Amir Shenouda ende ich damit:

Definition der Enumeration:

public enum Status { Active = 0, Canceled = 3 }; 

Einstellen der Dropdown-Werte davon:

cbStatus.DataSource = Enum.GetValues(typeof(Status));

Die Enumeration vom ausgewählten Element abrufen:

Status? status = cbStatus.SelectedValue as Status?;

 public static void FillByEnumOrderByNumber<TEnum>(this System.Windows.Forms.ListControl ctrl, TEnum enum1, bool showValueInDisplay = true) where TEnum : struct
    {
        if (!typeof(TEnum).IsEnum) throw new ArgumentException("An Enumeration type is required.", "enumObj");

        var values = from TEnum enumValue in Enum.GetValues(typeof(TEnum))
                     select
                        new
                         KeyValuePair<TEnum, string>(   (enumValue), enumValue.ToString());

        ctrl.DataSource = values
            .OrderBy(x => x.Key)

            .ToList();

        ctrl.DisplayMember = "Value";
        ctrl.ValueMember = "Key";

        ctrl.SelectedValue = enum1;
    }
    public static void  FillByEnumOrderByName<TEnum>(this System.Windows.Forms.ListControl ctrl, TEnum enum1, bool showValueInDisplay = true  ) where TEnum : struct
    {
        if (!typeof(TEnum).IsEnum) throw new ArgumentException("An Enumeration type is required.", "enumObj");

        var values = from TEnum enumValue in Enum.GetValues(typeof(TEnum))
                     select 
                        new 
                         KeyValuePair<TEnum,string> ( (enumValue),  enumValue.ToString()  );

        ctrl.DataSource = values
            .OrderBy(x=>x.Value)
            .ToList();

        ctrl.DisplayMember = "Value";
        ctrl.ValueMember = "Key";

        ctrl.SelectedValue = enum1;
    }

    public enum Colors
    {
        Red = 10,
        Blue = 20,
        Green = 30,
        Yellow = 40,
    }

comboBox1.DataSource = Enum.GetValues(typeof(Colors));

Full Source ... Enum an Combobox binden

public Form1()
{
    InitializeComponent();
    comboBox.DataSource = EnumWithName<SearchType>.ParseEnum();
    comboBox.DisplayMember = "Name";
}

public class EnumWithName<T>
{
    public string Name { get; set; }
    public T Value { get; set; }

    public static EnumWithName<T>[] ParseEnum()
    {
        List<EnumWithName<T>> list = new List<EnumWithName<T>>();

        foreach (object o in Enum.GetValues(typeof(T)))
        {
            list.Add(new EnumWithName<T>
            {
                Name = Enum.GetName(typeof(T), o).Replace('_', ' '),
                Value = (T)o
            });
        }

        return list.ToArray();
    }
}

public enum SearchType
{
    Value_1,
    Value_2
}

Konvertieren Sie das Enum in eine Liste mit Zeichenfolgen und fügen Sie dies der ComboBox hinzu

comboBox1.DataSource = Enum.GetValues(typeof(SomeEnum)).Cast<SomeEnum>();

Stellen Sie den angezeigten Wert mit selectedItem ein

comboBox1.SelectedItem = SomeEnum.SomeValue;

Ich verwende die folgende Hilfsmethode, die Sie an Ihre Liste binden können.

    ''' <summary>
    ''' Returns enumeration as a sortable list.
    ''' </summary>
    ''' <param name="t">GetType(some enumeration)</param>
    Public Shared Function GetEnumAsList(ByVal t As Type) As SortedList(Of String, Integer)

        If Not t.IsEnum Then
            Throw New ArgumentException("Type is not an enumeration.")
        End If

        Dim items As New SortedList(Of String, Integer)
        Dim enumValues As Integer() = [Enum].GetValues(t)
        Dim enumNames As String() = [Enum].GetNames(t)

        For i As Integer = 0 To enumValues.GetUpperBound(0)
            items.Add(enumNames(i), enumValues(i))
        Next

        Return items

    End Function

Keines davon funktionierte für mich, aber dies tat es (und es hatte den zusätzlichen Vorteil, dass es eine bessere Beschreibung für den Namen der einzelnen Enummen gab). Ich bin nicht sicher, ob es an .net-Updates liegt oder nicht, aber unabhängig davon denke ich, dass dies der beste Weg ist. Sie müssen einen Verweis auf Folgendes hinzufügen:

using System.ComponentModel;

enum MyEnum
{
    [Description("Red Color")]
    Red = 10,
    [Description("Blue Color")]
    Blue = 50
}

....

    private void LoadCombobox()
    {
        cmbxNewBox.DataSource = Enum.GetValues(typeof(MyEnum))
            .Cast<Enum>()
            .Select(value => new
            {
                (Attribute.GetCustomAttribute(value.GetType().GetField(value.ToString()), typeof(DescriptionAttribute)) as DescriptionAttribute).Description,
                value
            })
            .OrderBy(item => item.value)
            .ToList();
        cmbxNewBox.DisplayMember = "Description";
        cmbxNewBox.ValueMember = "value";
    }

Wenn Sie dann auf die Daten zugreifen möchten, verwenden Sie diese beiden Zeilen:

        Enum.TryParse<MyEnum>(cmbxNewBox.SelectedValue.ToString(), out MyEnum proc);
        int nValue = (int)proc;

Generische Methode zum Festlegen einer Aufzählung als Datenquelle für Dropdowns

Die Anzeige wäre Name . Der ausgewählte Wert wäre Enum

public IList<KeyValuePair<string, T>> GetDataSourceFromEnum<T>() where T : struct,IConvertible
    {
        IList<KeyValuePair<string, T>> list = new BindingList<KeyValuePair<string, T>>();
        foreach (string value in Enum.GetNames(typeof(T)))
        {
            list.Add(new KeyValuePair<string, T>(value, (T)Enum.Parse(typeof(T), value)));
        }
        return list;
    }

Im Moment verwende ich die Items-Eigenschaft anstelle der DataSource. Dies bedeutet, dass ich Add für jeden Enumerationswert aufrufen muss, aber es ist eine kleine Enumeration und der temporäre Code.

Dann kann ich einfach Convert.ToInt32 für den Wert ausführen und es mit SelectedIndex einstellen.

Temporäre Lösung, aber vorerst YAGNI.

Prost auf die Ideen, ich werde sie wahrscheinlich verwenden, wenn ich die richtige Version mache, nachdem ich eine Runde Feedback von Kunden erhalten habe.

In Framework 4 können Sie den folgenden Code verwenden:

So binden Sie die MultiColumnMode-Enumeration beispielsweise an die Combobox:

cbMultiColumnMode.Properties.Items.AddRange(typeof(MultiColumnMode).GetEnumNames());

und um einen ausgewählten Index zu erhalten:

MultiColumnMode multiColMode = (MultiColumnMode)cbMultiColumnMode.SelectedIndex;

hinweis: Ich verwende in diesem Beispiel die DevExpress-Combobox. In Win Form Combobox können Sie dasselbe tun

verwenden Sie nur das Gießen auf diese Weise:

if((YouEnum)ComboBoxControl.SelectedItem == YouEnum.Español)
{
   //TODO: type you code here
}

Alte Frage vielleicht hier, aber ich hatte das Problem und die Lösung war einfach und einfach. Ich fand diese http://www.c-sharpcorner.com/UploadFile/mahesh/1220/

Es nutzt das Datenbining und funktioniert gut, also überprüfen Sie es. 

Das war immer ein Problem ... wenn Sie ein sortiertes Enum haben, wie von 0 bis ...

public enum Test
      one
      Two
      Three
 End

sie können Namen an eine Combobox binden und anstelle der .SelectedValue-Eigenschaft .SelectedIndex verwenden.

   Combobox.DataSource = System.Enum.GetNames(GetType(test))

und das

Dim x as byte = 0
Combobox.Selectedindex=x

Sie können die Funktionen "FindString .." verwenden:

Public Class Form1
    Public Enum Test
        pete
        jack
        fran
        bill
    End Enum
    Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load
        ComboBox1.DataSource = [Enum].GetValues(GetType(Test))
        ComboBox1.SelectedIndex = ComboBox1.FindStringExact("jack")
        ComboBox1.SelectedIndex = ComboBox1.FindStringExact(Test.jack.ToString())
        ComboBox1.SelectedIndex = ComboBox1.FindStringExact([Enum].GetName(GetType(Test), Test.jack))
        ComboBox1.SelectedItem = Test.bill
    End Sub
End Class

comboBox1.SelectedItem = MyEnum.Something;

sollte gut funktionieren ... Wie können Sie feststellen, dass SelectedItem null ist?

Sie können eine Erweiterungsmethode verwenden

 public static void EnumForComboBox(this ComboBox comboBox, Type enumType)
 {
     var memInfo = enumType.GetMembers().Where(a => a.MemberType == MemberTypes.Field).ToList();
     comboBox.Items.Clear();
     foreach (var member in memInfo)
     {
         var myAttributes = member.GetCustomAttribute(typeof(DescriptionAttribute), false);
         var description = (DescriptionAttribute)myAttributes;
         if (description != null)
         {
             if (!string.IsNullOrEmpty(description.Description))
             {
                 comboBox.Items.Add(description.Description);
                 comboBox.SelectedIndex = 0;
                 comboBox.DropDownStyle = ComboBoxStyle.DropDownList;
             }
         }   
     }
 }

So verwenden Sie ....__ Enum deklarieren 

using System.ComponentModel;

public enum CalculationType
{
    [Desciption("LoaderGroup")]
    LoaderGroup,
    [Description("LadingValue")]
    LadingValue,
    [Description("PerBill")]
    PerBill
}

Diese Methode zeigt die Beschreibung in Kombinationsfeldelementen

combobox1.EnumForComboBox(typeof(CalculationType));

Sie können eine Liste von KeyValuePair-Werten als Datenquelle für das Kombinationsfeld verwenden. Sie benötigen eine Hilfsmethode, in der Sie den Aufzählungstyp angeben können, und es gibt IEnumerable> zurück, wobei int der Wert von enum und string der Name des enum-Werts ist. Setzen Sie in Ihrer Combobox die DisplayMember-Eigenschaft auf 'Key' und die ValueMember-Eigenschaft auf 'Value'. Value und Key sind öffentliche Eigenschaften der KeyValuePair-Struktur. Wenn Sie dann die SelectedItem-Eigenschaft auf einen Enumerationswert setzen, sollte dies funktionieren.

Ein bisschen spät zu dieser Party, 

Die SelectedValue.ToString () - Methode sollte den DisplayedName abrufen. Dieser Artikel DataBinding Enum und auch With Descriptions zeigt jedoch eine praktische Möglichkeit, dies nicht nur zu haben, sondern Sie können der Enum auch ein benutzerdefiniertes Beschreibungsattribut hinzufügen und es für Ihren angezeigten Wert verwenden, wenn Sie dies vorziehen. Sehr einfach und leicht und ungefähr 15 Zeilen Code (es sei denn, Sie zählen die geschweiften Klammern) für alles.

Es ist ziemlich schicker Code und Sie können es als Erweiterungsmethode zum Booten machen ... 

comboBox1.DataSource = Enum.GetValues(typeof(MyEnum));

comboBox1.SelectedIndex = (int)MyEnum.Something;

comboBox1.SelectedIndex = Convert.ToInt32(MyEnum.Something);

Beide arbeiten für mich, bist du sicher, dass sonst nichts stimmt?

Dies wird wahrscheinlich nie bei allen anderen Antworten zu sehen sein, aber dies ist der Code, den ich mir ausgedacht habe. Dies hat den Vorteil, dass DescriptionAttribute verwendet wird, falls vorhanden, ansonsten jedoch der Name des Enum-Werts selbst .

Ich habe ein Wörterbuch verwendet, weil es ein fertiges Schlüssel-/Wertelementmuster hat. Ein List<KeyValuePair<string,object>> würde auch funktionieren und ohne das unnötige Hashing, aber ein Wörterbuch sorgt für saubereren Code.

Ich bekomme Mitglieder, die MemberType von Field haben und die wörtlich sind. Dadurch wird nur eine Folge von Elementen erstellt, die Enum-Werte sind. Dies ist robust, da eine Aufzählung keine anderen Felder enthalten kann.

public static class ControlExtensions
{
    public static void BindToEnum<TEnum>(this ComboBox comboBox)
    {
        var enumType = typeof(TEnum);

        var fields = enumType.GetMembers()
                              .OfType<FieldInfo>()
                              .Where(p => p.MemberType == MemberTypes.Field)
                              .Where(p => p.IsLiteral)
                              .ToList();

        var valuesByName = new Dictionary<string, object>();

        foreach (var field in fields)
        {
            var descriptionAttribute = field.GetCustomAttribute(typeof(DescriptionAttribute), false) as DescriptionAttribute;

            var value = (int)field.GetValue(null);
            var description = string.Empty;

            if (!string.IsNullOrEmpty(descriptionAttribute?.Description))
            {
                description = descriptionAttribute.Description;
            }
            else
            {
                description = field.Name;
            }

            valuesByName[description] = value;
        }

        comboBox.DataSource = valuesByName.ToList();
        comboBox.DisplayMember = "Key";
        comboBox.ValueMember = "Value";
    }


}