c# - Vacío ILookup<K, T>

.net

Question

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

Answer 1

Además de las respuestas de mquander y Vasile Bujac , puede crear una clase simple, simple y simple de EmptyLookup<K,E> la siguiente manera. (En mi opinión, no parece ser muy beneficioso crear una ILookup<K,E> completa de ILookup<K,E> 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

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 3

No hay una función integrada, por lo que solo escribo un método de extensión que se ejecuta en la línea de la new T[0].ToLookup<K, T>(x => default(K));

Dudo mucho que volver nulo sea más correcto aquí. Casi nunca es el caso que desee devolver el valor nulo a un método que devuelve una colección (en lugar de una colección vacía). No podría estar más en desacuerdo con las personas que lo sugieren.

Answer 4

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 5

Puede crear una clase de singleton para búsquedas vacías.

public sealed class EmptyLookup<T, K> : ILookup<T, K> 
{
        private static readonly EmptyLookup<T, K> _instance 
            = new EmptyLookup<T, K>();

        public static EmptyLookup<T, K> Instance
        {
            get { return _instance; }
        }

        private EmptyLookup() { }

        public bool Contains(T key)
        {
            return false;
        }

        public int Count
        {
            get { return 0; }
        }

        public IEnumerable<K> this[T key]
        {
            get { return Enumerable.Empty<K>(); }
        }

        public IEnumerator<IGrouping<T, K>> GetEnumerator()
        {
            yield break;
        }

        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
        {
            yield break;
        }
    }

Entonces puedes escribir código como este:

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

La ventaja de crear una nueva clase es que puede usar el operador "is" y verificar la igualdad de tipos:

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

Answer 6

Puedes devolver el nulo

o Excepción

Pero debes anotarlo en el comentario de la clase.

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