C# 检查所有浅层属性是否为空（或任何属性不为空）的优雅方法

Question

当我读到这个问题时 Deep Null checking, is there a better way?

还有这个

C# elegant way to check if a property's property is null

假设我要检查所有属性是否不为空，或者是否有任何属性不为空。（浅属性）

SearchCriteria 对象：

Keyword (Searches Name and Description) != null ||
SectorId != null ||
IndustryId != null ||
HasOption != null ||
HasFutures != null ||
30 properties to go...

正如我们所见，语法有点难以阅读。我想要类似的东西

SearchCriteria
.Has(criteria => criteria.Keywork)
.Has(criteria => criteria.SectorId)
.Has(criteria => criteria.HasOption)
.etc

（如果我们希望以上所有属性都不为空）

或

SearchCriteria
.Has(criteria => criteria.Keywork).Or()
.Has(criteria => criteria.SectorId).Or()
.Has(criteria => criteria.HasOption).Or()
.etc

（如果我们想要任何属性不为空）

或

SearchCriteria
.Has(criteria => criteria.Keywork).Or()
.Has(criteria => criteria.SectorId)
.Has(criteria => criteria.HasOption)
.etc

（如果我们希望关键字或 SectorId 有值并且 HasOption 有值。

那么，我们在 codeplex 上是否有任何现成的项目？或者任何可以结合深空检查和浅空检查的优雅方法？

Answer 1

坦率地说，我会坚持使用涉及|| 或&&、== null 或!= null 的简单版本。它直接有效，并允许立即短路。如果您打算这样做lots，您也许可以编写一个使用元编程（Expression 或 ILGenerator 可能）的实用程序类来为每个类型创建一个优化的方法来检查所有属性，然后：

if(MyHelper.AllNull(obj)) ... // note this is probably actually generic

完整示例：

using System;
using System.Linq.Expressions;
using System.Reflection;

static class Program
{
    static void Main()
    {
        bool x = MyHelper.AnyNull(new Foo { }); // true
        bool y = MyHelper.AnyNull(new Foo { X = "" }); // false
    }
}
class Foo
{
    public string X { get; set; }
    public int Y { get; set; }
}
static class MyHelper
{
    public static bool AnyNull<T>(T obj)
    {
        return Cache<T>.AnyNull(obj);
    }
    static class Cache<T>
    {
        public static readonly Func<T, bool> AnyNull;

        static Cache()
        {
            var props = typeof(T).GetProperties(
                BindingFlags.Instance | BindingFlags.Public);

            var param = Expression.Parameter(typeof(T), "obj");
            Expression body = null;

            foreach(var prop in props)
            {
                if (!prop.CanRead) continue;

                if(prop.PropertyType.IsValueType)
                {
                    Type underlyingType = Nullable.GetUnderlyingType(
                                              prop.PropertyType);
                    if (underlyingType == null) continue; // cannot be null

                    // TODO: handle Nullable<T>
                }
                else
                {
                    Expression check = Expression.Equal(
                        Expression.Property(param, prop),
                        Expression.Constant(null, prop.PropertyType));
                    body = body == null ? check : Expression.OrElse(body, check);
                }
            }
            if (body == null) AnyNull = x => false; // or true?
            else
            {
                AnyNull = Expression.Lambda<Func<T, bool>>(body, param).Compile();
            }
        }
    }
}

Answer 2

虽然我确实支持 Marc Gravell 的回答，只是将其完整地写出来，但如果您坚持不重复 != null，则不需要创建任何自定义方法。 LINQ 方法已经可以做你想做的事，例如：

new[] { SearchCriteria }.SelectMany(criteria => new object[] {
  criteria.Keywork,
  criteria.SectorId,
  criteria.HasOption,
  ...
}).Any(p => p != null)

为了还涵盖SearchCriteria 本身可能是null 的情况，您可以使用

new[] { SearchCriteria }.Where(criteria => criteria != null).SelectMany(...