Deep Null Checking, gibt es einen besseren Weg?

Hinweis: Diese Frage vor der Einführung der gebeten wurde , den .?Operator in C 6 / Visual Studio 2015 , .

Wir waren alle dort, wir haben einige tiefe Eigenschaften wie cake.frosting.berries.loader, die wir überprüfen müssen, ob sie null sind, damit es keine Ausnahme gibt. Der Weg, dies zu tun, besteht darin, eine kurzschließende if-Anweisung zu verwenden

if (cake != null && cake.frosting != null && cake.frosting.berries != null) ...

Dies ist nicht gerade elegant, und es sollte möglicherweise eine einfachere Möglichkeit geben, die gesamte Kette zu überprüfen und festzustellen, ob sie auf eine Nullvariable / -eigenschaft stößt.

Ist es möglich, eine Erweiterungsmethode zu verwenden, oder wäre es eine Sprachfunktion, oder ist es nur eine schlechte Idee?

Wir haben überlegt, eine neue Operation "?" auf die Sprache, die die gewünschte Semantik hat. (Und es wurde jetzt hinzugefügt; siehe unten.) Das heißt, Sie würden sagen

cake?.frosting?.berries?.loader

und der Compiler würde alle Kurzschlussprüfungen für Sie generieren.

Es hat die Messlatte für C # 4 nicht erreicht. Vielleicht für eine hypothetische zukünftige Version der Sprache.

Update (2014): Der ?.Betreiber ist jetzt geplant für die nächste Roslyn Compiler - Release. Beachten Sie, dass es immer noch einige Debatten über die genaue syntaktische und semantische Analyse des Operators gibt.

Update (Juli 2015): Visual Studio 2015 wurde veröffentlicht und wird mit einem C # -Compiler geliefert, der die nullbedingten Operatoren ?.und unterstützt?[] .

Diese Frage hat mich dazu inspiriert, herauszufinden, wie diese Art der tiefen Nullprüfung mit einer einfacheren / schöneren Syntax unter Verwendung von Ausdrucksbäumen durchgeführt werden kann. Ich stimme zwar den Antworten zu, die besagen, dass dies möglich ist ein schlechtes Design sein , wenn Sie häufig auf Instanzen tief in der Hierarchie zugreifen müssen, aber ich denke auch, dass es in einigen Fällen, wie z. B. bei der Datenpräsentation, sehr nützlich sein kann.

Also habe ich eine Erweiterungsmethode erstellt, mit der Sie schreiben können:

var berries = cake.IfNotNull(c => c.Frosting.Berries);

Dies gibt die Beeren zurück, wenn kein Teil des Ausdrucks null ist. Wenn null angetroffen wird, wird null zurückgegeben. Es gibt jedoch einige Einschränkungen: In der aktuellen Version funktioniert es nur mit einfachem Mitgliederzugriff und nur mit .NET Framework 4, da die in Version 4 neue Methode MemberExpression.Update verwendet wird. Dies ist der Code für die IfNotNull-Erweiterungsmethode:

using System;
using System.Collections.Generic;
using System.Linq.Expressions;

namespace dr.IfNotNullOperator.PoC
{
    public static class ObjectExtensions
    {
        public static TResult IfNotNull<TArg,TResult>(this TArg arg, Expression<Func<TArg,TResult>> expression)
        {
            if (expression == null)
                throw new ArgumentNullException("expression");

            if (ReferenceEquals(arg, null))
                return default(TResult);

            var stack = new Stack<MemberExpression>();
            var expr = expression.Body as MemberExpression;
            while(expr != null)
            {
                stack.Push(expr);
                expr = expr.Expression as MemberExpression;
            } 

            if (stack.Count == 0 || !(stack.Peek().Expression is ParameterExpression))
                throw new ApplicationException(String.Format("The expression '{0}' contains unsupported constructs.",
                                                             expression));

            object a = arg;
            while(stack.Count > 0)
            {
                expr = stack.Pop();
                var p = expr.Expression as ParameterExpression;
                if (p == null)
                {
                    p = Expression.Parameter(a.GetType(), "x");
                    expr = expr.Update(p);
                }
                var lambda = Expression.Lambda(expr, p);
                Delegate t = lambda.Compile();                
                a = t.DynamicInvoke(a);
                if (ReferenceEquals(a, null))
                    return default(TResult);
            }

            return (TResult)a;            
        }
    }
}

Es funktioniert, indem der Ausdrucksbaum, der Ihren Ausdruck darstellt, untersucht und die Teile nacheinander bewertet werden. jedes Mal, wenn überprüft wird, ob das Ergebnis nicht null ist.

Ich bin sicher, dass dies erweitert werden könnte, so dass andere Ausdrücke als MemberExpression unterstützt werden. Betrachten Sie dies als Proof-of-Concept-Code und denken Sie daran, dass die Verwendung einen Leistungsverlust zur Folge hat (was in vielen Fällen wahrscheinlich keine Rolle spielt, aber nicht in einer engen Schleife verwendet wird :-)).

Ich habe festgestellt, dass diese Erweiterung für Deep-Nesting-Szenarien sehr nützlich ist.

public static R Coal<T, R>(this T obj, Func<T, R> f)
    where T : class
{
    return obj != null ? f(obj) : default(R);
}

Diese Idee habe ich vom Null-Koaleszenz-Operator in C # und T-SQL abgeleitet. Das Schöne ist, dass der Rückgabetyp immer der Rückgabetyp der inneren Eigenschaft ist.

Auf diese Weise können Sie Folgendes tun:

var berries = cake.Coal(x => x.frosting).Coal(x => x.berries);

... oder eine geringfügige Abweichung von den oben genannten:

var berries = cake.Coal(x => x.frosting, x => x.berries);

Es ist nicht die beste Syntax, die ich kenne, aber es funktioniert.

Abgesehen von der Verletzung des Demeter-Gesetzes, wie Mehrdad Afshari bereits betont hat, scheint es mir, dass Sie für die Entscheidungslogik eine "tiefe Nullprüfung" benötigen.

Dies ist meistens der Fall, wenn Sie leere Objekte durch Standardwerte ersetzen möchten. In diesem Fall sollten Sie das Nullobjektmuster implementieren . Es fungiert als Ersatz für ein reales Objekt und bietet Standardwerte und "Nicht-Aktions" -Methoden.

Update: Ab Visual Studio 2015 erkennt der C # -Compiler (Sprachversion 6) jetzt den ?.Operator, was das "Deep Null Checking" zum Kinderspiel macht. Siehe diese Antwort für Details.

Abgesehen von der Neugestaltung Ihres Codes, wie in dieser gelöschten Antwort vorgeschlagen, besteht eine andere (wenn auch schreckliche) Option darin, einen try…catchBlock zu verwenden, um festzustellen, ob NullReferenceExceptionirgendwann während dieser tiefen Eigenschaftssuche ein Fehler auftritt.

try
{
    var x = cake.frosting.berries.loader;
    ...
}
catch (NullReferenceException ex)
{
    // either one of cake, frosting, or berries was null
    ...
}

Ich persönlich würde dies aus folgenden Gründen nicht tun:

• Es sieht nicht gut aus.
• Es verwendet die Ausnahmebehandlung, die auf Ausnahmesituationen abzielen sollte und nicht auf etwas, das Sie im normalen Betriebsverlauf häufig erwarten.
• NullReferenceExceptions sollte wahrscheinlich nie explizit gefangen werden. (Siehe diese Frage .)

Ist es also möglich, eine Erweiterungsmethode zu verwenden, oder wäre es eine Sprachfunktion, [...]

Dies müsste mit ziemlicher Sicherheit eine Sprachfunktion sein (die in C # 6 in Form von .?und ?[]Operatoren verfügbar ist ), es sei denn, C # hatte bereits eine ausgefeiltere verzögerte Auswertung oder Sie möchten Reflektion verwenden (was wahrscheinlich auch keine ist gute Idee aus Gründen der Leistung und Typensicherheit).

Da es keine Möglichkeit gibt, einfach cake.frosting.berries.loaderan eine Funktion zu übergeben (sie würde ausgewertet und eine Nullreferenzausnahme auslösen), müssten Sie eine allgemeine Suchmethode folgendermaßen implementieren: Sie nimmt Objekte und die Namen von Eigenschaften auf Sieh nach oben:

static object LookupProperty( object startingPoint, params string[] lookupChain )
{
    // 1. if 'startingPoint' is null, return null, or throw an exception.
    // 2. recursively look up one property/field after the other from 'lookupChain',
    //    using reflection.
    // 3. if one lookup is not possible, return null, or throw an exception.
    // 3. return the last property/field's value.
}

...

var x = LookupProperty( cake, "frosting", "berries", "loader" );

(Hinweis: Code bearbeitet.)

Sie sehen schnell mehrere Probleme mit einem solchen Ansatz. Erstens erhalten Sie keine Typensicherheit und kein mögliches Boxen von Eigenschaftswerten eines einfachen Typs. Zweitens können Sie entweder zurückkehren, nullwenn etwas schief geht, und Sie müssen dies in Ihrer aufrufenden Funktion überprüfen, oder Sie lösen eine Ausnahme aus, und Sie kehren zu Ihrem Ausgangspunkt zurück. Drittens könnte es langsam sein. Viertens sieht es hässlicher aus als das, womit Sie begonnen haben.

[...] oder ist es nur eine schlechte Idee?

Ich würde entweder bleiben bei:

if (cake != null && cake.frosting != null && ...) ...

oder gehen Sie mit der obigen Antwort von Mehrdad Afshari.

PS: Als ich diese Antwort schrieb, habe ich offensichtlich keine Ausdrucksbäume für Lambda-Funktionen berücksichtigt. Siehe zB die Antwort von @driis für eine Lösung in dieser Richtung. Es basiert auch auf einer Art Reflexion und ist daher möglicherweise nicht ganz so gut wie eine einfachere Lösung ( if (… != null & … != null) …), kann jedoch aus syntaktischer Sicht besser beurteilt werden.

Die Antwort von driis ist zwar interessant, aber meiner Meinung nach in Bezug auf die Leistung etwas zu teuer. Anstatt viele Delegaten zu kompilieren, würde ich es vorziehen, ein Lambda pro Eigenschaftspfad zu kompilieren, es zwischenzuspeichern und dann viele Typen neu aufzurufen.

NullCoalesce unten macht genau das. Es gibt einen neuen Lambda-Ausdruck mit Nullprüfungen und einer Standardrückgabe (TResult) zurück, falls ein Pfad null ist.

Beispiel:

NullCoalesce((Process p) => p.StartInfo.FileName)

Gibt einen Ausdruck zurück

(Process p) => (p != null && p.StartInfo != null ? p.StartInfo.FileName : default(string));

Code:

    static void Main(string[] args)
    {
        var converted = NullCoalesce((MethodInfo p) => p.DeclaringType.Assembly.Evidence.Locked);
        var converted2 = NullCoalesce((string[] s) => s.Length);
    }

    private static Expression<Func<TSource, TResult>> NullCoalesce<TSource, TResult>(Expression<Func<TSource, TResult>> lambdaExpression)
    {
        var test = GetTest(lambdaExpression.Body);
        if (test != null)
        {
            return Expression.Lambda<Func<TSource, TResult>>(
                Expression.Condition(
                    test,
                    lambdaExpression.Body,
                    Expression.Default(
                        typeof(TResult)
                    )
                ),
                lambdaExpression.Parameters
            );
        }
        return lambdaExpression;
    }

    private static Expression GetTest(Expression expression)
    {
        Expression container;
        switch (expression.NodeType)
        {
            case ExpressionType.ArrayLength:
                container = ((UnaryExpression)expression).Operand;
                break;
            case ExpressionType.MemberAccess:
                if ((container = ((MemberExpression)expression).Expression) == null)
                {
                    return null;
                }
                break;
            default:
                return null;
        }
        var baseTest = GetTest(container);
        if (!container.Type.IsValueType)
        {
            var containerNotNull = Expression.NotEqual(
                container,
                Expression.Default(
                    container.Type
                )
            );
            return (baseTest == null ?
                containerNotNull :
                Expression.AndAlso(
                    baseTest,
                    containerNotNull
                )
            );
        }
        return baseTest;
    }

Eine Möglichkeit besteht darin, das Null-Objekt-Patten zu verwenden. Statt Null zu haben, wenn Sie keinen Kuchen haben, haben Sie einen Null-Kuchen, der ein NullFosting usw. zurückgibt. Tut mir leid, ich kann das nicht sehr gut erklären, aber andere Leute sind es, siehe

• Ein Beispiel für die Verwendung von Null Object Patten
• Die Wikipedai schreiben auf den Null Object Patten

Auch ich habe mir oft eine einfachere Syntax gewünscht! Es wird besonders hässlich, wenn Sie Methodenrückgabewerte haben, die möglicherweise null sind, weil Sie dann zusätzliche Variablen benötigen (zum Beispiel:cake.frosting.flavors.FirstOrDefault().loader )

Hier ist jedoch eine ziemlich anständige Alternative, die ich verwende: Erstellen Sie eine Null-Safe-Chain-Hilfsmethode. Mir ist klar, dass dies der obigen Antwort von @ John (mit der CoalErweiterungsmethode) ziemlich ähnlich ist, aber ich finde, dass es einfacher ist und weniger tippt. So sieht es aus:

var loader = NullSafe.Chain(cake, c=>c.frosting, f=>f.berries, b=>b.loader);

Hier ist die Implementierung:

public static TResult Chain<TA,TB,TC,TResult>(TA a, Func<TA,TB> b, Func<TB,TC> c, Func<TC,TResult> r) 
where TA:class where TB:class where TC:class {
    if (a == null) return default(TResult);
    var B = b(a);
    if (B == null) return default(TResult);
    var C = c(B);
    if (C == null) return default(TResult);
    return r(C);
}

Ich habe auch mehrere Überladungen (mit 2 bis 6 Parametern) sowie Überladungen erstellt, die es der Kette ermöglichen, mit einem Werttyp oder einer Standardeinstellung zu enden. Das funktioniert wirklich gut für mich!

Es gibt ein Vielleicht-Codeplex-Projekt , das Vielleicht oder IfNotNull implementiert und Lambdas für tiefe Ausdrücke in C # verwendet

Anwendungsbeispiel:

int? CityId= employee.Maybe(e=>e.Person.Address.City);

Der Link wurde in einer ähnlichen Frage vorgeschlagen. Wie wird in einem tiefen Lambda-Ausdruck nach Nullen gesucht?

Wie in der Antwort von John Leidegren vorgeschlagen , besteht ein Ansatz zur Umgehung dieses Problems darin , Erweiterungsmethoden und Delegaten zu verwenden. Ihre Verwendung könnte ungefähr so ​​aussehen:

int? numberOfBerries = cake
    .NullOr(c => c.Frosting)
    .NullOr(f => f.Berries)
    .NullOr(b => b.Count());

Die Implementierung ist unübersichtlich, da sie für Werttypen, Referenztypen und nullfähige Werttypen funktionieren muss. Sie können eine vollständige Implementierung in finden Timwi ‚s Antwort auf Was ist der richtige Weg ist für Null - Werte zu überprüfen? .

Oder Sie können Reflexion verwenden :)

Reflexionsfunktion:

public Object GetPropValue(String name, Object obj)
    {
        foreach (String part in name.Split('.'))
        {
            if (obj == null) { return null; }

            Type type = obj.GetType();
            PropertyInfo info = type.GetProperty(part);
            if (info == null) { return null; }

            obj = info.GetValue(obj, null);
        }
        return obj;
    }

Verwendung:

object test1 = GetPropValue("PropertyA.PropertyB.PropertyC",obj);

Mein Fall (DBNull.Value anstelle von null in der Reflexionsfunktion zurückgeben):

cmd.Parameters.AddWithValue("CustomerContactEmail", GetPropValue("AccountingCustomerParty.Party.Contact.ElectronicMail.Value", eInvoiceType));

Versuchen Sie diesen Code:

    /// <summary>
    /// check deep property
    /// </summary>
    /// <param name="obj">instance</param>
    /// <param name="property">deep property not include instance name example "A.B.C.D.E"</param>
    /// <returns>if null return true else return false</returns>
    public static bool IsNull(this object obj, string property)
    {
        if (string.IsNullOrEmpty(property) || string.IsNullOrEmpty(property.Trim())) throw new Exception("Parameter : property is empty");
        if (obj != null)
        {
            string[] deep = property.Split('.');
            object instance = obj;
            Type objType = instance.GetType();
            PropertyInfo propertyInfo;
            foreach (string p in deep)
            {
                propertyInfo = objType.GetProperty(p);
                if (propertyInfo == null) throw new Exception("No property : " + p);
                instance = propertyInfo.GetValue(instance, null);
                if (instance != null)
                    objType = instance.GetType();
                else
                    return true;
            }
            return false;
        }
        else
            return true;
    }

Ich habe das letzte Nacht gepostet und dann hat mich ein Freund auf diese Frage hingewiesen. Ich hoffe es hilft. Sie können dann so etwas tun:

var color = Dis.OrDat<string>(() => cake.frosting.berries.color, "blue");


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Linq.Expressions;

namespace DeepNullCoalescence
{
  public static class Dis
  {
    public static T OrDat<T>(Expression<Func><T>> expr, T dat)
    {
      try
      {
        var func = expr.Compile();
        var result = func.Invoke();
        return result ?? dat; //now we can coalesce
      }
      catch (NullReferenceException)
      {
        return dat;
      }
    }
  }
}

Lesen Sie hier den vollständigen Blog-Beitrag .

Der gleiche Freund schlug auch vor, dass Sie dies sehen .

Ich habe den Code von hier aus leicht geändert , damit er für die gestellte Frage funktioniert:

public static class GetValueOrDefaultExtension
{
    public static TResult GetValueOrDefault<TSource, TResult>(this TSource source, Func<TSource, TResult> selector)
    {
        try { return selector(source); }
        catch { return default(TResult); }
    }
}

Und ja, dies ist wahrscheinlich nicht die optimale Lösung, da die Leistung beeinträchtigt wird, aber es funktioniert:>

Verwendung:

var val = cake.GetValueOrDefault(x => x.frosting.berries.loader);

Wo Sie dies erreichen müssen, tun Sie Folgendes:

Verwendung

Color color = someOrder.ComplexGet(x => x.Customer.LastOrder.Product.Color);

oder

Color color = Complex.Get(() => someOrder.Customer.LastOrder.Product.Color);

Implementierung der Hilfsklasse

public static class Complex
{
    public static T1 ComplexGet<T1, T2>(this T2 root, Func<T2, T1> func)
    {
        return Get(() => func(root));
    }

    public static T Get<T>(Func<T> func)
    {
        try
        {
            return func();
        }
        catch (Exception)
        {
            return default(T);
        }
    }
}

Ich mag den Ansatz von Objective-C:

"Die Objective-C-Sprache verfolgt einen anderen Ansatz für dieses Problem und ruft keine Methoden für nil auf, sondern gibt für alle derartigen Aufrufe nil zurück."

if (cake.frosting.berries != null) 
{
    var str = cake.frosting.berries...;
}