c# - 在运行时使用 Serialize.Linq 编译表达式

Question

我正在尝试序列化和反序列化 Linq 查询。目前我正在使用 Serialize.Linq通过 json 序列化和反序列化 Linq 查询。像这样:

    public async Task StoreQuery<T>(string queriedTypeName, string queryName, Expression<Func<T, bool>> query, IEnumerable<T> results)
        where T : class, IStorable
    {

        var expressionSerializer = new ExpressionSerializer(new Serialize.Linq.Serializers.JsonSerializer());
        var queryJson = expressionSerializer.SerializeText(query);

        await storage.AddQuery(queriedTypeName + ".queries", queryJson, ...);
        //etc...
    }

如果我知道查询表达式要操作的类型，我就能够成功地反序列化查询:

    public static bool QueryWouldContain<T>(T storable, string queryJson)
        where T : class, IStorable
    {
            var queryStatement = expressionSerializer.DeserializeText(queryJson);
        var expressionType = queryStatement.ToExpressionNode().ToExpression<Func<T,bool>>().Compile();

        var objectBelongsInQueryResults = expressionType.Invoke(obj)
        return objectBelongsInQueryResults;
    }

但是，在这种情况下，我希望能够在运行时而不是编译时检测到该类型:

    public static async bool QueriesWouldContain<T>(IEnumerable<T> storables, List<string> queryStrings)
        where T : class, IStorable
    {

        foreach (var querystring in queryStrings)
        {
            var expressionSerializer = new ExpressionSerializer(new JsonSerializer());
            var queryStatement = expressionSerializer.DeserializeText(querystring);

            var expression = queryStatement.ToExpressionNode().ToExpression<Func<?, bool>>().Compile();

            foreach (var storable in storables)
            {
                if (isOfTypeMatchingQuery(storable, expression))
                {
                    var result = expression.Invoke(storable);

                    if (result == false)
                    {
                        return false;
                    }
                }
            }
            return true;
        }

有什么方法可以从表达式中获取操作的类型吗？如果是这样，有没有办法将该表达式转换为 Func？

Answer 1

您不必在调用 ToExpression 时指定泛型类型。只需测试它是否返回 LambdaExpression。

public static async bool QueriesWouldContain<T>(IEnumerable<T> storables, List<string> queryStrings)
    where T : class, IStorable
{

    foreach (var querystring in queryStrings)
    {
        var expressionSerializer = new ExpressionSerializer(new JsonSerializer());
        var queryStatement = expressionSerializer.DeserializeText(querystring);

        var expression = queryStatement.ToExpressionNode().ToExpression();
        if (!(expression is LambdaExpression lambdaExpression))
            continue; // TODO: or throw
        var d = lambdaExpression.Compile();
        foreach (var storable in storables)
        {
            if (isOfTypeMatchingQuery(storable, d))
            {
                var result = (bool)d.Invoke(storable);

                if (result == false)
                {
                    return false;
                }
            }
        }
        return true;
    }
}