Custom Named Property Indexers

Question

Is there any possible way to make a property that uses an indexer other than one global one for the whole class? Here's the gist of what I want to do. Note that in this example, you should pretend I cannot move data or create another Dictionary.

class MyClass
{
    protected Dictionary<string,object> data = new Dictionary<string,object>();
    public object Foo[int index]
    {
        get {
            string name = String.Format("foo{0}",index);
            return data[name];
        }
    }
    public object Bar[int index]
    {
        get {
            string name = String.Format("bar{0}",index);
            return data[name];
        }
    }
}

I would then be able to reference an item of the data named foo15 or bar12 like so

MyClass myClass = new MyClass();
Console.WriteLine(myClass.Foo[15]);
Console.WriteLine(myClass.Bar[12]);

I'm aware you can do this, but this isn't what I want.

    public object this[string index]
    {
        get {
            return data[index];
        }
    }

Why do you want this in the first place? How do you expect its behavior to differ from the ordinary indexer? — EJoshuaS - Stand with Ukraine, Dec 13 '16 at 18:34
@EJoshuaS, I don't want to expose all properties of `data`, but I also don't want to define `FooX` where X is a number 15 times. That results in the same code over and over again, and it makes it difficult to iterate over the `FooX` properties. I want to make it easier so the user of `MyClass` can just reference `Foo[15]`. — Drew Chapin, Dec 13 '16 at 18:37
@EJoshuaS, I suspect I'll end up having to make `Foo` a function (e.g. `public object Foo( int index ) { return data[String.Format("foo{0}",index)]; }`, but I really would prefer to use a property. — Drew Chapin, Dec 13 '16 at 18:39
It doesn't seem like that particular syntax is much better than just using a method (since with an ordinary method you can just do Foo(15), which is the same number of characters). — EJoshuaS - Stand with Ukraine, Dec 13 '16 at 18:42

score 3 · Answer 1 · edited May 23 '17 at 12:30

You can do it, but it requires jumping through some hoops. C# does not support Indexed Properties natively. I learned how using this post: Easy creation of properties that support indexing in C#

First declare an IndexedProperty class:

public class IndexedProperty<TIndex, TValue>
{
    Action<TIndex, TValue> setAction;
    Func<TIndex, TValue> getFunc;

    public IndexedProperty(Func<TIndex, TValue> getFunc, Action<TIndex, TValue> setAction)
    {
        this.getFunc = getFunc;
        this.setAction = setAction;
    }

    public TValue this[TIndex i]
    {
        get
        {
            return getFunc(i);
        }
        set
        {
            setAction(i, value);
        }
    }
}

And here's one example of using it (the referenced post contains a simpler example):

    protected Dictionary<DialogResult, string> ButtonNames { get; set; }
    public IndexedProperty<DialogResult, string> ButtonName
    {
        get
        {
            return new IndexedProperty<DialogResult, string>(
                r =>
                {
                    if (ButtonNames.ContainsKey(r)) return ButtonNames[r];
                    return r.ToString();
                }, 
                (r, val) => ButtonNames[r] = val);
        }
    }

Later...

tableLayoutPanel2.Controls.Add(new Button 
    {
        Text = ButtonName[btn], DialogResult = btn, 
        Anchor = AnchorStyles.Right
    });

And the ButtonNames can be set from outside the class like:

msgbox.ButtonName[DialogResult.Cancel] = "Don't Do The Thing";

score 1 · Answer 2 · answered Apr 16 '22 at 18:38

A class in C# cannot have named indexers but can have multiple indexers with different signature. A possible approach is using different indexer interfaces and let your "named indexer" just return the class itself casted to the proper "interface".

Your example would become:

class MyClass: MyClass.IFooIndexer, MyClass.IBarIndexer
{
    public interface IFooIndexer { object this[int index] { get; } }
    public interface IBarIndexer { object this[int index] { get; } }

    protected Dictionary<string, object> data = new Dictionary<string, object>();

    //implementing Interfaces
    object IFooIndexer.this[int index] { 
        get => data[$"foo{index}"]; 
    }
    object IBarIndexer.this[int index] {
        get => data[$"bar{index}"];
    }

    // these are your "named" indexers
    public IFooIndexer Foo => (IFooIndexer)this;
    public IBarIndexer Bar => (IBarIndexer)this;
    
    //add some data to test with
    public MyClass()
    {
        data.Add("foo15", "<foo 15 value>");
        data.Add("bar12", "<bar 12 value>");
    }
}

score 0 · Answer 3 · answered Dec 13 '16 at 18:34

0

You'll need to create a new type, have Foo return an instance of that type, give that other type an indexer, and have that indexer do whatever you want it to do.

answered Dec 13 '16 at 18:34

Servy

202,030
26
332
449

Custom Named Property Indexers

3 Answers3