Feature Request: Named index operators

[jvlppm]

Context

csharp allows you to overload the array indexing operator

public string this[string key]
{
    get { return GetAttribute(key); }
    set { SetAttribute(key, value); }
}

Limitation

But if you want more than one acessor, for example:

public string this[string attribute]
{
    get { return GetAttribute(attribute); }
    set { SetAttribute(attribute, value); }
}

public double this[string metric]
{
    get { return GetMetric(metric); }
    set { SetMetric(metric, value); }
}

this is not allowed, because

var a = obj["key"];

would be ambiguous.
Even if I only want setters, I am not allowed.

Proposal

It would be great, if I could do this instead:

class BaseEvent
{
    public string Attribute[string key]
    {
        get => throw new System.NotImplementedException();
        set => throw new System.NotImplementedException(); // value is string
    }

    public double Metric[string key]
    {
        get => throw new System.NotImplementedException();
        set => throw new System.NotImplementedException(); // value is double
    }
}

And access it like:

obj.Metric["time"] = 0.5;
var a = obj.Metric["time"]; // double

Today

This can be done today, by creating something like this:

class BaseEvent {

    string GetAttribute(string name) { throw new System.NotImplementedException(); }
    void SetAttribute(string name, string value) { throw new System.NotImplementedException(); }
    float GetMetric(string name) { throw new System.NotImplementedException(); }
    void SetMetric(string name, float value) { throw new System.NotImplementedException(); }

    public readonly AttributesAcessor Attributes;
    public readonly MetricsAcessor Metrics;
    public readonly DurationAcessor Times;

    public BaseEvent()
    {
        Attributes = new AttributesAcessor(this);
        Metrics = new MetricsAcessor(this);
        Times = new DurationAcessor(this);
    }

    public class AttributesAcessor {
        BaseEvent baseEvent;
        public AttributesAcessor(BaseEvent baseEvent) {
            this.baseEvent = baseEvent;
        }
        public string this[string key]
        {
            get { return baseEvent.GetAttribute(key); }
            set { baseEvent.SetAttribute(key, value); }
        }
    }

    public class MetricsAcessor {
        BaseEvent baseEvent;
        public MetricsAcessor(BaseEvent baseEvent) {
            this.baseEvent = baseEvent;
        }
        public double this[string key]
        {
            get { return baseEvent.GetMetric(key); }
            set { baseEvent.SetMetric(key, value); }
        }
    }

    public class DurationAcessor {
        BaseEvent baseEvent;
        public DurationAcessor(BaseEvent eventData) {
            this.baseEvent = eventData;
        }
        public TimeSpan this[string key]
        {
            get { return TimeSpan.FromSeconds(baseEvent.GetMetric(key)); }
            set { baseEvent.SetMetric(key, value.TotalSeconds); }
        }
    }
}

public class AppSessionEvent : BaseEvent
{
    public AppSessionEvent()
        : base(EventAppSession)
    {
        DurationByState = new DurationByStateAcessor(this);
    }

    public readonly DurationByStateAcessor DurationByState;

    public class DurationByStateAcessor {
        readonly BaseEvent baseEvent;

        public DurationByStateAcessor(BaseEvent baseEvent)
        {
            this.baseEvent = baseEvent;
        }

        public TimeSpan this[State state]
        {
            get {
                var key = GetEventName(state, prefix: "time_spent_in");
                return baseEvent.Times[key];
            }
            set {
                var key = GetEventName(state, prefix: "time_spent_in");
                baseEvent.Times[key] = value;
            }
        }
    }
}

But is unnecessarily complex for something that could be simple.

[jnm2]

Duplicate of #471?

[jvlppm]

Yes, thank you.

[MkazemAkhgary]

this could be also equivalent using methods, you don't really have to use indexer.

obj.Metric("time", 0.5); //for set
var x = obj.Metric("time"); //for get

though this proposal is kinda cool for set part. it can improve syntax for setter indexers.

[jvlppm]

Yes, this can be done with two separate methods,
but there are two down sides:

1 - Both methods are independent, when they should be together,
The same way a property have its getter and setter together, it would not be good, if they had to be separated.
2 - Setting values with the = operator makes more sense, then calling a method with parameters.

Another thing, maybe the generated code could also be mapped to an interface, for instance IIndexAcessor<string, double> for metrics

interface IIndexAcessor<TKey, TValue> {
    TValue this[TKey key] { get; set; }
}

and I could pass obj.Metrics around, and it would use my acessor.

Is something to think about I believe.
It would help in my scenario.

[MkazemAkhgary]

yes, I agree with concerns that you have. this may not seem useful to some people but they will know its valuable when writing API that everyone loves. 👍

better say it converts ugly syntax into good looking syntax 😃

[HaloFour]

The argument against this feature has always been that in the C# language there is an expectation that the property and the indexer are two separate parts of the expression and that you should be able to assign what you're indexing to its own variable:

var x = foo.Bar[index];
var bar = foo.Bar; // would not work with indexed properties

That argument doesn't seem to have stopped any of the other major CLR languages, though. VB.NET, F# and C++/CLI all support named/custom indexer properties.

[ygc369]

I like this idea.

[quinmars]

This could sometimes be useful. Your workaround, however, can be simplyfied:

class Indexer<TKey, TValue>
{
    readonly Func<TKey, TValue> _Get;
    readonly Action<TKey, TValue> _Set;
    public Indexer(Func<TKey, TValue> get, Action<TKey, TValue> set)
    {
        _Get = get;
        _Set = set;
    }

    public TValue this[TKey k]
    {
        get => _Get(k);
        set => _Set(k, value);
    }
}

static class Indexer
{
    static public Indexer<TKey, TValue> Create<TKey, TValue>(Func<TKey, TValue> get, Action<TKey, TValue> set)
        => new Indexer<TKey, TValue>(get, set);
}

class BaseEvent
{
    public Indexer<double, double> Meteric { get; }
    public BaseEvent()
    {
        double c = 0;

        Meteric = Indexer.Create(
            get: (double k) => c + k,
            set: (k, v) => c = v - k
            );
    }
}

Unfortunately, you still have to separate the declaration and definition of the indexer.

[Corey-M]

@quinmars One issue with the Indexer class you propose is that the _Get and _Set delegates close over the BaseEvent class instance, creating a circular reference chain that can prevent garbage collection from ever cleaning up the object. You need to implement IDisposable on the Indexer class to ensure that the references are released by nulling the delegates. And of course you need to add IDisposable to all of the classes using Indexer to dispose of the Indexer instances...

Potentially this could be solved using weak references and LINQ Expression juggling. It's a bit messy, but doable. Would be nice to have language support to just handle this natively without having to jump through those particular hoops however.

[jvlppm]

Later I was thinking about another Idea, that could be more powerful than this one, it was something like:

public class TestClass
{
    string suffix = "_suffix";

    public property class Attribute
    {
        public string this[string key]
        {
            get => return key + suffix;
            set => throw new System.NotImplementedException();
        }
    }
}

static void Test()
{
    var test = new TestClass();
    var res = test.Attribute["abc"];
}

It would basically be a nested class, with access to its outer class, (yes, like Java).
When the TestClass is instantiated, a instance of Attribute is assigned to a property with the same name.

It would be equivalent of

public class TestClass
{
    string suffix = "_suffix";

    public AttributeClass Attribute = new AttributeClass(this); // I know this is an error, but you get the idea.

    public class AttributeClass
    {
        readonly TestClass outer;
        public AttributeClass(TestClass outer)
        {
            this.outer = outer;
        }

        public string this[string key]
        {
            get => return key + outer.suffix;
            set => throw new System.NotImplementedException();
        }
    }
}

This way, it would be possible to add fields inside AttributeClass and it would still be easy.
But I did not think much about this, and its probably flawed.

[hamarb123]

Would it work like this:
This is how it works in Visual Basic:

Public Class Form1
    Private Sub Main()
        Dim a1 As New a()
        a1.c(0) 'Returns "a"
        (a1.c)(0) 'Returns "b"
    End Sub
End Class

Public Class a
    Private b1 As New b
    Public Property a As b
        Get
            Return b1
        End Get
        Set(value As b)

        End Set
    End Property
    Public Property c(x As Integer) As String
        Get
            Return "a"
        End Get
        Set(value As String)

        End Set
    End Property
End Class

Public Class b
    'I named this c because it has to have a name
    Default Public Property c(x As Integer) As String
        Get
            Return "b"
        End Get
        Set(value As String)

        End Set
    End Property
End Class

This is how it could work in C#

public class Form1
{
    private void Main()
    {
        a a1 = new a();
        a1.c[0] //returns "a";
        (a1.c)[0] //returns "b";
    }
}

public class a
{
    private b b1 = new b();
    public b c
    { 
        get { return b1; } 
        set { }
    }
    public string c[int x]
    { 
        get { return "a"; } 
        set { }
    }
}

public class b
{
    public string this[int x]
    { 
        get { return "b"; } 
        set { }
    }
}

[bonimy]

Was looking to implement this also. I would definitely love to see this feature implemented.