Vider iLookup

Question

I ai une méthode qui renvoie un ILookup. Dans certains cas, je veux retourner un ILookup vide comme une sortie précoce. Quelle est la meilleure façon de construire un ILookup vide?

Answer 1

Suite aux réponses de mquander et Vasile Bujac , vous pouvez créer une belle, simple classe EmptyLookup<K,E> singleton-esque comme suit. (À mon avis, il ne semble pas beaucoup d'avantages à la création d'une pleine mise en œuvre de ILookup<K,E> selon la réponse 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

Il a intégré pas, donc je venais d'écrire une méthode d'extension qui exécute quelque chose le long des lignes de new T[0].ToLookup<K, T>(x => default(K));

doute fortement retour nul serait plus correct ici. Il est presque jamais le cas que vous voulez retourner NULL d'une méthode qui retourne une collection (par opposition à une collection vide.) Je ne pouvais pas en désaccord peut-être plus avec des gens qui suggèrent que.

Answer 3

Vous pouvez créer une classe singleton pour les recherches vides.

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

vous pouvez écrire du code comme ceci:

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

L'avantage de créer une nouvelle classe est que vous pouvez utiliser la fonction « est » l'opérateur et le contrôle de l'égalité de type:

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

Answer 4

Sur la base de réponse LukeH , je créerais une Lookup de classe statique avec un procédé Empty<TKey, TElement>. De cette façon, vous pouvez utiliser est la même façon que Enumerable.Empty<T>.

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

Exemple d'utilisation: Lookup.Empty<string, string>()

Answer 5

Créer une liste vide, puis exécutez ToLookup () sur elle, comme ceci:

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

Bonne chance!

Answer 6

Ou quelque chose de plus dans l'esprit 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

Vous pouvez retourner null

ou Exception

Mais vous devriez le noter dans le commentaire de la classe

Ajouté: + Ceci est plus évident que d'une méthode d'extension