生成具有运行时指定返回类型的多参数 LINQ 搜索查询

解决方案

首先，我们创建：

public abstract class SearchQuery 
{
    public Type ResultType { get; set; }
    public SearchQuery(Type searchResultType)
    {
        ResultType = searchResultType;
    }
}

我们还将创建上面用于定义搜索字段的属性：

    protected class Comparison : Attribute
    {
        public ExpressionType Type;
        public Comparison(ExpressionType type)
        {
            Type = type;
        }
    }
    protected class LinkedField : Attribute
    {
        public string TargetField;
        public LinkedField(string target)
        {
            TargetField = target;
        }
    }

对于每个搜索字段，我们不仅需要知道进行了哪些搜索，还需要知道搜索是否完成。例如，如果"TxNumber"的值为 null，则我们不希望运行该搜索。 因此，我们创建了一个 SearchField 对象，除了实际的搜索值外，它还包含两个表达式：一个表示执行搜索，另一个用于验证是否应应用搜索。

    private class SearchFilter<T>
    {
        public Expression<Func<object, bool>> ApplySearchCondition { get; set; }
        public Expression<Func<T, bool>> SearchExpression { get; set; }
        public object SearchValue { get; set; }
        public IQueryable<T> Apply(IQueryable<T> query)
        {
            //if the search value meets the criteria (e.g. is not null), apply it; otherwise, just return the original query.
            bool valid = ApplySearchCondition.Compile().Invoke(SearchValue);
            return valid ? query.Where(SearchExpression) : query;
        }
    }

创建所有过滤器后，我们需要做的就是遍历它们并在数据集上调用"应用"方法！容易！

下一步是创建验证表达式。我们将根据类型执行此操作;每个整数？验证是否与其他所有 int 相同？

    private static Expression<Func<object, bool>> GetValidationExpression(Type type)
    {
        //throw exception for non-nullable types (strings are nullable, but is a reference type and thus has to be called out separately)
        if (type != typeof(string) && !(type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>)))
            throw new Exception("Non-nullable types not supported.");
        //strings can't be blank, numbers can't be 0, and dates can't be minvalue
        if (type == typeof(string   )) return t => !string.IsNullOrWhiteSpace((string)t);
        if (type == typeof(int?     )) return t => t != null && (int)t >= 0;
        if (type == typeof(decimal? )) return t => t != null && (decimal)t >= decimal.Zero;
        if (type == typeof(DateTime?)) return t => t != null && (DateTime?)t != DateTime.MinValue;
        //everything else just can't be null
        return t => t != null;
    }

这就是我的应用程序所需要的全部内容，但肯定还有更多的验证可以完成。

搜索表达式稍微复杂一些，需要一个解析器来"取消限定"字段/属性名称(可能有更好的词，但如果是这样，我不知道(。 基本上，如果我指定"Order.Customer.Name"作为链接字段并且我正在搜索订单，我需要将其转换为"Customer.Name"，因为订单对象中没有订单字段。 或者至少我希望不是。 :)这并不确定，但我认为接受和更正完全限定的对象名称比支持该边缘情况更好。

    public static List<string> DeQualifyFieldName(string targetField, Type targetType)
    {
        var r = targetField.Split('.').ToList();
        foreach (var p in targetType.Name.Split('.'))
            if (r.First() == p) r.RemoveAt(0);
        return r;
    }

这只是直接文本解析，并在"级别"中返回字段名称(例如"客户"|"名称"(。

好吧，让我们一起讨论我们的搜索表达式。

    private Expression<Func<T, bool>> GetSearchExpression<T>(
        string targetField, ExpressionType comparison, object value)
    {
        //get the property or field of the target object (ResultType)
        //which will contain the value to be checked
        var param = Expression.Parameter(ResultType, "t");
        Expression left = null;
        foreach (var part in DeQualifyFieldName(targetField, ResultType))
            left = Expression.PropertyOrField(left == null ? param : left, part);
        //Get the value against which the property/field will be compared
        var right = Expression.Constant(value);
        //join the expressions with the specified operator
        var binaryExpression = Expression.MakeBinary(comparison, left, right);
        return Expression.Lambda<Func<T, bool>>(binaryExpression, param);
    }

还不错！例如，我们尝试创建的是：

t => t.Customer.Name == "Searched Name"

其中 t 是我们的 ReturnType——在本例中为 Order。首先，我们创建参数 t。 然后，我们遍历属性/字段名称的各个部分，直到我们获得目标对象的完整标题(将其命名为"left"，因为它是我们比较的左侧(。 我们比较的"正确"方面很简单：用户提供的常量。

然后我们创建二进制表达式并将其转换为 lambda。就像从原木上掉下来一样容易！无论如何，如果从日志上掉下来需要无数小时的挫败感和失败的方法。但我离题了。

我们现在有了所有的部分;我们所需要的只是一种组装查询的方法：

    protected IQueryable<T> ApplyFilters<T>(IQueryable<T> data)
    {
        if (data == null) return null;
        IQueryable<T> retVal = data.AsQueryable();
        //get all the fields and properties that have search attributes specified
        var fields = GetType().GetFields().Cast<MemberInfo>()
                              .Concat(GetType().GetProperties())
                              .Where(f => f.GetCustomAttribute(typeof(LinkedField)) != null)
                              .Where(f => f.GetCustomAttribute(typeof(Comparison)) != null);
        //loop through them and generate expressions for validation and searching
        try
        {
            foreach (var f in fields)
            {
                var value = f.MemberType == MemberTypes.Property ? ((PropertyInfo)f).GetValue(this) : ((FieldInfo)f).GetValue(this);
                if (value == null) continue;
                Type t = f.MemberType == MemberTypes.Property ? ((PropertyInfo)f).PropertyType : ((FieldInfo)f).FieldType;
                retVal = new SearchFilter<T>
                {
                    SearchValue = value,
                    ApplySearchCondition = GetValidationExpression(t),
                    SearchExpression = GetSearchExpression<T>(GetTargetField(f), ((Comparison)f.GetCustomAttribute(typeof(Comparison))).Type, value)
                }.Apply(retVal); //once the expressions are generated, go ahead and (try to) apply it
            }
        }
        catch (Exception ex) { throw (ErrorInfo = ex); }
        return retVal;
    }

基本上，我们只是获取派生类(链接的(中的字段/属性列表，从它们创建一个 SearchFilter 对象，然后应用它们。

清理

当然，还有更多。例如，我们使用字符串指定对象链接。如果有错别字怎么办？

就我而言，每当它启动派生类的实例时，我都会进行类检查，如下所示：

    private bool ValidateLinkedField(string fieldName)
    {
        //loop through the "levels" (e.g. Order / Customer / Name) validating that the fields/properties all exist
        Type currentType = ResultType;
        foreach (string currentLevel in DeQualifyFieldName(fieldName, ResultType))
        {
            MemberInfo match = (MemberInfo)currentType.GetField(currentLevel) ?? currentType.GetProperty(currentLevel);
            if (match == null) return false;
            currentType = match.MemberType == MemberTypes.Property ? ((PropertyInfo)match).PropertyType
                                                                   : ((FieldInfo)match).FieldType;
        }
        return true; //if we checked all levels and found matches, exit
    }

剩下的都是实施细节。如果您有兴趣查看它，可以在此处查看包含完整实现(包括测试数据(的项目。这是一个VS 2015项目，但如果这是一个问题，只需获取程序.cs和搜索.cs文件，并将它们放入您选择的IDE中的新项目中。

感谢 StackOverflow 上的每个人，他们提出了这些问题并写下了帮助我解决这个问题的答案！