Indexeurs statiques?

Question

Pourquoi les indexeurs statiques ne sont-ils pas autorisés en C#? Je ne vois aucune raison pour laquelle ils ne devraient pas être autorisés et de plus ils pourraient être très utiles.

Par exemple:

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

Le code ci-dessus bénéficierait grandement d'un indexeur statique. Cependant, il ne compilera pas car les indexeurs statiques ne sont pas autorisés. Pourquoi cela est-il ainsi?

Answer 1

notation Indexer nécessite une référence à this. Puisque les méthodes statiques n'ont pas de référence à une instance particulière de la classe, vous ne pouvez pas utiliser this avec elles, et par conséquent vous ne pouvez pas utiliser la notation d'indexeur sur les méthodes statiques.

La solution à votre problème utilise un singleton comme suit:

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

Maintenant, vous pouvez appeler Utilities.ConfigurationManager["someKey"] en utilisant la notation indexeur. Je crois qu'il a été considéré comme n'étant pas terriblement utile.

Answer 2

En tant que travail autour, vous pouvez définir un indexeur d'instance sur un objet singleton/statique (disons que ConfigurationManager est un singleton, au lieu d'être une classe statique):

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

Answer 3

Je pense que c'est dommage aussi - un exemple que j'ai tendance à utiliser est Encoding, où Encoding.GetEncoding ("foo") pourrait être Encoding ["Foo"]. Je ne pense pas que cela viendrait souvent, mais à part toute autre chose, il semble juste un peu incohérent de ne pas être disponible.

Je devrais vérifier, mais je suspect il est disponible en IL déjà.

Answer 4

Ce mot clé fait référence à l'instance actuelle de la classe. Les fonctions membres statiques n'ont pas ce pointeur. Ce mot-clé peut être utilisé pour accéder aux membres depuis les constructeurs, les méthodes d'instance et les accesseurs d'instance (récupéré à partir de msdn). Puisque cela fait référence à une instance de la classe, elle est en conflit avec la nature de static, puisque static n'est pas associé à une instance de la classe.

Une solution de contournement serait la suivante qui vous permet d'utiliser l'indexeur par rapport à un dictionnaire privé afin que vous ayez seulement besoin de créer une nouvelle instance et que vous accédiez à la partie statique.

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

Cela vous permet de sauter l'ensemble d'accéder à un membre de la classe et juste créer une instance de celui-ci et l'indexer.

new ConfigurationManager()["ItemName"] 

Answer 5

La raison en est qu'il est assez difficile de comprendre exactement ce que vous indexez avec un indexeur statique.

Vous dites que le code bénéficierait d'un indexeur statique, mais le ferait-il vraiment?Tout ce qu'il ferait est de changer ceci:

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

Dans ceci:

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

qui ne fait pas le code mieux en aucune manière; il n'est pas plus petit par beaucoup de lignes de code, il n'est pas plus facile d'écrire grâce à la saisie semi-automatique et il est moins clair, car il cache le fait que vous obtenez quelque chose que vous appelez 'Property' allez lire la documentation sur ce exactement le rendement indexeur ou ensembles, parce qu'il est nullement évident qu'il est une propriété que vous indexez pour, tout à la fois:

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

vous pouvez le lire à haute voix et immédiatement comprendre ce que fait le code. Rappelez-vous que nous voulons écrire un code facile à comprendre (= rapide), pas un code rapide à écrire. Ne confondez pas la vitesse à laquelle vous pouvez définir le code avec la vitesse à laquelle vous terminez les projets.