Was ist der Sinn von Lookup <TKey, TElement>?

Der MSDN erklärt Lookup folgendermaßen:

A Lookup<TKey, TElement> ähnelt a Dictionary<TKey, TValue>. Der Unterschied besteht darin, dass ein Wörterbuch <TKey, TValue> Schlüssel einzelnen Werten zuordnet, während ein Lookup <TKey, TElement> Schlüssel Sammlungen von Werten zuordnet .

Ich finde diese Erklärung nicht besonders hilfreich. Wofür wird Lookup verwendet?

Es ist eine Kreuzung zwischen einem IGroupingund einem Wörterbuch. Sie können Elemente nach einem Schlüssel gruppieren und dann über diesen Schlüssel auf effiziente Weise darauf zugreifen (anstatt nur über alle zu iterieren, was GroupBySie tun können).

Sie könnten beispielsweise eine Menge .NET-Typen laden und eine Suche nach Namespace erstellen ... und dann ganz einfach zu allen Typen in einem bestimmten Namespace gelangen:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Xml;

public class Test
{
    static void Main()
    {
        // Just types covering some different assemblies
        Type[] sampleTypes = new[] { typeof(List<>), typeof(string), 
                                     typeof(Enumerable), typeof(XmlReader) };

        // All the types in those assemblies
        IEnumerable<Type> allTypes = sampleTypes.Select(t => t.Assembly)
                                               .SelectMany(a => a.GetTypes());

        // Grouped by namespace, but indexable
        ILookup<string, Type> lookup = allTypes.ToLookup(t => t.Namespace);

        foreach (Type type in lookup["System"])
        {
            Console.WriteLine("{0}: {1}", 
                              type.FullName, type.Assembly.GetName().Name);
        }
    }
}

(Normalerweise würde ich varfür die meisten dieser Deklarationen normalen Code verwenden.)

Eine Möglichkeit, darüber nachzudenken, ist folgende: Lookup<TKey, TElement>ähnelt Dictionary<TKey, Collection<TElement>>. Grundsätzlich kann eine Liste mit null oder mehr Elementen über denselben Schlüssel zurückgegeben werden.

namespace LookupSample
{
    using System;
    using System.Collections.Generic;
    using System.Linq;

    class Program
    {
        static void Main(string[] args)
        {
            List<string> names = new List<string>();
            names.Add("Smith");
            names.Add("Stevenson");
            names.Add("Jones");

            ILookup<char, string> namesByInitial = names.ToLookup((n) => n[0]);

            // count the names
            Console.WriteLine("J's: {0}", namesByInitial['J'].Count()); // 1
            Console.WriteLine("S's: {0}", namesByInitial['S'].Count()); // 2
            Console.WriteLine("Z's: {0}", namesByInitial['Z'].Count()); // 0, does not throw
        }
    }
}

Eine Verwendung von Lookupkönnte sein, a umzukehren Dictionary.

Angenommen, Sie haben ein Telefonbuch implementiert, das eine DictionaryReihe von (eindeutigen) Namen als Schlüssel enthält, wobei jeder Name einer Telefonnummer zugeordnet ist. Zwei Personen mit unterschiedlichen Namen haben möglicherweise dieselbe Telefonnummer. Dies ist kein Problem für a Dictionary, das sich nicht darum kümmert, dass zwei Schlüssel demselben Wert entsprechen.

Jetzt möchten Sie nachschlagen, wem eine bestimmte Telefonnummer gehört. Sie erstellen ein Lookup, indem Sie alles KeyValuePairsvon Ihrem Dictionary, aber rückwärts, mit dem Wert als Schlüssel und dem Schlüssel als Wert hinzufügen . Sie können jetzt eine Telefonnummer abfragen und eine Liste mit Namen aller Personen abrufen, deren Telefonnummer dies ist. Das Erstellen eines Dictionarymit denselben Daten würde Daten löschen (oder fehlschlagen, je nachdem, wie Sie es getan haben)

dictionary["555-6593"] = "Dr. Emmett Brown";
dictionary["555-6593"] = "Marty McFly";

bedeutet, dass der zweite Eintrag den ersten überschreibt - das Dokument wird nicht mehr aufgelistet.

Der Versuch, dieselben Daten auf etwas andere Weise zu schreiben:

dictionary.Add("555-6593", "Dr. Emmett Brown");
dictionary.Add("555-6593", "Marty McFly");

würde eine Ausnahme in die zweite Zeile werfen, da Sie keinen AddSchlüssel finden können, der sich bereits in der befindet Dictionary.

[Natürlich möchten Sie vielleicht eine andere einzelne Datenstruktur verwenden Lookups in beide Richtungen zu tun, usw. In diesem Beispiel bedeutet , dass Sie die regenerieren haben Lookupaus dem Dictionarydie letzteren ändert sich jedes Mal. Aber für einige Daten könnte es die richtige Lösung sein.]

Ich habe es noch nicht erfolgreich verwendet, aber hier ist mein Ziel:

A Lookup<TKey, TElement>würde sich ziemlich ähnlich wie ein (relationaler) Datenbankindex für eine Tabelle ohne eine eindeutige Einschränkung verhalten. Verwenden Sie es an den gleichen Stellen, an denen Sie es auch verwenden würden.

Ich denke, Sie könnten es so argumentieren: Stellen Sie sich vor, Sie erstellen eine Datenstruktur für den Inhalt eines Telefonbuchs. Sie möchten nach Nachname und dann nach Vorname eingeben. Die Verwendung eines Wörterbuchs wäre hier gefährlich, da viele Personen denselben Namen haben können. Ein Wörterbuch wird also immer höchstens einem einzelnen Wert zugeordnet.

Eine Suche wird möglicherweise mehreren Werten zugeordnet.

Lookup ["Smith"] ["John"] wird eine Sammlung mit einer Größe von einer Milliarde sein.