Question

I’m attempting to databind to an entry in a dictionary where the key is the enum. I’ve consulted this question, but the answer doesn’t work for me. Here are the non-boilerplate parts of my code:

---

SomePage.xaml:

<!-- Here I try all the ways I can think of. None of them produce any text -->
<TextBlock Text="{Binding Data[0]}" />
<TextBlock Text="{Binding Data[EnumValueA]}" />
<TextBlock Text="{Binding Data[SomeEnum.EnumValueA]}" />
<TextBlock Text="{Binding Data[(local:SomeEnum)EnumValueA]}" />
<TextBlock Text="{Binding Data[(local:SomeEnum)SomeEnum.EnumValueA]}" />

SomePage.xaml.cs:

public SomePage() {
    DataContext = new SomeVM();
    InitializeComponent();
}

SomeVM.cs:

public enum SomeEnum {
    EnumValueA, EnumValueB
}
public class SomeVM {
    public Dictionary<SomeEnum, int> Data { get; private set; }
    public SomeVM() {
        Data = new Dictionary<SomeEnum, int> {
            {SomeEnum.EnumValueA, 1337}
        };
    }
}

Why does this databinding not work?

Answer 1

It is not possible. See http://msdn.microsoft.com/en-us/library/cc645024(v=vs.95).aspx#indexdata

Indexer

Indexers can be used for accessing properties in a path and obtaining
items from a list, but with some notable restrictions:

• List item
• Numeric integer indexers are supported.
• Beginning in Silverlight 4, string indexers are supported.
• Only one-dimensional array indexing is supported.

The type being indexed must implement or inherit IList. (List is
accepted, because it implements IList. However IList is not
accepted.)

Numeric integer indexes are specified by declaring the zero-based
index within bracket ([]) characters after the property name; for
example, Employees[2].

Property path evaluation first attempts to use integer indexing for a
collection. If that indexing is not valid for the collection, then the
information within [] is processed as a string. String indexing from a
property path generally expects a collection / business object that is
a dictionary with string keys. String indexing supports binding to
dynamic data objects where the CLR structure of the data source can
change, but the string keys represent a data contract that can still
be bound to by a client UI.

Validation uses indexers to access items of an attached property’s
collection as part of its property path usage. The validation
structure for the application can declare UI states within templates
that are used only when validation errors are raised, and can then
reference the active error objects in that context. For example, the
following is a property path for a binding that accesses the first
item in a Validation.Errors collection; the context of the property
path is modified by RelativeSource so that the errors are checked only
at run time on the applied template:

 <TextBlock Text="{Binding RelativeSource={RelativeSource
    TemplatedParent}, Path=(Validation.Errors)[0].Exception.Message }">