使用此（基于扩展方法）速记的可能陷阱

时间：2008-09-23 19:05:46

标签： c# .net-3.5 extension-methods

C＃6更新

在C#6 ?. is now a language feature中：

// C#1-5
propertyValue1 = myObject != null ? myObject.StringProperty : null; 

// C#6
propertyValue1 = myObject?.StringProperty;

以下问题仍适用于旧版本，但如果使用新的?.运算符开发新应用程序则更好。

原始问题：

我经常想要访问可能为空的对象的属性：

string propertyValue1 = null;
if( myObject1 != null )
    propertyValue1 = myObject1.StringProperty;

int propertyValue2 = 0;
if( myObject2 != null )
    propertyValue2 = myObject2.IntProperty;

等等......

我经常使用它，因此我有一个代码片段。

如果符合以下条件，您可以在某种程度上缩短此内容：

propertyValue1 = myObject != null ? myObject.StringProperty : null;

然而，这有点笨重，特别是如果设置大量属性或多个级别可以为null，例如：

propertyValue1 = myObject != null ? 
    (myObject.ObjectProp != null ? myObject.ObjectProp.StringProperty) : null : null;

我真正想要的是??样式语法，它适用于直接空类型：

int? i = SomeFunctionWhichMightReturnNull();
propertyValue2 = i ?? 0;

所以我想出了以下内容：

public static TResult IfNotNull<T, TResult>( this T input, Func<T, TResult> action, TResult valueIfNull )
    where T : class
{
    if ( input != null ) return action( input );
    else return valueIfNull;
}

//lets us have a null default if the type is nullable
public static TResult IfNotNull<T, TResult>( this T input, Func<T, TResult> action )
    where T : class
    where TResult : class
{ return input.IfNotNull( action, null ); }

这让我用这句语法：

propertyValue1 = myObject1.IfNotNull( x => x.StringProperty );
propertyValue2 = myObject2.IfNotNull( x => x.IntProperty, 0);

//or one with multiple levels
propertyValue1 = myObject.IfNotNull( 
    o => o.ObjectProp.IfNotNull( p => p.StringProperty ) );

这简化了这些调用，但我不确定是否检查了这种扩展方法 - 它确实使代码更容易阅读，但代价是扩展对象。这将出现在所有内容上，尽管我可以将它放在一个专门引用的命名空间中。

这个例子很简单，比较两个可以为空的对象属性稍微复杂一点：

if( ( obj1 == null && obj2 == null ) || 
    ( obj1 != null && obj2 != null && obj1.Property == obj2.Property ) )
    ...

//becomes
if( obj1.NullCompare( obj2, (x,y) => x.Property == y.Property ) 
    ...

以这种方式使用扩展有哪些陷阱？其他编码员可能会感到困惑吗？这只是滥用扩展吗？

我想我真正想要的是编译器/语言扩展：

propertyValue1 = myObject != null ? myObject.StringProperty : null;

//becomes
propertyValue1 = myObject?StringProperty;

这将使复杂的案例变得更加容易：

propertyValue1 = myObject != null ? 
    (myObject.ObjectProp != null ? myObject.ObjectProp.StringProperty) : null

//becomes
propertyValue1 = myObject?ObjectProp?StringProperty;

这只适用于值类型，但您可以返回可以为空的等价物：

int? propertyValue2 = myObject?ObjectProp?IntProperty;

//or

int propertyValue3 = myObject?ObjectProp?IntProperty ?? 0;

11 个答案:

答案 0 :(得分：16)

我们独立提出了完全相同的扩展方法名称和实现：Null-propagating extension method。因此，我们认为这不会令人困惑或滥用扩展方法。

我会用链接编写你的“多级”示例，如下所示：

propertyValue1 = myObject.IfNotNull(o => o.ObjectProp).IfNotNull(p => p.StringProperty);

有一个now-closed bug on Microsoft Connect建议“？”。作为执行此空传播的新C＃运算符。 Mads Torgersen（来自C＃语言团队）简要解释了为什么他们不会实现它。

答案 1 :(得分：15)

这是针对链式成员的另一种解决方案，包括扩展方法：

public static U PropagateNulls<T,U> ( this T obj
                                     ,Expression<Func<T,U>> expr) 
{  if (obj==null) return default(U);

   //uses a stack to reverse Member1(Member2(obj)) to obj.Member1.Member2 
   var members = new Stack<MemberInfo>();

   bool       searchingForMembers = true;
   Expression currentExpression   = expr.Body;

   while (searchingForMembers) switch (currentExpression.NodeType)
    { case ExpressionType.Parameter: searchingForMembers = false; break;

           case ExpressionType.MemberAccess:    
           { var ma= (MemberExpression) currentExpression;
             members.Push(ma.Member);
             currentExpression = ma.Expression;         
           } break;     

          case ExpressionType.Call:
          { var mc = (MethodCallExpression) currentExpression;
            members.Push(mc.Method);

           //only supports 1-arg static methods and 0-arg instance methods
           if (   (mc.Method.IsStatic && mc.Arguments.Count == 1) 
               || (mc.Arguments.Count == 0))
            { currentExpression = mc.Method.IsStatic ? mc.Arguments[0]
                                                     : mc.Object; 
              break;
            }

           throw new NotSupportedException(mc.Method+" is not supported");
         } 

        default: throw new NotSupportedException
                        (currentExpression.GetType()+" not supported");
  }

   object currValue = obj;
   while(members.Count > 0)
    { var m = members.Pop();

      switch(m.MemberType)
       { case MemberTypes.Field:
           currValue = ((FieldInfo) m).GetValue(currValue); 
           break;

         case MemberTypes.Method:
           var method = (MethodBase) m;
           currValue = method.IsStatic
                              ? method.Invoke(null,new[]{currValue})
                              : method.Invoke(currValue,null); 
           break;

         case MemberTypes.Property:
           var method = ((PropertyInfo) m).GetGetMethod(true);
                currValue = method.Invoke(currValue,null);
           break;

       }     

      if (currValue==null) return default(U);   
    }

   return (U) currValue;    
}

然后你可以在任何可以为null或none的情况下执行此操作：

foo.PropagateNulls(x => x.ExtensionMethod().Property.Field.Method());

答案 2 :(得分：11)

如果您发现自己必须经常检查对象的引用是否为空，那么您可能应该使用Null Object Pattern。在这种模式中，不是使用null来处理没有对象的情况，而是实现一个具有相同接口但具有返回足够默认值的方法和属性的新类。

答案 3 :(得分：5)

怎么样

propertyValue1 = myObject.IfNotNull(o => o.ObjectProp.IfNotNull( p => p.StringProperty ) );

比

更容易阅读和书写 
if(myObject != null && myObject.ObjectProp != null)
    propertyValue1 = myObject.ObjectProp.StringProperty;

Jafar Husain发布了一个使用表达式树来检查链中的空值Runtime macros in C# 3的样本。

这显然有性能影响。现在，如果我们在编译时有办法做到这一点。

答案 4 :(得分：5)

我只想说我喜欢这个黑客！

我没有意识到扩展方法并不意味着空检查，但它完全有意义。正如詹姆斯指出的那样，扩展方法调用本身并不比普通方法贵，但是如果你正在做大量的事情，那么遵循Njor对象模式是有意义的，ljorquera建议。或者使用null对象和??在一起。

class Class1
{
    public static readonly Class1 Empty = new Class1();
.
.
x = (obj1 ?? Class1.Empty).X;

答案 5 :(得分：1)

  

它确实使代码更容易阅读，但代价是扩展对象。这将出现在所有事情上，

请注意，您实际上并未扩展任何内容（理论上除外）。

propertyValue2 = myObject2.IfNotNull( x => x.IntProperty, 0);

将生成IL代码，就像编写它一样：

ExtentionClass::IfNotNull(myObject2,  x => x.IntProperty, 0);

没有为对象添加“开销”以支持此功能。

答案 6 :(得分：1)

对于不知道的读者来说，看起来你正在调用null引用上的方法。如果你想要这个，我建议把它放在一个实用程序类中，而不是使用扩展方法：


propertyValue1 = Util.IfNotNull(myObject1, x => x.StringProperty );
propertyValue2 = Util.IfNotNull(myObject2, x => x.IntProperty, 0);

“Util。”格里特，但IMO是较小的句法邪恶。

此外，如果您将此作为团队的一部分进行开发，请轻轻地询问其他人的想法和行为。跨代码库对于常用模式的一致性非常重要。

答案 7 :(得分：1)

虽然扩展方法在从null实例调用时通常会引起误解，但我认为在这种情况下意图非常简单。

string x = null;
int len = x.IfNotNull(y => y.Length, 0);

我想确保这个静态方法适用于可以为null的值类型，例如int？

编辑：编译器说这些都不是有效的：

    public void Test()
    {
        int? x = null;
        int a = x.IfNotNull(z => z.Value + 1, 3);
        int b = x.IfNotNull(z => z.Value + 1);
    }

除此之外，去吧。

答案 8 :(得分：1)

不是问题的答案，但是 Null-Conditional Operator in C# 6.0。我可以说，自从C＃6.0以来在OP中使用该选项将是一个糟糕的选择：）

所以你的表达更简单，

string propertyValue = myObject?.StringProperty;

如果myObject为null，则返回null。如果属性是值类型，则必须使用等效的可空类型，例如

int? propertyValue = myObject?.IntProperty;

否则，您可以与null合并运算符合并，以便在null的情况下给出默认值。例如，

int propertyValue = myObject?.IntProperty ?? 0;

?.不是唯一可用的语法。对于索引属性，您可以使用?[..]。例如，

string propertyValue = myObject?[index]; //returns null in case myObject is null

?.运算符的一个令人惊讶的行为是，如果对象恰好为null，它可以智能地绕过后续的.Member调用。链接中给出了一个这样的例子：

var result = value?.Substring(0, Math.Min(value.Length, length)).PadRight(length);

如果result为空且value表达式不会导致value.Length，则NullReferenceException为空。

答案 9 :(得分：0)

就个人而言，即使在你所有的解释之后，我也记不起这是怎么回事：

if( obj1.NullCompare( obj2, (x,y) => x.Property == y.Property )

这可能是因为我没有C＃经验;但是，我可以阅读并理解代码中的其他所有内容。我更喜欢保持代码语言不可知（特别是对于琐碎的事情），以便明天，另一个开发人员可以将其更改为一种全新的语言，而不需要太多关于现有语言的信息。

答案 10 :(得分：0)

这是使用myObject.NullSafe（x =＆gt; x.SomeProperty.NullSafe（x =＆gt; x.SomeMethod））的另一个解决方案，解释于 http://www.epitka.blogspot.com/

相关问题
最新问题