No estoy seguro de que esta pregunta encaje en StackOverflow. Si ese es el caso, por favor hágamelo saber.
Estoy tratando de crear un Lookup<,> a partir de un IEnumerable<IGrouping<,>> , solo porque sí (esto no es un problema XY).
Tengo entendido que la única forma de crear un objeto de Lookup es con el método ToLookup .
La mejor manera que encontré para hacer esto es separar las agrupaciones en pares clave-valor con claves duplicadas y luego agruparlas nuevamente en una Lookup usando ToLookup :
groups // IEnumerable<IGrouping<TKey, TElement>> .SelectMany(group => group.Select(item => new KeyValuePair<TKey, TElement>(group.Key, item))) .ToLookup(kvp => kvp.Key, kvp => kvp.Value) Creo que esto es muy ineficiente porque separa los grupos y luego los 'reensambla', en lugar de aprovechar el hecho de que ya están agrupados.
¿Hay una mejor manera de hacer esto?
Posible caso de uso:
Digamos que tenemos una lista de nombres. Queremos agrupar los nombres por su primera letra, hasta ahora todo bien, pero solo queremos mantener los grupos con más de dos nombres, y queremos que el resultado sea un Lookup<,> para que tengamos acceso a su útil indexador
La primera parte se puede hacer fácilmente:
names.GroupBy(name => name[0]).Where(group => group.Count() > 2) Pero luego necesitaremos convertir IEnumerable<IGrouping<char, string>> a Lookup<char, string> .
¿Qué razones hay para no tener un constructor equivalente a Dictionary<TKey, TValue>(IEnumerable<KeyValuePair<TKey, TValue>>) ?
Además de las posibles razones que podrían explicar por qué tal funcionalidad no está disponible que señaló Marc, solo quería agregar que el indexador también está disponible en Diccionario, por lo que podría crear un IDictionary<char, IEnumerable<string>> y luego tenga en cuenta que obtendrá una excepción si usa el indexador con una clave que no está en el diccionario (lo cual es una diferencia importante con el indexador en ILookup ... además de que la búsqueda es inmutable en contraste con el diccionario) .
Así que podrías hacer algo como esto:
using System; using System.Linq; using System.Collections.Generic; public class Program { public static void Main() { var names = new List<string>(); names.Add("Agustin"); names.Add("Alejandro"); names.Add("Diego"); names.Add("Damian"); names.Add("Dario"); IDictionary<char, IEnumerable<string>> fakeLookup = names.GroupBy(name => name[0]) .Where(group => group.Count() > 2) .ToDictionary(group => group.Key, group => group.AsEnumerable()); foreach(var name in fakeLookup ['D']) { Console.WriteLine(name); } var namesStartingWithA = lookup['A']; // This will throw a KeyNotFoundException } }"¿Qué razones hay para no tener un constructor equivalente a ..." - porque cada característica debe ser:
y a) no llegó al n.° 1, o b) se pensó en ello, pero se descartó o se aplazó entre el n.° 2 y el n.° 7, porque c) se pensó activamente que era una mala idea, o d) era una idea lo suficientemente buena, pero en comparación con el mar de buenas ideas, no alcanzó el umbral necesario de beneficio versus esfuerzo para que se le diera el tiempo para hacerlo.
No me queda claro por qué la clase Lookup<TKey, TValue> está expuesta públicamente. Esta clase no tiene constructores públicos y parece que no hay una API pública que devuelva este tipo concreto. El operador ToLookup LINQ devuelve una interfaz ( ILookup<TKey, TValue> ) en lugar de este tipo.
Si desea convertir de manera eficiente un IEnumerable<IGrouping<TKey, TValue>> a un ILookup<TKey, TValue> , sin reconstruir las agrupaciones desde cero, parece que no hay otra opción que escribir una implementación personalizada de esta interfaz. La implementación no necesita ser pública, y es bastante sencilla:
private class LookupOfGroupings<TKey, TValue> : ILookup<TKey, TValue> { private readonly Dictionary<TKey, IGrouping<TKey, TValue>> _dictionary; public LookupOfGroupings(IEnumerable<IGrouping<TKey, TValue>> source) => _dictionary = source.ToDictionary(g => g.Key); public int Count => _dictionary.Count; public IEnumerable<TValue> this[TKey key] => _dictionary.TryGetValue(key, out var g) ? g : Enumerable.Empty<TValue>(); public bool Contains(TKey key) => _dictionary.ContainsKey(key); public IEnumerator<IGrouping<TKey, TValue>> GetEnumerator() => _dictionary.Values.GetEnumerator(); IEnumerator IEnumerable.GetEnumerator() => this.GetEnumerator(); }El comportamiento del indexador es el mismo que el comportamiento de la implementación nativa. En caso de una clave inexistente, devuelve una secuencia vacía.
Y aquí está el operador ToLookup personalizado que realiza la conversión:
public static ILookup<TKey, TValue> ToLookup<TKey, TValue>( this IEnumerable<IGrouping<TKey, TValue>> source) => new LookupOfGroupings<TKey, TValue>(source);Ejemplo de uso:
ILookup<char, string> lookup = names .GroupBy(name => name[0]) .Where(group => group.Count() > 2) .ToLookup();