Leeres ilookup

Question

Ich habe eine Methode, die eine zurückgibt ILookup. In einigen Fällen möchte ich einen leeren zurückgeben ILookup als früher Ausstieg. Was ist der beste Weg, um einen leeren zu konstruieren? ILookup?

Answer 1

Weiter zu den Antworten von Mquander und Vasile Bujac, Sie könnten einen schönen, unkomplizierten Singleton-ähnlichen schaffen EmptyLookup<K,E> Klasse wie folgt. (Meiner Meinung nach scheint es nicht viel Nutzen zu sein, ein volles Schaffung zu schaffen ILookup<K,E> Implementierung gemäß der Antwort von 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

Es gibt kein integriertes Integrieren, also schreibe ich nur eine Erweiterungsmethode, die etwas in der Reihe von Ausführungen ausführt new T[0].ToLookup<K, T>(x => default(K));

ich stark Zweifel Rückkehr null wäre hier korrekter. Es ist fast nie so, dass Sie Null aus einer Methode zurückgeben möchten, die eine Sammlung zurückgibt (im Gegensatz zu einer leeren Sammlung). Ich konnte unmöglich mehr mit Menschen nicht einverstanden sein, die dies vorschlagen.

Answer 3

Sie können eine Singleton -Klasse für leere Lookups erstellen.

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

Dann können Sie einen solchen Code schreiben:

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

Der Vorteil der Erstellung einer neuen Klasse besteht darin, dass Sie den Operator "IS" verwenden können und nach der Typität der Type prüfen können:

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

Answer 4

Bezogen auf Lukeh Antwort, ich würde eine statische Klasse erstellen Lookup mit einem Empty<TKey, TElement> Methode. Auf diese Weise können Sie genauso genauso verwendet wie Enumerable.Empty<T>.

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

Beispiel Verwendung: Lookup.Empty<string, string>()

Answer 5

Erstellen Sie eine leere Liste und führen Sie dann Tolookup () darauf aus:

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

Viel Glück!

Answer 6

Oder etwas mehr im Geist von 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

Sie können null zurückkehren

oder Ausnahme

Aber Sie sollten es im Unterrichtskommentar beachten

Hinzugefügt:+ Dies ist offensichtlicher als eine Erweiterungsmethode