Svuotare iLookup

Question

Ho un metodo che restituisce un ILookup. In alcuni casi, voglio restituire un ILookup vuota come una rapida uscita. Qual è il modo migliore di costruire un ILookup vuoto?

Answer 1

Oltre alle risposte da mquander e Vasile Bujac , è possibile creare una bella, semplice classe EmptyLookup<K,E> Singleton-esque come segue. (A mio parere, non ci non sembra molto benefica per la creazione di un'implementazione ILookup<K,E> completa come da risposta di 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

Non c'è built-in, quindi avevo appena scritto un metodo di estensione che corre qualcosa sulla falsariga di new T[0].ToLookup<K, T>(x => default(K));

I fortemente dubbio di tornare nulla sarebbe più corretto qui. E 'quasi mai il caso che si desidera restituire null da un metodo che restituisce un insieme (al contrario di un insieme vuoto.) Non potrei essere più in disaccordo con le persone che stanno suggerendo che.

Answer 3

È possibile creare una classe Singleton per le ricerche vuote.

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

Codice allora si può scrivere in questo modo:

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

Il vantaggio della creazione di una nuova classe è che è possibile utilizzare la "è" operatore e di controllo per l'uguaglianza tipo:

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

Answer 4

In base a LukeH risposta, mi piacerebbe creare un Lookup classe statica con una metodo Empty<TKey, TElement>. In questo modo è possibile utilizzare è solo allo stesso modo di Enumerable.Empty<T>.

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

Esempio di utilizzo: Lookup.Empty<string, string>()

Answer 5

Crea un elenco vuoto, quindi eseguire ToLookup () su di esso, in questo modo:

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

In bocca al lupo!

Answer 6

O qualcosa di più nello spirito di 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

E 'possibile restituire null

o eccezioni

Ma si deve notare che nel commento della classe

Aggiunto: + Questo è più evidente rispetto ad alcuni metodo di estensione