Статические индексаторы?

В качестве обходного пути вы можете определить индексатор экземпляра для одноэлементного / статического объекта (скажем, что ConfigurationManager является одноэлементным, а не статическим классом):

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

Обозначение индексатора требует ссылки на this. Поскольку статические методы не имеют ссылки на какой-либо конкретный экземпляр класса, вы не можете использовать с ними this, и, следовательно, вы не можете использовать нотацию индексатора для статических методов.

Решение вашей проблемы заключается в использовании одноэлементного шаблона следующим образом:

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
    }
}

Теперь вы можете вызвать Utilities.ConfigurationManager["someKey"], используя нотацию индексатора.

Я считаю, что это считалось не очень полезным. Я тоже думаю, что это позор - пример, который я обычно использую, - это кодирование, где Encoding.GetEncoding("foo") может быть Encoding["Foo"]. Я не думаю, что очень будет часто появляться, но, помимо всего прочего, это просто кажется немного непоследовательным из-за того, что он недоступен.

Я должен был бы проверить, но я подозревать он уже доступен на IL (промежуточном языке).

Ключевое слово this относится к текущему экземпляру класса. Статические функции-члены не имеют указателя this. Ключевое слово this может использоваться для доступа к членам из конструкторов, методов экземпляра и средств доступа к экземпляру. (Извлекается из msdn). Поскольку this ссылается на экземпляр класса, он конфликтует с природой static, поскольку static не связан с экземпляром класса.

Один из способов обхода проблемы заключается в следующем, который позволяет использовать индексатор против частного Dictionary, поэтому вам нужно только создать новый экземпляр и получить доступ к статической части.

    public class ConfigurationManager 
{
    public ConfigurationManager()
    {
        // TODO: Complete member initialization
    }
    public object this[string keyName]
    {
        get
        {
                return ConfigurationManagerItems[keyName];
        }
        set
        {
                ConfigurationManagerItems[keyName] = value;
        }
    }
    private static Dictionary<string, object> ConfigurationManagerItems = new Dictionary<string, object>();        
}

Это позволяет вам полностью пропустить доступ к члену класса и просто создать его экземпляр и проиндексировать его.

    new ConfigurationManager()["ItemName"]

Причина в том, что довольно сложно понять, что именно вы индексируете с помощью статического индексатора.

Вы говорите, что статический индексатор принесет пользу коду, но так ли это на самом деле? Все, что он сделает, это изменит это:

ConfigurationManager.editProperty(name, value);
...
value = ConfigurationManager.getProperty(name)

В это:

ConfigurationManager[name] = value
...
value = ConfigurationManager[name]

что никак не улучшает код; он не меньше на много строк кода, его не легче писать благодаря автозаполнению, и он менее понятен, поскольку скрывает тот факт, что вы получаете и устанавливаете то, что вы называете `` Свойством '', и фактически заставляет читателя прочтите документацию о том, что именно индексатор возвращает или устанавливает, потому что никоим образом не очевидно, что это свойство, для которого вы индексируете, в то время как с обоими:

ConfigurationManager.editProperty(name, value);
...
value = ConfigurationManager.getProperty(name)

Вы можете прочитать это вслух и сразу понять, что делает код.

Помните, что мы хотим писать код, который легко (= быстро) понимать, а не код, который быстро пишется. Не путайте скорость, с которой вы можете написать код, со скоростью, с которой вы завершаете проекты.

С новыми конструкциями в C# 6 вы можете упростить одноэлементный шаблон с помощью тела выражения свойства. Например, я использовал следующий ярлык, который отлично работает с code-lense:

public static class Config
{
   public static NameValueCollection Get => ConfigurationManager.AppSettings;
}

У него есть дополнительное преимущество, заключающееся в возможности поиска и замены для обновления старого кода и унификации доступа к настройкам вашего приложения.

Мне также был нужен (ну, скорее, полезный) статический индексатор для хранения атрибутов, поэтому я нашел несколько неудобный обходной путь:

Внутри класса, который вы хотите иметь статический индексатор (здесь: Element), создайте подкласс с тем же именем + «Dict». Дайте ему статический объект только для чтения в качестве экземпляра указанного подкласса, а затем добавьте желаемый индексатор.

Наконец, добавьте класс как статический импорт (следовательно, подкласс будет отображать только статическое поле).

import static Element.ElementDict;

public class Element {
    // .... 
    private static readonly Dictionary<string, object> elemDict = new Dictionary<string, object>();
    public class ElementDict {
        public readonly static ElementDict element = new ElementDict();
        public object this[string key] {
            get => elemDict.TryGetValue(key, out object o) ? o : null;
            set => elemDict[key] = value;
        }
    }
}

а затем вы можете использовать его либо с заглавной буквы как Type, либо без словаря:

var cnt = element["counter"] as int;
element["counter"] = cnt;

Но, увы, если бы кто-то действительно использовал объект как "значение" -Type, то приведенный ниже был бы еще короче (по крайней мере, как объявление), а также обеспечивал бы немедленное приведение типов:

public static T load<T>(string key) => elemDict.TryGetValue(key, out object o) ? (T) o : default(T);
public static void store<T>(string key, T value) => elemDict[key] = value;

var cnt = Element.load<int>("counter");
Element.store("counter", cnt);