Im LINQ alle Werte der Eigenschaft X auswählen, bei denen X != null ist

Question

Gibt es einen kürzeren Weg, um das Folgende zu schreiben? (Etwas, das auf Null überprüft, ohne explizit != null zu schreiben)

from item in list 
where item.MyProperty != null 
select item.MyProperty

Answer 1

Sie können den OfType-Operator verwenden. Er ignoriert Nullwerte in der Ausgangssequenz. Verwenden Sie einfach denselben Typ wie MyProperty und es filtert nichts anderes aus.

// gegeben:
// public T MyProperty { get; }
var nonNullItems = list.Select(x => x.MyProperty).OfType();

Ich würde jedoch davon abraten. Wenn Sie nicht-null Werte auswählen möchten, was kann expliziter sein als zu sagen, dass Sie "die MyProperties aus der Liste, die nicht null sind", möchten?

Answer 2

Sie könnten Ihre eigene Erweiterungsmethode definieren, aber das würde ich nicht empfehlen.

public static IEnumerable SelectNonNull(this IEnumerable sequence,Func projection)
{
   return sequence.Select(projection).Where(e => e != null);
}

Ich mag diese Methode nicht, weil sie zwei Anliegen mischt. Das Projektieren mit Select und das Filtern Ihrer Nullwerte sind separate Operationen und sollten nicht zu einer Methode kombiniert werden.

---

Ich würde lieber eine Erweiterungsmethode definieren, die nur überprüft, ob das Element nicht null ist:

public static IEnumerable WhereNotNull(this IEnumerable sequence)
{
   return sequence.Where(e => e != null);
}

public static IEnumerable WhereNotNull(this IEnumerable sequence)
    where T : struct
{
   return sequence.Where(e => e != null).Select(e => e.Value);
}

Dies hat nur einen einzigen Zweck, nämlich das Überprüfen auf Null. Bei nullable-Werttypen wird es in den nicht nullable-Äquivalenten umgewandelt, da es sinnlos ist, den nullable-Wrapper für Werte zu erhalten, die nicht null sein können.

Mit dieser Methode wird Ihr Code zu:

list.Select(item => item.MyProperty).WhereNotNull()

Answer 3

Ich neige dazu, eine statische Klasse mit grundlegenden Funktionen für Fälle wie diese zu erstellen. Sie ermöglichen es mir, Ausdrücke wie

var myValues myItems.Select(x => x.Value).Where(Predicates.IsNotNull);

Und die Sammlung von Prädikatsfunktionen:

public static class Predicates
{
    public static bool IsNull(T value) where T : class
    {
        return value == null;
    }

    public static bool IsNotNull(T value) where T : class
    {
        return value != null;
    }

    public static bool IsNull(T? nullableValue) where T : struct
    {
        return !nullableValue.HasValue;
    }

    public static bool IsNotNull(T? nullableValue) where T : struct
    {
        return nullableValue.HasValue;
    }

    public static bool HasValue(T? nullableValue) where T : struct
    {
        return nullableValue.HasValue;
    }

    public static bool HasNoValue(T? nullableValue) where T : struct
    {
        return !nullableValue.HasValue;
    }
}

Answer 4

Es besteht keine Möglichkeit, einen Check zu überspringen, wenn er existiert.

Answer 5

// Wenn Sie überprüfen müssen, ob MyProperty aller Elemente nicht null ist

if (list.All(x => x.MyProperty != null))
// do something

// oder wenn Sie überprüfen müssen, ob mindestens ein Elementeigenschaft nicht null ist

if (list.Any(x => x.MyProperty != null))
// do something

Sie müssen jedoch immer auf null überprüfen