Erstellen eines konstanten Wörterbuch in C #

Question

Was ist der effizienteste Weg, eine Konstante (ändert sich nie zur Laufzeit) Abbildung von strings zu ints zu schaffen?

Ich habe versucht, einen const Dictionary , aber das hat nicht funktioniert.

Ich könnte ein unveränderlichen Wrapper implementieren mit entsprechender Semantik, aber das bedeutet nicht noch völlig richtig sein.

---

Für diejenigen, die darum gebeten haben, ich bin Umsetzung IDataErrorInfo in einer generierten Klasse und für eine Art und Weise sucht die column Lookup in meine Reihe von Deskriptoren zu machen.

ich war nicht bewusst (Tippfehler beim Testen! D'oh!), Dass der Schalter akzeptiert Strings, so dass das, was ich gonna verwenden bin. Dank!

Answer 1

Erstellen einer wirklich Kompilierung -uhrzeit konstant Wörterbuch in C # ist nicht wirklich eine einfache Aufgabe. Eigentlich keine der Antworten hier wirklich das erreichen.

Es gibt eine Lösung, obwohl die Ihre Anforderungen erfüllt, wenn auch nicht unbedingt ein nett; erinnern, dass nach der C # Spezifikation der Schalter-case-Tabellen kompilieren konstante hash Sprungtabellen. Das heißt, sie sind konstant Wörterbücher, nicht eine Reihe von if-else-Anweisungen. So sollten Sie eine switch-case-Anweisung wie folgt:

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

Das ist genau das, was Sie wollen. Und ja, ich weiß, es ist hässlich.

Answer 2

Es gibt sehr wenige unveränderlichen Sammlungen im aktuellen Rahmen. Ich kann mich eine relativ schmerzfreie Option in .NET 3.5:

Verwenden Enumerable.ToLookup() - die Lookup<,> Klasse ist unveränderlich (aber multi- Wert auf den rhs); Sie können aus einer Dictionary<,> dies tun, ganz einfach:

    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 3

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

...

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

Answer 4

Dies ist das nächste, was Sie zu einem „CONST-Wörterbuch“ bekommen:

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

Der Compiler wird klug genug sein, den Code so sauber wie möglich zu bauen.

Answer 5

Wenn 4.5+ Framework würde ich ReadOnlyDictionary (auch Readonly-Sammlung für Listen) verwenden Nur-Lese-Mappings / Konstanten zu tun. Es wird in der folgenden Art und Weise umgesetzt werden.

static class SomeClass
{
    static readonly ReadOnlyDictionary<string,int> SOME_MAPPING 
        = new ReadOnlyDictionary<string,int>(
            new Dictionary<string,int>()
            {
                { "One", 1 },
                { "Two", 2 }
            }
        )
}        

Answer 6

Warum Namespaces oder Klassen nicht Ihre Werte Nest benutzen? Es ist vielleicht nicht perfekt, aber es ist sehr sauber.

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

Jetzt können Sie .ParentClass.FooDictionary.Key1 zugreifen, etc.

Answer 7

Es scheint, keinen Standard unveränderliche Schnittstelle für Wörterbücher zu sein, also einen Wrapper zu schaffen scheint, wie die einzige vernünftige Option, leider.

Bearbeiten . Marc GRA die ILookup gefunden, die ich verpasst -, dass Sie zumindest vermeiden ermöglicht eine neue Wrapper erstellen, obwohl Sie immer noch das Wörterbuch mit .ToLookup umwandeln müssen ()

Wenn dies eine Notwendigkeit, ein bestimmtes Szenario beschränkt ist, können Sie mit einer Business-Logik-orientierte Schnittstelle besser dran:

interface IActiveUserCountProvider
{
    int GetMaxForServer(string serverName);
}

Answer 8

Warum nicht:

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