Lo sé, lo sé ... La respuesta de Eric Lippert a este tipo de preguntas suele ser algo así como "porque no valía la pena el costo de diseñarlo, implementarlo, probarlo y documentarlo".

Pero aún así, me gustaría una mejor explicación ... estaba leyendoesta publicación de blog sobre nuevas características de C # 4, y en la sección sobre Interoperabilidad COM, la siguiente parte me llamó la atención:

Por cierto, este código usa una nueva característica más: propiedades indexadas (observe más de cerca los corchetes después de Range).Pero esta función solo está disponible para interoperabilidad COM; no puede crear sus propias propiedades indexadas en C # 4.0.

Está bien, pero por qué ? Ya sabía y lamentaba que no fuera posible crear propiedades indexadas en C #, pero esta oración me hizo pensar de nuevo. Puedo ver varias buenas razones para implementarlo:

el CLR lo admite (por ejemplo,PropertyInfo.GetValue tiene unindex parámetro), por lo que es una pena que no podamos aprovecharlo en C #es compatible con la interoperabilidad COM, como se muestra en el artículo (mediante el envío dinámico)se implementa en VB.NETya es posible crear indexadores, es decir, aplicar un índice al objeto en sí mismo, por lo que probablemente no sería un gran problema extender la idea a las propiedades, manteniendo la misma sintaxis y simplemente reemplazandothis con un nombre de propiedad

Permitiría escribir ese tipo de cosas:

public class Foo
{
    private string[] _values = new string[3];
    public string Values[int index]
    {
        get { return _values[index]; }
        set { _values[index] = value; }
    }
}

Actualmente, la única solución que conozco es crear una clase interna (ValuesCollection por ejemplo) que implementa un indexador y cambia elValues propiedad para que devuelva una instancia de esa clase interna.

Esto es muy fácil de hacer, pero molesto ... ¡Entonces quizás el compilador podría hacerlo por nosotros! Una opción sería generar una clase interna que implemente el indexador y exponerlo a través de una interfaz genérica pública:

// interface defined in the namespace System
public interface IIndexer<TIndex, TValue>
{
    TValue this[TIndex index]  { get; set; }
}

public class Foo
{
    private string[] _values = new string[3];

    private class <>c__DisplayClass1 : IIndexer<int, string>
    {
        private Foo _foo;
        public <>c__DisplayClass1(Foo foo)
        {
            _foo = foo;
        }

        public string this[int index]
        {
            get { return _foo._values[index]; }
            set { _foo._values[index] = value; }
        }
    }

    private IIndexer<int, string> <>f__valuesIndexer;
    public IIndexer<int, string> Values
    {
        get
        {
            if (<>f__valuesIndexer == null)
                <>f__valuesIndexer = new <>c__DisplayClass1(this);
            return <>f__valuesIndexer;
        }
    }
}

Pero, por supuesto, en ese caso la propiedadRealmente devolver unIIndexer<int, string>, y realmente no sería una propiedad indexada ... Sería mejor generar una propiedad indexada CLR real.

Qué piensas ? ¿Te gustaría ver esta función en C #? Si no, ¿por qué?