Vacío de Ilookup

Question

Tengo un método que devuelve un ILookup. En algunos casos quiero devolver un vacío ILookup como una salida temprana. ¿Cuál es la mejor manera de construir un vacío? ILookup?

Answer 1

Más a las respuestas de mquandero y Vasile Bujac, podrías crear un bonito y sencillo singleton-esque EmptyLookup<K,E> clase de la siguiente manera. (En mi opinión, no parece tener mucho beneficio para crear un completo ILookup<K,E> implementación según la respuesta de Vasile).

var empty = EmptyLookup<int, string>.Instance;

// ...

public static class EmptyLookup<TKey, TElement>
{
    private static readonly ILookup<TKey, TElement> _instance
        = Enumerable.Empty<TElement>().ToLookup(x => default(TKey));

    public static ILookup<TKey, TElement> Instance
    {
        get { return _instance; }
    }
}

Answer 2

No hay incorporado, así que solo escribiría un método de extensión que ejecute algo en la línea de new T[0].ToLookup<K, T>(x => default(K));

yo duda Regresar nulo sería más correcto aquí. Casi nunca es el caso que desee devolver a Null de un método que devuelve una colección (en lugar de una colección vacía). No podría estar en desacuerdo con las personas que sugieren eso.

Answer 3

Puedes crear una clase Singleton para búsqueda vacías.

using System.Linq;

public sealed class EmptyLookup<T, K> : ILookup<T, K> 
{
        public static readonly EmptyLookup<T, K> Instance { get; }
            = new EmptyLookup<T, K>();

        private EmptyLookup() { }

        public bool Contains(T key) => false;

        public int Count => 0;

        public IEnumerable<K> this[T key] => Enumerable.Empty<K>();

        public IEnumerator<IGrouping<T, K>> GetEnumerator()
          => Enumerable.Empty<IGrouping<K, V>>().GetEnumerator();

        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() => GetEnumerator();
 }

Entonces puedes escribir código como este:

var x = EmptyLookup<int, int>.Instance;

El beneficio de crear una nueva clase es que puede usar el operador "IS" y verificar la igualdad de tipo:

if (x is EmptyLookup<,>) {
 // ....
}

Answer 4

Residencia en Lukeh Respuesta, crearía una clase estática Lookup con un Empty<TKey, TElement> método. De esta manera que podrías usar es de la misma manera que Enumerable.Empty<T>.

public static class Lookup
{
    public static ILookup<TKey, TElement> Empty<TKey, TElement>()
        => Enumerable.Empty<TElement>().ToLookup(x => default(TKey));
}

Uso de ejemplo: Lookup.Empty<string, string>()

Answer 5

Cree una lista vacía, luego ejecute tolookup () en ella, así:

List<Point> items = new List<Point>();
ILookup<int, int> lookup = items.ToLookup(p => p.X, p => p.Y);

¡Buena suerte!

Answer 6

O algo más en el espíritu de Linq:

    public static class Utility
{

    public static ILookup<TKey, TElement> EmptyLookup<TKey, TElement>(Func<TKey, TKey> keySelector,
                                                                      Func<TKey, TElement> elementSelector)
    {
        return Enumerable.Empty<TKey>().ToLookup(keySelector, elementSelector);
    }

}

Answer 7

Puedes devolver nulo

o excepción

Pero deberías notarlo en el comentario de la clase

Agregado:+ Esto es más obvio que algún método de extensión