Indicadores estáticos?

Question

¿Por qué los indexadores estáticos no se permiten en C#? No veo ninguna razón por la cual no se les permita y, además, podrían ser muy útiles.

Por ejemplo:

static class ConfigurationManager { 

     public object this[string name]{ 
      get{ 
       return 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) { 
      DataSet ds = new DataSet(); 
      FileStream configFile = new FileStream("./config.xml", FileMode.OpenOrCreate); 
      ds.ReadXml(configFile); 

      if (ds.Tables["config"] == null) { 
       ds.Tables.Add("config"); 
      } 

      DataTable 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) { 
      DataSet ds = new DataSet(); 
      FileStream configFile = new FileStream("./config.xml", FileMode.OpenOrCreate); 
      ds.ReadXml(configFile); 
      configFile.Close(); 


      if (ds.Tables["config"] == null) { 
       return null; 
      } 

      DataTable config = ds.Tables["config"]; 

      if (config.Rows[0] == null) { 
       return null; 
      } 

      if (config.Columns[name] == null) { 
       return null; 
      } 

      return config.Rows[0][name]; 
     } 
    } 

El código anterior se beneficiaría enormemente de un indizador de estática. Sin embargo, no se compilará porque los indexadores estáticos no están permitidos. ¿Por qué esto es tan?

Answer 1

notación paso a paso requiere una referencia a this. Como los métodos estáticos no tienen una referencia a una instancia particular de la clase, no puede usar this con ellos y, en consecuencia, no puede usar la notación del indexador en métodos estáticos.

La solución a su problema es el uso de un patrón singleton de la siguiente manera:

    public class Utilities 
    { 
     static ConfigurationManager _configurationManager = new ConfigurationManager(); 
     public static ConfigurationManager ConfigurationManager 
     { 
      get 
      { 
       return _configurationManager; 
      } 
     } 
    } 

    public class ConfigurationManager 
    { 
     public object this[string value] 
     { 
      get 
      { 
       return new object(); 
      } 
      set 
      { 
       // set something 
      } 
     } 
    } 

Ahora puede llamar Utilities.ConfigurationManager["someKey"] usando la notación indexador.

Answer 2

Como solución alternativa, se puede definir un indexador instancia en un objeto singleton/estática (dicen que ConfigurationManager es un producto único, en lugar de ser una clase estática):

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

Answer 3

Creo que se consideró que no era terriblemente útil. También creo que es una lástima, un ejemplo que suelo usar es Encoding, donde Encoding.GetEncoding ("foo") podría ser Encoding ["Foo"]. No creo que salga muy a menudo, pero aparte de cualquier otra cosa, parece un poco inconsistente no estar disponible.

Tendría que verificar, pero I sospechoso ya está disponible en IL.

Answer 4

La palabra clave se refiere a la instancia actual de la clase. Las funciones de miembro estático no tienen este puntero. La palabra clave this se puede usar para acceder a miembros desde dentro de constructores, métodos de instancia y accesadores de instancia (recuperado de msdn). Como esto hace referencia a una instancia de la clase, entra en conflicto con la naturaleza de estática, ya que estática no está asociada con una instancia de la clase.

Una solución alternativa sería la siguiente que le permite usar el indexador contra un diccionario privado , por lo que solo necesita crear una nueva instancia y acceder a la parte estática.

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>();   
} 

Esto le permite saltar la totalidad acceder a un miembro de la clase y acaba de crear una instancia de ella y el índice.

new ConfigurationManager()["ItemName"] 

Answer 5

La razón es porque es bastante difícil entender qué es exactamente lo que está indexando con un indexador estático.

Usted dice que el código se beneficiaría de un indexador estático, pero ¿realmente?Todo lo que podría hacer es cambiar esta situación:

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

En esto:

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

que no hace el mejor código de ninguna manera; no es más pequeño por muchas líneas de código, no es más fácil de escribir gracias a la función autocompletar y es menos claro, ya que oculta el hecho de que está obteniendo y configurando algo que llama 'Propiedad' y realmente obliga al lector a ve a leer la documentación sobre qué es exactamente el indexador devoluciones o conjuntos, ya que no es en absoluto evidente que se trata de una propiedad que está indexación para, mientras tanto:

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

usted puede leer en voz alta e inmediatamente entender lo que hace el código

Recuerda que queremos escribir código que sea fácil de entender (= rápido), no código que sea rápido de escribir. No confunda la velocidad con la que puede establecer el código con la velocidad a la que completa los proyectos.