सी # सुरुचिपूर्ण तरीके से यह जांचने के लिए कि किसी संपत्ति की संपत्ति शून्य है या नहीं

Question 1

C # में, कहें कि आप इस उदाहरण में PropertyC का मान खींचना चाहते हैं और ObjectA, PropertyA और PropertyB सभी शून्य हो सकते हैं।

ObjectA.PropertyA.PropertyB.PropertyC

मैं कम से कम कोड वाली प्रॉपर्टी को सुरक्षित रूप से कैसे प्राप्त कर सकता हूं?

अभी मैं जाँच करूँगा:

if(ObjectA != null && ObjectA.PropertyA !=null && ObjectA.PropertyA.PropertyB != null)
{
    // safely pull off the value
    int value = objectA.PropertyA.PropertyB.PropertyC;
}

इस तरह कुछ और करना अच्छा होगा (छद्म कोड)।

int value = ObjectA.PropertyA.PropertyB ? ObjectA.PropertyA.PropertyB : defaultVal;

संभवतः एक अशक्त-सह-संचालक के साथ और भी अधिक ढह गई।

EDIT मूल रूप से मैंने कहा कि मेरा दूसरा उदाहरण js जैसा था, लेकिन मैंने इसे psuedo-code में बदल दिया क्योंकि यह सही ढंग से बताया गया था कि यह js में काम नहीं करेगा।

Question 2

C # 6 में आप Null Conditional Operator का उपयोग कर सकते हैं । तो मूल परीक्षा होगी:

int? value = objectA?.PropertyA?.PropertyB?.PropertyC;

Question 3

लघु विस्तार विधि:

public static TResult IfNotNull<TInput, TResult>(this TInput o, Func<TInput, TResult> evaluator)
  where TResult : class where TInput : class
{
  if (o == null) return null;
  return evaluator(o);
}

का उपयोग करते हुए

PropertyC value = ObjectA.IfNotNull(x => x.PropertyA).IfNotNull(x => x.PropertyB).IfNotNull(x => x.PropertyC);

यह सरल विस्तार विधि और बहुत कुछ आप पर पा सकते हैं http://devtalk.net/csharp/chained-null-checks-and-the-maybe-monad/

संपादित करें:

क्षण के लिए इसका उपयोग करने के बाद मुझे लगता है कि इस विधि के लिए उचित नाम मूल With () के बजाय IfNotNull () होना चाहिए ।

Question 4

क्या आप अपनी कक्षा में एक विधि जोड़ सकते हैं? यदि नहीं, तो क्या आपने विस्तार विधियों का उपयोग करने के बारे में सोचा है? आप अपने ऑब्जेक्ट प्रकार के लिए एक एक्सटेंशन विधि बना सकते हैं जिसे कहा जाता हैGetPropC() ।

उदाहरण:

public static class MyExtensions
{
    public static int GetPropC(this MyObjectType obj, int defaltValue)
    {
        if (obj != null && obj.PropertyA != null & obj.PropertyA.PropertyB != null)
            return obj.PropertyA.PropertyB.PropertyC;
        return defaltValue;
    }
}

उपयोग:

int val = ObjectA.GetPropC(0); // will return PropC value, or 0 (defaltValue)

वैसे, यह मानता है कि आप .NET 3 या उच्चतर का उपयोग कर रहे हैं।

Question 5

जिस तरह से आप कर रहे हैं वह सही है।

आप यहाँ बताए गए ट्रिक का उपयोग कर सकते हैं , जो Linq व्यंजक का उपयोग कर रहा है:

int value = ObjectA.NullSafeEval(x => x.PropertyA.PropertyB.PropertyC, 0);

लेकिन यह बहुत धीमी है कि मैन्युअल रूप से प्रत्येक संपत्ति की जाँच कर रहा है ...

Question 6

कानून के कानून का पालन करने के लिए रिफ्लेक्टर

Question 7

अद्यतन 2014: C # 6 में एक नया ऑपरेटर है ?.जिसे 'सुरक्षित नेविगेशन' या 'अशक्त प्रचार' कहा जाता है।

parent?.child

Http://blogs.msdn.com/b/jerrynixon/archive/2014/02/26/at-last-c-is-getting-sometimes-called-the-safe-navigation-operator.aspx पढ़ें विवरण के लिए

यह लंबे समय से एक बेहद लोकप्रिय अनुरोध किया गया है https://visualstudio.uservoice.com/forums/121579-visual-studio/suggestions/3990187-add-operator-to-c-?tracking_code=594c10a522f8e9bc987ee4a5e2c0b38d

Question 8

आप स्पष्ट रूप से अशक्त मोनाड की तलाश कर रहे हैं :

string result = new A().PropertyB.PropertyC.Value;

हो जाता है

string result = from a in new A()
                from b in a.PropertyB
                from c in b.PropertyC
                select c.Value;

यह रिटर्न null, यदि कोई भी अशक्त गुण शून्य है; अन्यथा, का मूल्य Value।

class A { public B PropertyB { get; set; } }
class B { public C PropertyC { get; set; } }
class C { public string Value { get; set; } }

LINQ विस्तार विधियाँ:

public static class NullableExtensions
{
    public static TResult SelectMany<TOuter, TInner, TResult>(
        this TOuter source,
        Func<TOuter, TInner> innerSelector,
        Func<TOuter, TInner, TResult> resultSelector)
        where TOuter : class
        where TInner : class
        where TResult : class
    {
        if (source == null) return null;
        TInner inner = innerSelector(source);
        if (inner == null) return null;
        return resultSelector(source, inner);
    }
}

Question 9

मान लें कि आपके पास एक प्रकार के रिक्त मान हैं, यह होगा:

var x = (((objectA ?? A.Empty).PropertyOfB ?? B.Empty).PropertyOfC ?? C.Empty).PropertyOfString;

मैं C # का बहुत बड़ा प्रशंसक हूं, लेकिन नए जावा (1.7?) में बहुत अच्छी बात है? ऑपरेटर:

 var x = objectA.?PropertyOfB.?PropertyOfC.?PropertyOfString;

Question 10

यह कोड "कम से कम राशि का कोड" है, लेकिन सबसे अच्छा अभ्यास नहीं:

try
{
    return ObjectA.PropertyA.PropertyB.PropertyC;
}
catch(NullReferenceException)
{
     return null;
}

Question 11

जब मुझे उस तरह से कॉल करने की आवश्यकता होती है, तो मैं एक सहायक विधि पर भरोसा करता हूं जिसे मैंने बनाया, TryGet ():

    public static U TryGet<T, U>(this T obj, Func<T, U> func)
    {
        return obj.TryGet(func, default(U));
    }

    public static U TryGet<T, U>(this T obj, Func<T, U> func, U whenNull)
    {
        return obj == null ? whenNull : func(obj);
    }

आपके मामले में, आप इसका इस तरह उपयोग करेंगे:

    int value = ObjectA
        .TryGet(p => p.PropertyA)
        .TryGet(p => p.PropertyB)
        .TryGet(p => p.PropertyC, defaultVal);

Question 12

मैंने नए C # 6.0 में कुछ देखा, यह 'का उपयोग करके है?' बजाय जाँच के

उदाहरण के लिए उपयोग करने के बजाय

if (Person != null && Person.Contact!=null && Person.Contact.Address!= null && Person.Contact.Address.City != null)
{ 
  var city = person.contact.address.city;
}

आप बस उपयोग करें

var city = person?.contact?.address?.city;

मुझे उम्मीद है कि इसने किसी की मदद की।

अपडेट करें:

अब आप ऐसा कर सकते हैं

 var city = (Person != null)? 
           ((Person.Contact!=null)? 
              ((Person.Contact.Address!= null)?
                      ((Person.Contact.Address.City!=null)? 
                                 Person.Contact.Address.City : null )
                       :null)
               :null)
            : null;

Question 13

आप ऐसा कर सकते हैं:

class ObjectAType
{
    public int PropertyC
    {
        get
        {
            if (PropertyA == null)
                return 0;
            if (PropertyA.PropertyB == null)
                return 0;
            return PropertyA.PropertyB.PropertyC;
        }
    }
}



if (ObjectA != null)
{
    int value = ObjectA.PropertyC;
    ...
}

या इससे भी बेहतर हो सकता है:

private static int GetPropertyC(ObjectAType objectA)
{
    if (objectA == null)
        return 0;
    if (objectA.PropertyA == null)
        return 0;
    if (objectA.PropertyA.PropertyB == null)
        return 0;
    return objectA.PropertyA.PropertyB.PropertyC;
}


int value = GetPropertyC(ObjectA);

Question 14

आप निम्नलिखित एक्सटेंशन का उपयोग कर सकते हैं और मुझे लगता है कि यह वास्तव में अच्छा है:

/// <summary>
/// Simplifies null checking
/// </summary>
public static TR Get<TF, TR>(TF t, Func<TF, TR> f)
    where TF : class
{
    return t != null ? f(t) : default(TR);
}

/// <summary>
/// Simplifies null checking
/// </summary>
public static TR Get<T1, T2, TR>(T1 p1, Func<T1, T2> p2, Func<T2, TR> p3)
    where T1 : class
    where T2 : class
{
    return Get(Get(p1, p2), p3);
}

/// <summary>
/// Simplifies null checking
/// </summary>
public static TR Get<T1, T2, T3, TR>(T1 p1, Func<T1, T2> p2, Func<T2, T3> p3, Func<T3, TR> p4)
    where T1 : class
    where T2 : class
    where T3 : class
{
    return Get(Get(Get(p1, p2), p3), p4);
}

और इसका उपयोग इस तरह किया जाता है:

int value = Nulify.Get(objectA, x=>x.PropertyA, x=>x.PropertyB, x=>x.PropertyC);

Question 15

मैं Nulla प्रकार के समान पैटर्न का उपयोग करके संपत्ति के प्रकार (या यदि आपके प्रकार नहीं है तो एक विस्तार विधि) में अपनी खुद की विधि लिखूंगा।

class PropertyAType
{
   public PropertyBType PropertyB {get; set; }

   public PropertyBType GetPropertyBOrDefault()
   {
       return PropertyB != null ? PropertyB : defaultValue;
   }
}

Question 16

बस इस पद के लिए ठोकर खाई।

कुछ समय पहले मैंने एक नए ???ऑपरेटर को जोड़ने के बारे में विज़ुअल स्टूडियो कनेक्ट पर एक सुझाव दिया था ।

http://visualstudio.uservoice.com/forums/121579-visual-studio/suggestions/4104392-add-as-an-recursive-null-reference-check-opera

इसके लिए फ्रेमवर्क टीम से कुछ काम की आवश्यकता होगी लेकिन भाषा को बदलने की जरूरत नहीं है, लेकिन बस कुछ संकलक जादू करें। विचार यह था कि संकलक को इस कोड को बदलना चाहिए (सिंटैक्स को एटीएम की अनुमति नहीं है)

string product_name = Order.OrderDetails[0].Product.Name ??? "no product defined";

इस कोड में

Func<string> _get_default = () => "no product defined"; 
string product_name = Order == null 
    ? _get_default.Invoke() 
    : Order.OrderDetails[0] == null 
        ? _get_default.Invoke() 
        : Order.OrderDetails[0].Product == null 
            ? _get_default.Invoke() 
            : Order.OrderDetails[0].Product.Name ?? _get_default.Invoke()

अशक्त जाँच के लिए ऐसा लग सकता है

bool isNull = (Order.OrderDetails[0].Product ??? null) == null;

Question 17

मैंने एक विधि लिखी है जो एक डिफ़ॉल्ट मान को स्वीकार करता है, यहाँ इसका उपयोग कैसे किया जाए:

var teacher = new Teacher();
return teacher.GetProperty(t => t.Name);
return teacher.GetProperty(t => t.Name, "Default name");

यहाँ कोड है:

public static class Helper
{
    /// <summary>
    /// Gets a property if the object is not null.
    /// var teacher = new Teacher();
    /// return teacher.GetProperty(t => t.Name);
    /// return teacher.GetProperty(t => t.Name, "Default name");
    /// </summary>
    public static TSecond GetProperty<TFirst, TSecond>(this TFirst item1,
        Func<TFirst, TSecond> getItem2, TSecond defaultValue = default(TSecond))
    {
        if (item1 == null)
        {
            return defaultValue;
        }

        return getItem2(item1);
    }
}

Question 18

यह संभव नहीं है।
ObjectA.PropertyA.PropertyBविफल हो जाएगा यदि ObjectAअशक्त डेरेफेरिंग के कारण अशक्त है, जो एक त्रुटि है।

if(ObjectA != null && ObjectA.PropertyA... लघु सर्किटिंग के कारण काम करता है, यानी ObjectA.PropertyAअगर जाँच की जा कभी नहीं होगा ObjectAहै null।

पहला तरीका जो आप प्रस्तावित करते हैं वह इरादे के साथ सबसे अच्छा और सबसे स्पष्ट है। अगर कुछ भी आप इतने सारे nulls पर भरोसा किए बिना नया स्वरूप देने की कोशिश कर सकते हैं।

Question 19

एक बार मेमने के बड़े होने पर यह दृष्टिकोण बहुत सीधा होता है:

public static TProperty GetPropertyOrDefault<TObject, TProperty>(this TObject model, Func<TObject, TProperty> valueFunc)  
                                                        where TObject : class
    {
        try
        {
            return valueFunc.Invoke(model);
        }
        catch (NullReferenceException nex)
        {
            return default(TProperty);
        }
    }

उपयोग के साथ ऐसा लग सकता है:

ObjectA objectA = null;

Assert.AreEqual(0,objectA.GetPropertyOrDefault(prop=>prop.ObjectB.ObjectB.ObjectC.ID));

Assert.IsNull(objectA.GetPropertyOrDefault(prop => prop.ObjectB));

Question 20

var result = nullableproperty ?? defaultvalue;

??(शून्य-वालों ऑपरेटर) का अर्थ है यदि पहला तर्क है null, दूसरा एक के बजाय वापस जाएँ।