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.