c# - que - definición y declaración de constantes

Creando un diccionario constante en C#

Question

¿Cuál es la forma más eficiente de crear un mapeo constante (nunca cambia en el tiempo de ejecución) de string a int ?

He intentado usar un diccionario const , pero eso no funcionó.

Podría implementar una envoltura inmutable con la semántica adecuada, pero eso todavía no parece del todo correcto.

Para aquellos que han preguntado, estoy implementando IDataErrorInfo en una clase generada y estoy buscando una manera de hacer que la búsqueda de columnName en mi matriz de descriptores.

No estaba al tanto (¡error al testear! ¡Oh!) Que el interruptor acepta cadenas, así que eso es lo que voy a usar. ¡Gracias!

Answer 1

¿Por qué no usar espacios de nombres o clases para anidar sus valores? Puede ser imperfecto, pero está muy limpio.

public static class ParentClass
{
    // here is the "dictionary" class
    public static class FooDictionary
    {
        public const string Key1 = "somevalue";
        public const string Foobar = "fubar";
    }
}

Ahora puede acceder a .ParentClass.FooDictionary.Key1, etc.

Answer 2

Crear un diccionario constante generado en tiempo de compilación en C # no es realmente una tarea sencilla. En realidad, ninguna de las respuestas aquí realmente logra eso.

Sin embargo, hay una solución que cumple con sus requisitos, aunque no necesariamente una buena; recuerde que, de acuerdo con la especificación C #, las tablas de conmutadores se compilan en tablas de salto hash constantes. Es decir, son diccionarios constantes, no una serie de declaraciones if-else. Así que considere una declaración de mayúsculas y minúsculas como esta:

switch (myString)
{
   case "cat": return 0;
   case "dog": return 1;
   case "elephant": return 3;
}

Esto es exactamente lo que quieres. Y sí, lo sé, es feo.

Answer 3

Esto es lo más cercano que se puede obtener a un "Diccionario CONST":

public static int GetValueByName(string name)
{
    switch (name)
    {
        case "bob": return 1;
        case "billy": return 2;
        default: return -1;
    }
}

El compilador será lo suficientemente inteligente como para construir el código lo más limpio posible.

Answer 4

Hay pocas colecciones inmutables en el marco actual. Puedo pensar en una opción relativamente libre de dolor en .NET 3.5:

Use Enumerable.ToLookup() - la clase Lookup<,> es inmutable (pero tiene múltiples valores en el rhs); puede hacer esto desde un Dictionary<,> bastante facilidad:

    Dictionary<string, int> ids = new Dictionary<string, int> {
      {"abc",1}, {"def",2}, {"ghi",3}
    };
    ILookup<string, int> lookup = ids.ToLookup(x => x.Key, x => x.Value);
    int i = lookup["def"].Single();

Answer 5

No parece haber una interfaz inmutable estándar para los diccionarios, por lo que la creación de un contenedor parece ser la única opción razonable, desafortunadamente.

Editar : Marc Gravell encontró el ILookup que eché de menos, que le permitirá al menos evitar la creación de un nuevo contenedor, aunque todavía necesita transformar el diccionario con .ToLookup ().

Si esta es una necesidad limitada a un escenario específico, es posible que esté mejor con una interfaz más orientada a la lógica de negocios:

interface IActiveUserCountProvider
{
    int GetMaxForServer(string serverName);
}

Answer 6

Por qué no:

public class MyClass
{
    private Dictionary<string, int> _myCollection = new Dictionary<string, int>() { { "A", 1 }, { "B", 2 }, { "C", 3 } };

    public IEnumerable<KeyValuePair<string,int>> MyCollection
    {
        get { return _myCollection.AsEnumerable<KeyValuePair<string, int>>(); }
    }
}

Answer 7

enum Constants
{
    Abc = 1,
    Def = 2,
    Ghi = 3
}

...

int i = (int)Enum.Parse(typeof(Constants), "Def");