Я пытаюсь обернуть голову, какие структуры данных являются наиболее эффективными и когда и где использовать какие.

Возможно, я просто недостаточно хорошо понимаю структуры, но как это ILookup(of key, ...)отличается от Dictionary(of key, list(of ...))?

Кроме того, где я хотел бы использовать ILookupи где это было бы более эффективно с точки зрения скорости программы / памяти / доступа к данным и т. Д.?

Два существенных различия:

• Lookupнеизменен. Ууу :) (По крайней мере, я считаю, что конкретный Lookupкласс неизменен, и ILookupинтерфейс не предоставляет никаких мутирующих членов. Конечно, могут быть и другие изменяемые реализации.)
• Когда вы ищете ключ, которого нет в поиске, вы получаете пустую последовательность вместо a KeyNotFoundException. (Следовательно, нет TryGetValue, AFAICR.)

Они, вероятно, будут эквивалентны по эффективности - поиск может вполне использовать Dictionary<TKey, GroupingImplementation<TValue>>закулисную, например. Выберите между ними в зависимости от ваших требований. Лично я нахожу, что поиск обычно лучше подходит, чем Dictionary<TKey, List<TValue>>, в основном из-за первых двух пунктов выше.

Обратите внимание, что в качестве детали реализации, конкретная реализация IGrouping<,>которой используется для значений реализует IList<TValue>, что означает, что его эффективно использовать с Count(), ElementAt()и т. Д.

Интересно, что никто не указал фактическую самую большую разницу (взято непосредственно из MSDN ):

Поиск похож на словарь. Разница в том, что словарь отображает ключи на отдельные значения, тогда как поиск отображает ключи на коллекции значений.

И a, Dictionary<Key, List<Value>>и Lookup<Key, Value>логически могут содержать данные, организованные одинаковым образом, и оба имеют одинаковый порядок эффективности. Основным отличием является то, что a Lookupявляется неизменным: у него нет Add()методов и открытого конструктора (и, как упоминал Джон, вы можете запросить несуществующий ключ без исключения и иметь ключ как часть группировки).

Что касается того, что вы используете, это действительно зависит от того, как вы хотите их использовать. Если вы поддерживаете карту ключей с несколькими значениями, которая постоянно изменяется, то, Dictionary<Key, List<Value>>вероятно, лучше, поскольку она изменчива.

Если, однако, у вас есть последовательность данных и вы просто хотите просматривать данные только для чтения, организованные по ключу, тогда поиск очень прост в создании и даст вам снимок только для чтения.

Основное различие между an ILookup<K,V>и a в Dictionary<K, List<V>>том, что словарь изменчив; Вы можете добавлять или удалять ключи, а также добавлять или удалять элементы из списка, который ищется. An ILookupявляется неизменным и не может быть изменен после создания.

Базовая реализация обоих механизмов будет одинаковой или похожей, поэтому их скорость поиска и объем памяти будут примерно одинаковыми.

Еще одно различие, которое еще не упоминалось, заключается в том, что Lookup () поддерживает нулевые ключи :

Класс Lookup реализует интерфейс ILookup. Поиск очень похож на словарь, за исключением того, что множественные значения могут отображаться на один и тот же ключ, и поддерживаются нулевые ключи.

Когда исключение не является опцией, перейти к поиску

Если вы пытаетесь получить структуру, столь же эффективную, как, Dictionaryно не знаете наверняка, что во вводе нет повторяющегося ключа, Lookupэто безопаснее.

Как уже упоминалось в другом ответе, он также поддерживает нулевые ключи и всегда возвращает действительный результат при запросе к произвольным данным, поэтому он выглядит более устойчивым к неизвестному вводу (менее склонен, чем словарь, вызывать исключения).

И это особенно верно, если вы сравните это с System.Linq.Enumerable.ToDictionaryфункцией:

// won't throw
new[] { 1, 1 }.ToLookup(x => x); 

// System.ArgumentException: An item with the same key has already been added.
new[] { 1, 1 }.ToDictionary(x => x);

Альтернативой может быть написание собственного дублирующего кода управления ключами внутри foreachцикла.

Производительность, словарь: явный победитель

Если вам не нужен список, и вы собираетесь управлять огромным количеством элементов Dictionary(или даже собственной настраиваемой структурой), это будет более эффективным:

        Stopwatch stopwatch = new Stopwatch();
        var list = new List<string>();
        for (int i = 0; i < 5000000; ++i)
        {
            list.Add(i.ToString());
        }
        stopwatch.Start();
        var lookup = list.ToLookup(x => x);
        stopwatch.Stop();
        Console.WriteLine("Creation: " + stopwatch.Elapsed);

        // ... Same but for ToDictionary
        var lookup = list.ToDictionary(x => x);
        // ...

Так как Lookupприходится вести список элементов для каждого ключа, он медленнее словаря (примерно в 3 раза медленнее для огромного количества элементов)

Скорость поиска: Создание: 00: 00: 01.5760444

Скорость словаря: Создание: 00: 00: 00.4418833