Comment lier une énumération à un contrôle combobox dans WPF ?

Question

J'essaie de trouver un exemple simple où les enums sont affichés tels quels. Tous les exemples que j'ai vus essaient d'ajouter de belles chaînes d'affichage, mais je ne veux pas de cette complexité.

En fait, j'ai une classe qui contient toutes les propriétés que je lie, en fixant d'abord le DataContext à cette classe, puis en spécifiant la liaison comme ceci dans le fichier xaml :

<ComboBox ItemsSource="{Binding Path=EffectStyle}"/>

Mais cela n'affiche pas les valeurs de l'énumération dans le tableau de bord. ComboBox comme des articles.

Answer 1

Vous pouvez le faire à partir du code en plaçant le code suivant dans Window Loaded le gestionnaire d'événements, par exemple :

yourComboBox.ItemsSource = Enum.GetValues(typeof(EffectStyle)).Cast<EffectStyle>();

Si vous avez besoin de le lier dans XAML, vous devez utiliser ObjectDataProvider pour créer un objet disponible comme source de liaison :

<Window x:Class="YourNamespace.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:System="clr-namespace:System;assembly=mscorlib"
        xmlns:StyleAlias="clr-namespace:Motion.VideoEffects">
    <Window.Resources>
        <ObjectDataProvider x:Key="dataFromEnum" MethodName="GetValues"
                            ObjectType="{x:Type System:Enum}">
            <ObjectDataProvider.MethodParameters>
                <x:Type TypeName="StyleAlias:EffectStyle"/>
            </ObjectDataProvider.MethodParameters>
        </ObjectDataProvider>
    </Window.Resources>
    <Grid>
        <ComboBox ItemsSource="{Binding Source={StaticResource dataFromEnum}}"
                  SelectedItem="{Binding Path=CurrentEffectStyle}" />
    </Grid>
</Window>

Attirez l'attention sur le code suivant :

xmlns:System="clr-namespace:System;assembly=mscorlib"
xmlns:StyleAlias="clr-namespace:Motion.VideoEffects"

Guide sur la façon de mettre en correspondance les espaces de noms et les assemblages. MSDN .

Answer 2

J'aimerais que tous les objets que je lie soient définis dans mon ViewModel J'essaie donc d'éviter d'utiliser <ObjectDataProvider> dans le xaml lorsque cela est possible.

Ma solution n'utilise aucune donnée définie dans la vue et aucun code-behind. Seulement un DataBinding, un ValueConverter réutilisable, une méthode pour obtenir une collection de descriptions pour n'importe quel type d'Enum, et une seule propriété dans le ViewModel à lier.

Lorsque je veux lier un Enum à un ComboBox le texte que je veux afficher ne correspond jamais aux valeurs des éléments suivants Enum donc j'utilise le [Description()] pour lui donner le texte que je souhaite voir apparaître dans l'écran. ComboBox . Si j'avais un enum des jours de la semaine, il ressemblerait à quelque chose comme ceci :

public enum DayOfWeek
{
  // add an optional blank value for default/no selection
  [Description("")]
  NOT_SET = 0,
  [Description("Sunday")]
  SUNDAY,
  [Description("Monday")]
  MONDAY,
  ...
}

D'abord, j'ai créé une classe d'aide avec quelques méthodes pour traiter les enums. Une méthode obtient une description pour une valeur spécifique, l'autre méthode obtient toutes les valeurs et leurs descriptions pour un type.

public static class EnumHelper
{
  public static string Description(this Enum value)
  {
    var attributes = value.GetType().GetField(value.ToString()).GetCustomAttributes(typeof(DescriptionAttribute), false);
    if (attributes.Any())
      return (attributes.First() as DescriptionAttribute).Description;

    // If no description is found, the least we can do is replace underscores with spaces
    // You can add your own custom default formatting logic here
    TextInfo ti = CultureInfo.CurrentCulture.TextInfo;
    return ti.ToTitleCase(ti.ToLower(value.ToString().Replace("_", " ")));
  }

  public static IEnumerable<ValueDescription> GetAllValuesAndDescriptions(Type t)
  {
    if (!t.IsEnum)
      throw new ArgumentException($"{nameof(t)} must be an enum type");

    return Enum.GetValues(t).Cast<Enum>().Select((e) => new ValueDescription() { Value = e, Description = e.Description() }).ToList();
  }
}

Ensuite, nous créons un ValueConverter . Héritant de MarkupExtension permet de l'utiliser plus facilement dans XAML, sans avoir à le déclarer en tant que ressource.

[ValueConversion(typeof(Enum), typeof(IEnumerable<ValueDescription>))]
public class EnumToCollectionConverter : MarkupExtension, IValueConverter
{
  public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
  {
    return EnumHelper.GetAllValuesAndDescriptions(value.GetType());
  }
  public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
  {
    return null;
  }
  public override object ProvideValue(IServiceProvider serviceProvider)
  {
    return this;
  }
}

Mon ViewModel n'a besoin que d'une seule propriété que mon View peuvent se lier à la fois pour le SelectedValue y ItemsSource de la combobox :

private DayOfWeek dayOfWeek;

public DayOfWeek SelectedDay
{
  get { return dayOfWeek; }
  set
  {
    if (dayOfWeek != value)
    {
      dayOfWeek = value;
      OnPropertyChanged(nameof(SelectedDay));
    }
  }
}

Et enfin, pour lier le ComboBox (en utilisant le ValueConverter en el ItemsSource de liaison)...

<ComboBox ItemsSource="{Binding Path=SelectedDay, Converter={x:EnumToCollectionConverter}, Mode=OneTime}"
          SelectedValuePath="Value"
          DisplayMemberPath="Description"
          SelectedValue="{Binding Path=SelectedDay}" />

Pour mettre en œuvre cette solution, il vous suffit de copier mes EnumHelper et EnumToCollectionConverter classe. Ils travailleront avec tout enums. De plus, je ne l'ai pas inclus ici, mais la fonction ValueDescription est une classe simple avec 2 propriétés d'objet publiques, l'une appelée Value un appelé Description . Vous pouvez le créer vous-même ou modifier le code afin d'utiliser un fichier Tuple<object, object> o KeyValuePair<object, object>

Answer 3

J'ai utilisé une autre solution en utilisant MarkupExtension.

1. J'ai créé une classe qui fournit la source des éléments :

   public class EnumToItemsSource : MarkupExtension
   {
       private readonly Type _type;
   
       public EnumToItemsSource(Type type)
       {
           _type = type;
       }
   
       public override object ProvideValue(IServiceProvider serviceProvider)
       {
           return Enum.GetValues(_type)
               .Cast<object>()
               .Select(e => new { Value = (int)e, DisplayName = e.ToString() });
       }
   }

2. C'est presque tout... Maintenant, utilisez-le dans XAML :

       <ComboBox DisplayMemberPath="DisplayName"
             ItemsSource="{persons:EnumToItemsSource {x:Type enums:States}}"
             SelectedValue="{Binding Path=WhereEverYouWant}"
             SelectedValuePath="Value" />

3. Remplacez 'enums:States' par votre enum.

Answer 4

La réponse de Nick m'a vraiment aidé, mais je me suis rendu compte qu'elle pouvait être légèrement modifiée, pour éviter une classe supplémentaire, ValueDescription. Je me suis souvenu qu'il existe déjà une classe KeyValuePair dans le framework, qui peut donc être utilisée à la place.

Le code ne change que légèrement :

public static IEnumerable<KeyValuePair<string, string>> GetAllValuesAndDescriptions<TEnum>() where TEnum : struct, IConvertible, IComparable, IFormattable
    {
        if (!typeof(TEnum).IsEnum)
        {
            throw new ArgumentException("TEnum must be an Enumeration type");
        }

        return from e in Enum.GetValues(typeof(TEnum)).Cast<Enum>()
               select new KeyValuePair<string, string>(e.ToString(),  e.Description());
    }

public IEnumerable<KeyValuePair<string, string>> PlayerClassList
{
   get
   {
       return EnumHelper.GetAllValuesAndDescriptions<PlayerClass>();
   }
}

et enfin le XAML :

<ComboBox ItemSource="{Binding Path=PlayerClassList}"
          DisplayMemberPath="Value"
          SelectedValuePath="Key"
          SelectedValue="{Binding Path=SelectedClass}" />

J'espère que cela sera utile à d'autres.

Answer 5

Vous devrez créer un tableau des valeurs de l'enum, qui peut être créé en appelant System.Enum.GetValues() en lui transmettant le Type de l'enum dont vous voulez les éléments.

Si vous le spécifiez pour l'option ItemsSource alors elle doit être remplie avec toutes les valeurs de l'enum. Vous voulez probablement lier SelectedItem a EffectStyle (en supposant qu'il s'agit d'une propriété du même enum, et qu'elle contient la valeur actuelle).