WPF——专用枚举器ListBox和ComboBox

public enum EnumTest1 { One=1, Two, Three, Four, Fifty=50, FiftyOne, FiftyTwo }

您可以像这样实例化集合：

public EnumItemList Enum1 { get; set; }
...
this.Enum1 = new EnumItemList(typeof(EnumTest1), true);

然后，您可以将其手动绑定到控件：

public class EnumItem
{
    // The actual value of the enumerator (i.e., DayOfWeek.Monday)
    public object Value               { get; set; }
    // The name of the enumerator value (i.e., "Monday")
    public string Name                { get; set; }
    // The enumerator type (i.e., DayOfWeek)
    public Type   EnumType            { get; set; }
    // The underlying enumerator type (i.e., Int32)
    public Type   UnderlyingType      { get; set; }
    // A helper property that determines how the enumartor value is 
    // displayed in the control
    public bool   ShowOrdinalWithName { get; set; }

    public EnumItem()
    {
        this.ShowOrdinalWithName = false;
    }

    public override string ToString()
    {
        return (this.ShowOrdinalWithName) ? string.Format("({0}) {1}", 
                                                          Convert.ChangeType(this.Value, this.UnderlyingType), 
                                                          Name)
                                          : this.Name;
    }
}

实际上绑定到控件的EnumItemList ObservableCollection负责创建自己的项。它还可以自确定控件是否可以进行多重选择。请记住，如果要在控件中显示一个本地枚举数，则必须自己实例化此集合（已经提供了这样做的示例）。

public class EnumItemList : ObservableCollection
{
    public bool CanMultiSelect { get; set; }

    public EnumItemList(Type enumType, bool showOrd)
    {
        // if the enumerator is decorated with the "Flags" attribute, 
        // more than one item can be selected at a time.
        this.CanMultiSelect = enumType.GetCustomAttributes().Any();
        // find all of the enumerator's members
        this.AsObservableEnum(enumType, showOrd);
    }

    public void AsObservableEnum(Type enumType, bool showOrd)
    {
        // if the specified type is not null AND it is actually an 
        // enum type, we can create the collection
        if (enumType != null && enumType.IsEnum)
        {
            // discover the underlying type (int, long, byte, etc)
            Type underlyingType = Enum.GetUnderlyingType(enumType);

            // get each enum item and add it to the list
            foreach (Enum item in enumType.GetEnumValues())
            {
                this.Add(new EnumItem()
                { 
                    // the name that will probably be displayed in the 
                    // UI component
                    Name           = item.ToString(), 
                    // the actual enum value (DayofWeek.Monday)
                    Value          = item, 
                    // the enum type
                    EnumType       = enumType,
                    // the underlying type (int, long, byte, etc)
                    UnderlyingType = underlyingType,
                    ShowOrdinalWithName = showOrd,
                });
            }
        }
    }
}

//---------------------------------------------------------
// This property allows you to specify the type name for system 
// enumerators (it's pointless to try using local enumerators 
// here because the control won't be able to discover its 
// members.)
public static DependencyProperty EnumTypeNameProperty = 
	DependencyProperty.Register("EnumTypeName", 
                                typeof(string), 
                                typeof(EnumListBox), 
                                new PropertyMetadata(null));
public string EnumTypeName
{
	get { return (string)GetValue(EnumTypeNameProperty); }
	set { SetValue(EnumTypeNameProperty, value); }
}

//---------------------------------------------------------
// This property allows you to turn off the automatic 
// determination of whether or not to use multiple selection. 
// This only affects list boxes because combo boxes do not 
// support multiple-selection. The default value is true.
public static DependencyProperty AutoSelectionModeProperty = 
	DependencyProperty.Register("AutoSelectionMode", 
                                typeof(bool), 
                                typeof(EnumListBox), 
                                new PropertyMetadata(true));
public bool AutoSelectionMode
{
	get { return (bool)GetValue(AutoSelectionModeProperty); }
	set { SetValue(AutoSelectionModeProperty, value); }
}

//---------------------------------------------------------
// This property causes the displayed enumerator name to be 
// pre-pended with the ordnial value of the enumerator. The 
// default value is false.
public static DependencyProperty ShowOrdinalWithNameProperty = 
	DependencyProperty.Register("ShowOrdinalWithName", 
                                typeof(bool), 
                                typeof(EnumListBox), 
                                new PropertyMetadata(false));
public bool ShowOrdinalWithName
{
	get { return (bool)GetValue(ShowOrdinalWithNameProperty); }
	set { SetValue(ShowOrdinalWithNameProperty, value); }
}

也有几个辅助属性：

// This property represents the auto-created collection (for 
// system enums only).
public EnumItemList EnumList { get; set; }

// This property provides the actual Type based on the enum 
// type name
public Type EnumType
{
    get 
    { 
        Type value = (string.IsNullOrEmpty(this.EnumTypeName)) 
                     ? null : Type.GetType(this.EnumTypeName);  
        return value;
    }
}

剩下的唯一事情就是控件对加载的反应。我使用Loaded事件来确定绑定该集合要做什么。当我向ItemsSource添加对XAML内支持的支持时，我觉得有必要验证绑定集合的EnumItemList类型，并发现我必须获取父窗口的DataContext类型。

private void EnumListBox_Loaded(object sender, RoutedEventArgs e)
{
    // avoid errors being displayed in designer
    if (!DesignerProperties.GetIsInDesignMode(this))
    {
        // if the enum type is not null, the enum must be a system enum, so we can 
        // populate/bind automatically
        if (this.EnumType != null)
        {
            // create the list of enums
            this.EnumList = new EnumItemList(this.EnumType, this.ShowOrdinalWithName);

            // create and set the binding
            Binding binding    = new Binding() { Source=this.EnumList };
            this.SetBinding(ListBox.ItemsSourceProperty, binding);
        }
        else
        {
            // otherwise, the developer specifically set the binding, so we have 
            // to get the datacontext from the parent content control (window or 
            // usercontrol) so we can use the specified collection
            this.DataContext = EnumGlobal.FindParent(this).DataContext;

            // before we use it, make sure it's the correct type (it must be a 
            // EnumItemList object)
            if (!(this.ItemsSource is EnumItemList))
            {
                throw new InvalidCastException("The bound collection must be of type EnumItemList.");
            }
        }
        // no matter what happens, see if we can set the list to mult5iple selection
        if (this.ItemsSource != null)
        {
            if (this.AutoSelectionMode)
            {
                this.SelectionMode = (((EnumItemList)(this.ItemsSource)).CanMultiSelect) 
                                     ? SelectionMode.Multiple : SelectionMode.Single;
            }
        }
    }
}

public partial class MainWindow : Window
{
    public EnumItemList Enum1 { get; set; }

    public MainWindow()
    {
        this.InitializeComponent();
        this.DataContext = this;

        // we only have to do this for locally implemented enumerators.
        this.Enum1 = new EnumItemList(typeof(EnumTest1), true);
    }
    ...
}

XAML同样简单，因为缺少样式元素和处理控件中事件的愿望，因此您所要做的就是应用适当的绑定

>ctrls:EnumListBox x:Name="lbLocalEnum1" ItemsSource="{Binding Path=Enum1}" />