Derin boşluk kontrolü, daha iyi bir yol var mı?

Not: Bu soru giriş önce istendi Studio 2015 6. / Visual C operatörü ..?

Hepimiz oradaydık, cake.frosting.berries.loader gibi derin bir özelliğimiz var, boş olup olmadığını kontrol etmemiz gerekiyor, bu yüzden istisna yok. Bunu yapmanın yolu, kısa devre yapan if ifadesi kullanmaktır.

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

Bu tam olarak zarif değildir ve belki de tüm zinciri kontrol etmenin ve boş bir değişken / özelliğe karşı çıkıp çıkmadığını görmenin daha kolay bir yolu olmalıdır.

Bir uzatma yöntemi kullanmak mümkün mü yoksa bir dil özelliği mi yoksa sadece kötü bir fikir mi?

Yeni bir "?" Operasyonu eklemeyi düşündük. istediğiniz semantiğe sahip dile. (Ve şimdi eklendi; aşağıya bakın.) Yani,

cake?.frosting?.berries?.loader

ve derleyici sizin için tüm kısa devre kontrollerini oluşturacaktır.

C # 4 için çıtayı koymadı. Belki dilin varsayımsal bir gelecek versiyonu için.

Güncelleme (2014):?. operatör şimdi olduğu planlanan sonraki Roslyn derleyici serbest bırakılması için. Operatörün tam sözdizimsel ve anlambilimsel analizi konusunda hala bazı tartışmalar olduğunu unutmayın.

Güncelleme (Temmuz 2015): Visual Studio 2015 yayınlandı ve boş koşullu işleçleri?.?[] destekleyen bir C # derleyicisi ile birlikte ve .

İfade ağaçları kullanılarak daha kolay / daha güzel bir sözdizimi ile bu tür derin boşluk kontrolünün nasıl yapılabileceğini öğrenmek için bu sorudan ilham aldım. Hiyerarşinin derinliklerindeki örneklere sık sık erişmeniz gerekiyorsa bunun kötü bir tasarım olabileceğini belirten yanıtlara katılıyorum, ancak veri sunumu gibi bazı durumlarda bunun çok yararlı olabileceğini düşünüyorum.

Bu yüzden yazmanıza izin verecek bir uzantı yöntemi oluşturdum:

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

İfadenin hiçbir bölümü boş değilse, bu Berries'i döndürecektir. Null ile karşılaşılırsa, null döndürülür. Yine de bazı uyarılar var, şu anki sürümde yalnızca basit üye erişimiyle çalışacak ve yalnızca .NET Framework 4'te çalışıyor çünkü v4.2'de yeni olan MemberExpression.Update yöntemini kullanıyor. Bu, IfNotNull uzantı yönteminin kodudur:

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

İfadenizi temsil eden ifade ağacını inceleyerek ve parçaları birbiri ardına değerlendirerek çalışır; her seferinde sonucun boş olmadığını kontrol edin.

Eminim bu, MemberExpression dışındaki diğer ifadelerin desteklenmesi için uzatılabilir. Bunu kavram kanıtı kodu olarak düşünün ve lütfen bunu kullandığınızda bir performans cezası olacağını unutmayın (bu muhtemelen çoğu durumda önemli olmayacaktır, ancak sıkı bir döngü içinde kullanmayın :-))

Bu uzantıyı, derin yuvalama senaryoları için oldukça yararlı buldum.

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

Bu, C # ve T-SQL'deki boş birleştirme operatöründen çıkardığım bir fikir. Güzel olan şey, dönüş türünün her zaman iç özelliğin dönüş türü olmasıdır.

Bu şekilde bunu yapabilirsiniz:

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

... veya yukarıdakinin hafif bir varyasyonu:

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

Bildiğim en iyi sözdizimi değil ama işe yarıyor.

Demeter Yasasını ihlal etmenin yanı sıra, Mehrdad Afshari'nin daha önce de belirttiği gibi, bana öyle geliyor ki karar mantığı için "derin bir sıfır kontrolüne" ihtiyacınız var.

Bu, genellikle boş nesneleri varsayılan değerlerle değiştirmek istediğinizde ortaya çıkar. Bu durumda, Boş Nesne Kalıbını uygulamayı düşünmelisiniz . Varsayılan değerler ve "eylem dışı" yöntemler sağlayarak, gerçek bir nesne için bir stand-in görevi görür.

Güncelleme: Visual Studio 2015'ten başlayarak, C # derleyicisi (dil sürümü 6) artık ?.operatörü tanıyor ve bu da "derin boşluk denetimini" çocuk oyuncağı haline getiriyor. Ayrıntılar için bu yanıta bakın.

Bu silinmiş cevabın önerdiği gibi kodunuzu yeniden tasarlamanın yanı sıra , başka (korkunç da olsa) bir seçenek, bu derin mülk araması sırasında try…catchbir ara NullReferenceExceptionmeydana gelip gelmediğini görmek için bir blok kullanmak olabilir .

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

Şahsen bunu aşağıdaki nedenlerden dolayı yapmazdım:

• Hoş görünmüyor.
• Normal çalışma sırasında sık sık olmasını beklediğiniz bir şeyi değil, istisnai durumları hedeflemesi gereken istisna işlemeyi kullanır.
• NullReferenceExceptions muhtemelen hiçbir zaman açıkça yakalanmamalıdır. ( Bu soruya bakın .)

Öyleyse, bazı uzatma yöntemlerini kullanmak mümkün mü yoksa bir dil özelliği mi, [...]

Bu neredeyse kesin (biçiminde C # 6 kullanılabilen bir dil özelliği olması gerekir .?ve ?[]C # zaten daha sofistike tembel muayeneden geçmiş sürece, operatörler) veya muhtemelen de değildir yansıması (kullanmak istemiyorsanız performans ve tip güvenliği açısından iyi bir fikir).

cake.frosting.berries.loaderBir işleve basitçe geçiş yapmanın bir yolu olmadığından (değerlendirilir ve boş bir referans istisnası atılır), aşağıdaki şekilde genel bir arama yöntemi uygulamanız gerekir: Bir nesneyi ve özelliklerin adlarını alır yukarı Bak:

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" );

(Not: kod düzenlendi.)

Böyle bir yaklaşımla hızlıca birkaç sorun görürsünüz. İlk olarak, herhangi bir güvenlik türü ve basit bir türdeki özellik değerlerinin olası kutulamasını elde edemezsiniz. İkincisi, bir nullşeyler ters giderse geri dönebilirsiniz ve arama işlevinizde bunu kontrol etmeniz gerekecek veya bir istisna atarsınız ve başladığınız yere geri dönersiniz. Üçüncüsü, yavaş olabilir. Dördüncüsü, başladığından daha çirkin görünüyor.

[...] veya bu sadece kötü bir fikir mi?

Ya şununla kalırdım:

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

ya da Mehrdad Afshari'nin yukarıdaki cevabı ile devam edin.

Not: Bu cevabı yazdığımda, lambda fonksiyonları için ifade ağaçlarını açıkça düşünmemiştim; Bu yöndeki bir çözüm için örneğin @driis'in cevabına bakınız. Aynı zamanda bir tür düşünceye dayalıdır ve bu nedenle daha basit bir çözüm ( if (… != null & … != null) …) kadar iyi performans göstermeyebilir , ancak sözdizimi açısından daha iyi değerlendirilebilir.

Driis'in cevabı ilginç olsa da, performans açısından biraz fazla pahalı olduğunu düşünüyorum. Birçok temsilci derlemek yerine, özellik yolu başına bir lambda derlemeyi, onu önbelleğe almayı ve sonra birçok türü yeniden çağırmayı tercih ederim.

Aşağıdaki NullCoalesce tam da bunu yapar, herhangi bir yolun boş olması durumunda boş kontroller ve bir varsayılan dönüş (TResult) ile yeni bir lambda ifadesi döndürür.

Misal:

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

Bir ifade döndürecektir

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

Kod:

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

Bir seçenek, Null Object Patten kullanmaktır, bu nedenle, bir pastanız olmadığında null yerine, bir NullFosting döndüren bir NullCake'e sahip olursunuz vb. Üzgünüm bunu açıklamakta pek iyi değilim ama diğer insanlar, bakın

• Boş Nesne Patten kullanımına bir örnek
• Vikipedi, Boş Nesne Patten hakkında yazdı

Ben de sık sık daha basit bir sözdizimi diledim! Eğer null olabilir yöntemi dönüşümsüz değerlerine sahip olduğunda o zaman ekstra değişkenleri gerekir, çünkü, özellikle çirkin alır (örneğin: cake.frosting.flavors.FirstOrDefault().loader)

Ancak, işte kullandığım oldukça iyi bir alternatif: bir Null-Safe-Chain yardımcı yöntemi oluşturun. Bunun @ John'un yukarıdaki cevabına oldukça benzediğinin farkındayım ( Coaluzatma yöntemiyle) ancak daha basit ve daha az yazarak buluyorum. Göründüğü gibi:

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

İşte uygulama:

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

Ayrıca, zincirin bir değer türü veya varsayılanla bitmesine izin veren aşırı yüklerin yanı sıra birkaç aşırı yük (2 ila 6 parametreli) oluşturdum. Bu benim için gerçekten işe yarıyor!

Orada Belki codeplex proje Belki uygular veya IfNotNull C # derin ifadeler için lambdas kullanarak bu

Kullanım örneği:

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

Bağlantı benzer bir soruda önerildi Derin bir lambda ifadesinde boş değerler nasıl kontrol edilir?

İçerisinde ileri sürüldüğü gibi , John Leidegren 'ın cevabı , bir yaklaşım çalışması-etrafında bu uzantı yöntem ve delegeleri kullanmaktır. Bunları kullanmak şunun gibi görünebilir:

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

Uygulama karmaşıktır çünkü değer türleri, başvuru türleri ve null yapılabilir değer türleri için çalışmasını sağlamanız gerekir. Sen tam bir uygulama bulabilirsiniz Timwi 'ın cevabı için null değerleri denetlemek için doğru yolu nedir? .

Ya da yansıma kullanabilirsiniz :)

Yansıma işlevi:

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

Kullanımı:

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

My Case (yansıma işlevinde null yerine DBNull.Value döndür):

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

Bu kodu deneyin:

    /// <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;
    }

Bunu dün gece gönderdim ve sonra bir arkadaşım bana bu soruya işaret etti. Umarım yardımcı olur. Daha sonra şuna benzer bir şey yapabilirsiniz:

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

Blog yazısının tamamını buradan okuyun .

Aynı arkadaş da bunu izlemeni önerdi .

Sorulan soru için çalışmasını sağlamak için kodu buradan biraz değiştirdim :

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

Ve evet, bu muhtemelen dene / yakala performans etkileri nedeniyle en uygun çözüm değil ama işe yarıyor:>

Kullanımı:

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

Bunu başarmanız gereken yerde şunu yapın:

kullanım

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

veya

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

Yardımcı sınıf uygulaması

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

Objective-C tarafından alınan yaklaşımı seviyorum:

"Objective-C dili bu soruna başka bir yaklaşım getiriyor ve nil üzerinde yöntemleri çağırmıyor, bunun yerine tüm bu tür çağrılar için nil döndürüyor."

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