Empty ILookup <K, T>

Question

Tengo un método que devuelve ILookup. En algunos casos, quiero devolver un ILookup vacío como una salida anticipada. ¿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 de EmptyLookup<K,E> sencilla, simple y simple como sigue. (En mi opinión, hay no parece mucho beneficio para la creación de un ILookup<K,E> aplicación plena de acuerdo con 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

Usted puede volver nula

o excepción

Pero debe tener en cuenta que en el comentario de la clase

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

Answer 3

No hay Built-in , entonces solo escribiría un método de extensión que ejecute algo similar a new T[0].ToLookup<K, T>(x => default(K));

I es muy dudoso que devolver nulo sería más correcto aquí. Casi nunca se da el caso de que desee devolver el valor nulo de un método que devuelve una colección (a diferencia de una colección vacía). No podría estar más en desacuerdo con las personas que sugieren eso.

Answer 4

Puede crear una clase 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 se puede escribir código como este:

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

La ventaja de crear una nueva clase es que se puede utilizar el "es" operador y comprobar el tipo de igualdad:

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

Answer 5

Cree una lista vacía, luego ejecute ToLookup() en ella, como este:

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); 
    } 

}