Statische indexeerders?

Waarom zijn statische indexeerders niet toegestaan ​​in C#? Ik zie geen reden waarom ze niet zouden moeten worden toegestaan ​​en bovendien zouden ze erg nuttig kunnen zijn.

Bijvoorbeeld:

public static class ConfigurationManager 
{
        public object this[string name]
        {
            get => ConfigurationManager.getProperty(name);
            set => ConfigurationManager.editProperty(name, value);
        }
        /// <summary>
        /// This will write the value to the property. Will overwrite if the property is already there
        /// </summary>
        /// <param name="name">Name of the property</param>
        /// <param name="value">Value to be wrote (calls ToString)</param>
        public static void editProperty(string name, object value) 
        {
            var ds = new DataSet();
            var configFile = new FileStream("./config.xml", FileMode.OpenOrCreate);
            ds.ReadXml(configFile);
            if (ds.Tables["config"] == null)
                ds.Tables.Add("config");
            var config = ds.Tables["config"];
            if (config.Rows[0] == null) 
                config.Rows.Add(config.NewRow());
            if (config.Columns[name] == null) 
                config.Columns.Add(name);
            config.Rows[0][name] = value.ToString();
            ds.WriteXml(configFile);
            configFile.Close();
        }
        public static void addProperty(string name, object value) =>
            ConfigurationManager.editProperty(name, value);
        public static object getProperty(string name) 
        {
            var ds = new DataSet();
            var configFile = new FileStream("./config.xml", FileMode.OpenOrCreate);
            ds.ReadXml(configFile);
            configFile.Close();
            if (ds.Tables["config"] == null) return null;
            var config = ds.Tables["config"];
            if (config.Rows[0] == null) return null;
            if (config.Columns[name] == null) return null;
            return config.Rows[0][name];
        }
    }

De bovenstaande code zou veel baat hebben bij een statische indexer. Het compileert echter niet omdat statische indexeerders niet zijn toegestaan. Waarom is dit zo?

Antwoord 1, autoriteit 100%

Ik geloof dat het niet erg nuttig werd geacht. Ik vind het ook jammer – een voorbeeld dat ik meestal gebruik is Encoding, waarbij Encoding.GetEncoding("foo")Encoding["Foo"]kan zijn. Ik denk niet dat het heelvaak zal voorkomen, maar afgezien van al het andere voelt het gewoon een beetje inconsistent om niet beschikbaar te zijn.

Ik zou het moeten controleren, maar ik vermoeddat het al beschikbaar is in IL (Intermediate Language).

Antwoord 2, autoriteit 77%

Indexernotatie vereist een verwijzing naar this. Aangezien statische methoden geen verwijzing hebben naar een bepaalde instantie van de klasse, kunt u thiser niet mee gebruiken, en bijgevolg kunt u geen indexeernotatie gebruiken voor statische methoden.

De oplossing voor uw probleem is het gebruik van een singletonpatroon als volgt:

public class Utilities
{
    private static ConfigurationManager _configurationManager = new ConfigurationManager();
    public static ConfigurationManager ConfigurationManager => _configurationManager;
}
public class ConfigurationManager
{
    public object this[string value]
    {
        get => new object();
        set => // set something
    }
}

Je kunt nu Utilities.ConfigurationManager["someKey"]aanroepen met indexernotatie.

Antwoord 3, autoriteit 9%

Als tijdelijke oplossing kunt u een instantie-indexer definiëren voor een singleton/statisch object (stel dat ConfigurationManager een singleton is in plaats van een statische klasse):

class ConfigurationManager
{
  //private constructor
  ConfigurationManager() {}
  //singleton instance
  public static ConfigurationManager singleton;
  //indexer
  object this[string name] { ... etc ... }
}