C # cách tốt để kiểm tra xem thuộc tính của một thuộc tính có rỗng không

Trong C #, giả sử rằng bạn muốn lấy một giá trị của PropertyC trong ví dụ này và ObjectA, PropertyA và PropertyB đều có thể là rỗng.

Đối tượngA.PropertyA.PropertyB.PropertyC

Làm cách nào tôi có thể nhận được PropertyC một cách an toàn với số lượng mã ít nhất?

Ngay bây giờ tôi sẽ kiểm tra:

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

Sẽ rất tuyệt nếu làm một cái gì đó giống như thế này hơn (mã giả).

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

Thậm chí có thể sụp đổ hơn nữa với một toán tử kết hợp không.

CHỈNH SỬA Ban đầu tôi nói ví dụ thứ hai của tôi giống như js, nhưng tôi đã đổi nó thành mã psuedo vì nó được chỉ ra một cách chính xác rằng nó sẽ không hoạt động trong js.

Trong C # 6, bạn có thể sử dụng Toán tử Điều kiện Null . Vì vậy, thử nghiệm ban đầu sẽ là:

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

Phương pháp gia hạn ngắn:

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

Sử dụng

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

Phương pháp mở rộng đơn giản này và nhiều hơn nữa bạn có thể tìm thấy trên http://devtalk.net/csharp/chained-null-checks-and-the-maybe-monad/

BIÊN TẬP:

Sau khi sử dụng nó trong giây lát, tôi nghĩ tên riêng cho phương thức này phải là IfNotNull () thay vì With () ban đầu.

Bạn có thể thêm một phương thức vào lớp của mình không? Nếu chưa, bạn đã nghĩ đến việc sử dụng các phương pháp mở rộng chưa? Bạn có thể tạo một phương thức mở rộng cho loại đối tượng của bạn được gọi là GetPropC().

Thí dụ:

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

Sử dụng:

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

Nhân tiện, điều này giả sử bạn đang sử dụng .NET 3 trở lên.

Cách bạn đang làm là đúng.

Bạn có thể sử dụng một thủ thuật như được mô tả ở đây , sử dụng biểu thức Linq:

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

Nhưng việc kiểm tra thủ công từng thuộc tính chậm hơn nhiều ...

Refactor để tuân theo Định luật Demeter

Cập nhật 2014: C # 6 có một toán tử mới ?.khác nhau được gọi là 'điều hướng an toàn' hoặc 'truyền dẫn null'

parent?.child

Đọc http://blogs.msdn.com/b/jerrynixon/archive/2014/02/26/at-last-c-is-getting-sometimes-called-the-safe-navigation-operator.aspx để biết chi tiết

Đây từ lâu đã là một yêu cầu cực kỳ phổ biến https://visualstudio.uservoice.com/forums/121579-visual-studio/suggestions/3990187-add-operator-to-c-?tracking_code=594c10a522f8e9bc987ee4a5e2c0b38d

Rõ ràng là bạn đang tìm kiếm Nullable Monad :

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

trở thành

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

Điều này trả về null, nếu bất kỳ thuộc tính nullable nào là null; nếu không, giá trị của Value.

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

Các phương thức mở rộng 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);
    }
}

Giả sử bạn có các giá trị trống của các loại, một cách tiếp cận sẽ là:

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

Tôi là một fan hâm mộ lớn của C # nhưng một điều rất hay trong Java mới (1.7?) Là.? nhà điều hành:

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

Mã này là "số lượng mã ít nhất", nhưng không phải là phương pháp hay nhất:

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

Khi tôi cần chuỗi các cuộc gọi như vậy, tôi dựa vào phương thức trợ giúp mà tôi đã tạo, 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);
    }

Trong trường hợp của bạn, bạn sẽ sử dụng nó như vậy:

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

Tôi đã thấy một cái gì đó trong C # 6.0 mới, đây là bằng cách sử dụng '?' thay vì kiểm tra

ví dụ thay vì sử dụng

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

bạn chỉ cần sử dụng

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

Tôi hy vọng nó đã giúp ai đó.

CẬP NHẬT:

Bạn có thể làm như thế này bây giờ

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

Bạn có thể làm điều này:

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

Hoặc thậm chí tốt hơn có thể là thế này:

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

bạn có thể sử dụng tiện ích mở rộng sau và tôi nghĩ nó thực sự tốt:

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

Và nó được sử dụng như thế này:

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

Tôi sẽ viết phương thức của riêng bạn trong kiểu PropertyA (hoặc một phương thức mở rộng nếu nó không phải là kiểu của bạn) bằng cách sử dụng mẫu tương tự với kiểu Nullable.

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

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

Chỉ tình cờ qua bài viết này.

Cách đây một thời gian, tôi đã đưa ra đề xuất trên Visual Studio Connect về việc thêm một ???toán tử mới .

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

Điều này sẽ yêu cầu một số công việc từ nhóm khung nhưng không cần thay đổi ngôn ngữ mà chỉ cần thực hiện một số phép thuật biên dịch. Ý tưởng là trình biên dịch nên thay đổi mã này (cú pháp không được phép atm)

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

vào mã này

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

Đối với kiểm tra null, điều này có thể trông giống như

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

Tôi đã viết một phương thức chấp nhận một giá trị mặc định, đây là cách sử dụng nó:

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

Đây là mã:

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

Điều đó là không thể.
ObjectA.PropertyA.PropertyBsẽ không thành công nếu ObjectAlà null do không tham chiếu, đó là một lỗi.

if(ObjectA != null && ObjectA.PropertyA... hoạt động do đoản mạch, tức là ObjectA.PropertyAsẽ không bao giờ được kiểm tra nếu ObjectAcó null.

Cách đầu tiên bạn đề xuất là tốt nhất và rõ ràng nhất với ý định. Nếu bất cứ điều gì bạn có thể cố gắng thiết kế lại mà không cần phải dựa vào quá nhiều null.

Cách tiếp cận này khá dễ hiểu khi bạn vượt qua lambda gobbly-gook:

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

Với cách sử dụng có thể trông giống như:

ObjectA objectA = null;

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

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

var result = nullableproperty ?? defaultvalue;

Các ??(nhà điều hành null-coalescing) có nghĩa là nếu đối số đầu tiên là null, trả lại một giây để thay thế.