Pourquoi C# n'implémente pas les propriétés indexées?

C# indexeur est une propriété indexée. Il est nommé Item par défaut (et vous pouvez vous y référer en tant que tel à partir de par exemple VB), et vous pouvez le changer avec IndexerNameAttribute si vous voulez.

Je ne sais pas pourquoi, spécifiquement, il a été conçu de cette façon, mais il semble que ce soit une limitation intentionnelle. Il est toutefois conforme aux lignes directrices sur la conception du cadre, qui recommandent l'approche d'un propriété retournant un objet indexable pour les collections des membres. C'est-à-dire que "être indexable" est un trait d'un type; s'il est indexable de plus d'une façon, alors il devrait vraiment être divisé en plusieurs types.

parce que vous pouvez déjà le faire en quelque sorte, et il est forcé de penser dans les aspects OO, l'ajout de propriétés indexées serait tout simplement ajouter plus de bruit à la langue. Et juste une autre façon de faire autre chose.

class Foo
{
    public Values Values { ... }
}

class Values
{
    public string this[int index] { ... }    
}

foo.Values[0]

personnellement, je préfère voir une seule manière de faire quelque chose, plutôt que 10 façons. Mais bien sûr c'est un avis subjectif.

j'avais l'habitude de favoriser l'idée de propriétés indexées, mais j'ai alors réalisé qu'il ajouterait une ambiguïté horrible et en fait dissuasive fonctionnalité. Les propriétés indexées signifieraient que vous n'avez pas d'instance de collecte d'enfants. C'est à la fois bon et mauvais. Il est moins difficile à mettre en œuvre et vous n'avez pas besoin d'une référence retour à la classe de propriétaire enclosing. Mais cela signifie aussi que vous ne pouvez pas passer cette collection d'enfants à quoi que ce soit; vous auriez probablement à énumérer chaque fois. Ni pouvez-vous faire un foreach sur elle. Pire que tout, vous ne pouvez pas dire en regardant une propriété indexée si c'est cela ou une propriété de collection.

l'idée est rationnelle mais elle ne mène qu'à l'inflexibilité et à la maladresse abrupte.

je trouve le manque de propriétés indexées très frustrant en essayant d'écrire du code propre et concis. Une propriété indexée a une connotation très différente de fournir une référence de classe qui est indexée ou de fournir des méthodes individuelles. Je trouve un peu troublant que fournir l'accès à un objet interne qui implémente une propriété indexée soit même considéré comme acceptable car cela brise souvent l'un des composants clés de l'orientation de l'objet: l'encapsulation.

Je rencontre ce problème assez souvent, mais je viens de le rencontrer à nouveau aujourd'hui donc je vais fournir un exemple de code du monde réel. L'interface et la classe étant écrite stocke la configuration de l'application qui est une collection d'informations vaguement liées. J'avais besoin d'ajouter des fragments de script nommés et l'utilisation de l'indexeur de classe sans nom aurait impliqué un contexte très erroné puisque les fragments de script ne sont qu'une partie de la configuration.

si les propriétés indexées étaient disponibles en C # je pourrais ont implémenté le code ci-dessous (la syntaxe est cette[clé] changée en PropertyName[clé]).

public interface IConfig
{
    // Other configuration properties removed for examp[le

    /// <summary>
    /// Script fragments
    /// </summary>
    string Scripts[string name] { get; set; }
}

/// <summary>
/// Class to handle loading and saving the application's configuration.
/// </summary>
internal class Config : IConfig, IXmlConfig
{
  #region Application Configuraiton Settings

    // Other configuration properties removed for examp[le

    /// <summary>
    /// Script fragments
    /// </summary>
    public string Scripts[string name]
    {
        get
        {
            if (!string.IsNullOrWhiteSpace(name))
            {
                string script;
                if (_scripts.TryGetValue(name.Trim().ToLower(), out script))
                    return script;
            }
            return string.Empty;
        }
        set
        {
            if (!string.IsNullOrWhiteSpace(name))
            {
                _scripts[name.Trim().ToLower()] = value;
                OnAppConfigChanged();
            }
        }
    }
    private readonly Dictionary<string, string> _scripts = new Dictionary<string, string>();

  #endregion

    /// <summary>
    /// Clears configuration settings, but does not clear internal configuration meta-data.
    /// </summary>
    private void ClearConfig()
    {
        // Other properties removed for example
        _scripts.Clear();
    }

  #region IXmlConfig

    void IXmlConfig.XmlSaveTo(int configVersion, XElement appElement)
    {
        Debug.Assert(configVersion == 2);
        Debug.Assert(appElement != null);

        // Saving of other properties removed for example

        if (_scripts.Count > 0)
        {
            var scripts = new XElement("Scripts");
            foreach (var kvp in _scripts)
            {
                var scriptElement = new XElement(kvp.Key, kvp.Value);
                scripts.Add(scriptElement);
            }
            appElement.Add(scripts);
        }
    }

    void IXmlConfig.XmlLoadFrom(int configVersion, XElement appElement)
    {
        // Implementation simplified for example

        Debug.Assert(appElement != null);
        ClearConfig();
        if (configVersion == 2)
        {
            // Loading of other configuration properites removed for example

            var scripts = appElement.Element("Scripts");
            if (scripts != null)
                foreach (var script in scripts.Elements())
                    _scripts[script.Name.ToString()] = script.Value;
        }
        else
            throw new ApplicaitonException("Unknown configuration file version " + configVersion);
    }

  #endregion
}

malheureusement les propriétés indexées ne sont pas implémentées donc j'ai implémenté une classe pour les stocker et fourni l'accès à cela. Il s'agit d'une implémentation indésirable car le but de la classe de configuration dans ce modèle de domaine est d'encapsuler tous les détails. Les Clients de cette classe accéderont à des fragments de script spécifiques par leur nom et n'auront aucune raison de compter ou énumérer sur eux.

je pourrais avoir mis en place ce que:

public string ScriptGet(string name)
public void ScriptSet(string name, string value)

que j'aurais probablement dû avoir, mais c'est une illustration utile de la raison pour laquelle l'utilisation de classes indexées en remplacement de cette caractéristique manquante n'est souvent pas un substitut raisonnable.

pour implémenter une capacité similaire en tant que propriété indexée, j'ai dû écrire le code ci-dessous qui est beaucoup plus long, plus complexe et donc plus difficile à lire., comprendre et maintenir.

public interface IConfig
{
    // Other configuration properties removed for examp[le

    /// <summary>
    /// Script fragments
    /// </summary>
    ScriptsCollection Scripts { get; }
}

/// <summary>
/// Class to handle loading and saving the application's configuration.
/// </summary>
internal class Config : IConfig, IXmlConfig
{
    public Config()
    {
        _scripts = new ScriptsCollection();
        _scripts.ScriptChanged += ScriptChanged;
    }

  #region Application Configuraiton Settings

    // Other configuration properties removed for examp[le

    /// <summary>
    /// Script fragments
    /// </summary>
    public ScriptsCollection Scripts
    { get { return _scripts; } }
    private readonly ScriptsCollection _scripts;

    private void ScriptChanged(object sender, ScriptChangedEventArgs e)
    {
        OnAppConfigChanged();
    }

  #endregion

    /// <summary>
    /// Clears configuration settings, but does not clear internal configuration meta-data.
    /// </summary>
    private void ClearConfig()
    {
        // Other properties removed for example
        _scripts.Clear();
    }

  #region IXmlConfig

    void IXmlConfig.XmlSaveTo(int configVersion, XElement appElement)
    {
        Debug.Assert(configVersion == 2);
        Debug.Assert(appElement != null);

        // Saving of other properties removed for example

        if (_scripts.Count > 0)
        {
            var scripts = new XElement("Scripts");
            foreach (var kvp in _scripts)
            {
                var scriptElement = new XElement(kvp.Key, kvp.Value);
                scripts.Add(scriptElement);
            }
            appElement.Add(scripts);
        }
    }

    void IXmlConfig.XmlLoadFrom(int configVersion, XElement appElement)
    {
        // Implementation simplified for example

        Debug.Assert(appElement != null);
        ClearConfig();
        if (configVersion == 2)
        {
            // Loading of other configuration properites removed for example

            var scripts = appElement.Element("Scripts");
            if (scripts != null)
                foreach (var script in scripts.Elements())
                    _scripts[script.Name.ToString()] = script.Value;
        }
        else
            throw new ApplicaitonException("Unknown configuration file version " + configVersion);
    }

  #endregion
}

public class ScriptsCollection : IEnumerable<KeyValuePair<string, string>>
{
    private readonly Dictionary<string, string> Scripts = new Dictionary<string, string>();

    public string this[string name]
    {
        get
        {
            if (!string.IsNullOrWhiteSpace(name))
            {
                string script;
                if (Scripts.TryGetValue(name.Trim().ToLower(), out script))
                    return script;
            }
            return string.Empty;
        }
        set
        {
            if (!string.IsNullOrWhiteSpace(name))
                Scripts[name.Trim().ToLower()] = value;
        }
    }

    public void Clear()
    {
        Scripts.Clear();
    }

    public int Count
    {
        get { return Scripts.Count; }
    }

    public event EventHandler<ScriptChangedEventArgs> ScriptChanged;

    protected void OnScriptChanged(string name)
    {
        if (ScriptChanged != null)
        {
            var script = this[name];
            ScriptChanged.Invoke(this, new ScriptChangedEventArgs(name, script));
        }
    }

  #region IEnumerable

    public IEnumerator<KeyValuePair<string, string>> GetEnumerator()
    {
        return Scripts.GetEnumerator();
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }

  #endregion
}

public class ScriptChangedEventArgs : EventArgs
{
    public string Name { get; set; }
    public string Script { get; set; }

    public ScriptChangedEventArgs(string name, string script)
    {
        Name = name;
        Script = script;
    }
}

une autre solution est listée à création facile de propriétés qui supportent l'indexation dans C# , qui nécessite moins de travail.

EDIT : je devrais également ajouter qu'en réponse à la question originale, que mon si nous pouvons accomplir la syntaxe désirée, avec le soutien de bibliothèque, alors je pense qu'il doit y avoir un cas très fort pour l'ajouter directement à la langue, afin de minimiser le bloat de langue.

Eh bien, je dirais qu'ils ne l'ont pas ajouté parce que cela ne valait pas le coût de la conception, de la mise en œuvre, de la mise à l'essai et de la documentation.

blague à part, c'est probablement parce que les solutions de rechange sont simples et que la fonction ne fait jamais le temps par rapport à la réduction des avantages. Je ne serais pas surpris de voir cela apparaître comme un changement.

vous avez également oublié de mentionner qu'une solution plus facile est de faire une méthode régulière:

public void SetFoo(int index, Foo toSet) {...}
public Foo GetFoo(int index) {...}

il existe une solution générale simple utilisant lambdas pour remplacer la fonctionnalité d'indexation

pour l'indexation en lecture seule

public class RoIndexer<TIndex, TValue>
{
    private readonly Func<TIndex, TValue> _Fn;

    public RoIndexer(Func<TIndex, TValue> fn)
    {
        _Fn = fn;
    }

    public TValue this[TIndex i]
    {
        get
        {
            return _Fn(i);
        }
    }
}

pour indexation mutable

public class RwIndexer<TIndex, TValue>
{
    private readonly Func<TIndex, TValue> _Getter;
    private readonly Action<TIndex, TValue> _Setter;

    public RwIndexer(Func<TIndex, TValue> getter, Action<TIndex, TValue> setter)
    {
        _Getter = getter;
        _Setter = setter;
    }

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

et une usine

public static class Indexer
{
    public static RwIndexer<TIndex, TValue> Create<TIndex, TValue>(Func<TIndex, TValue> getter, Action<TIndex, TValue> setter)
    {
        return new RwIndexer<TIndex, TValue>(getter, setter);
    } 
    public static RoIndexer<TIndex, TValue> Create<TIndex, TValue>(Func<TIndex, TValue> getter)
    {
        return new RoIndexer<TIndex, TValue>(getter);
    } 
}

dans mon propre code je l'utilise comme

public class MoineauFlankContours
{

    public MoineauFlankContour Rotor { get; private set; }

    public MoineauFlankContour Stator { get; private set; }

     public MoineauFlankContours()
    {
        _RoIndexer = Indexer.Create(( MoineauPartEnum p ) => 
            p == MoineauPartEnum.Rotor ? Rotor : Stator);
    }
    private RoIndexer<MoineauPartEnum, MoineauFlankContour> _RoIndexer;

    public RoIndexer<MoineauPartEnum, MoineauFlankContour> FlankFor
    {
        get
        {
            return _RoIndexer;
        }
    }

}

et avec une instance de MoineauFlankContours je peux faire

MoineauFlankContour rotor = contours.FlankFor[MoineauPartEnum.Rotor];
MoineauFlankContour stator = contours.FlankFor[MoineauPartEnum.Stator];

vient de découvrir moi aussi que vous pouvez utiliser des interfaces explicitement implémentées pour y parvenir, comme indiqué ici: nommé propriété indexée dans C#? (voir la deuxième réponse)