如何使用官方的MongoDB CSharp驱动程序将条件运算符动态应用于字段

本文关键字：条件运算符 动态 应用于 字段 驱动程序 CSharp 何使用 官方 MongoDB | 更新日期: 2023-09-27 18:20:34

我正在尝试生成一个查询，该查询查找所有开销大于3的大型红色事物。

这个查询似乎就是我想要的：

{ "color" : "red", "size" : "large", "cost" : { "$gt" : 3.0 } }

但是，我无法找到一种使用官方MongoDB CSharp驱动程序创建成本条件的优雅方法。这是一个似乎创建查询的黑客：

QueryConditionList gt = Query.GT("cost", BsonDouble.Create(3));
QueryDocument query = new QueryDocument();
query.Add("color", "red");
query.Add("size", "large");
query.Add(gt.ToBsonDocument().Elements);
List<BsonDocument> results = events.Find(query).ToList();

另一种似乎有效的方法是这样的：

QueryDocument query = new QueryDocument();
query.Add("color", "red");
query.Add("size", "large");
query.Add("cost", new BsonDocument("$gt", BsonDouble.Create(3)));
List<BsonDocument> results = events.Find(query).ToList();

这两种方法中的任何一种都是实现这一目标的好方法吗？还有别的吗？

我需要使用允许我动态构建查询并添加将涉及查询的字段的技术。我希望找到一种通过查询添加条件的方法。添加（），但我不知道这是否可能。

感谢您的帮助。

如何使用官方的MongoDB CSharp驱动程序将条件运算符动态应用于字段

您可以全程使用查询生成器，如下所示：

var query = Query.And(
              Query.EQ("color", "red"), 
              Query.EQ("size", "large"), 
              Query.GT("cost", 3)
            );

更新对不起，我明白你在问什么了。

你也可以这样做：

int i = 0;
var qc = QueryComplete[3];
qc[i++] = Query.EQ("color", "red");
qc[i++] = Query.EQ("size", "large");
qc[i++] = Query.GT("cost", 3);
var query = Query.And(qc);

通过这种方式，您仍然可以使用构建器方法，并使其成为动态的。

您可以以暴力的方式对其进行数据驱动，只需构建一个"QueryElement"树并调用BuildQuery以递归方式构建它，如本示例类所示：

    public class QueryElement
    {
        public enum eOperator
        {
            AND, OR, EQ, NE, GT, GTE, LT, LTE      //etc.
        };
        public eOperator Operator { get; set; }
        public string Field { get; set; }
        public BsonValue Value { get; set; }
        public List<QueryElement> Children { get; set; }
        public IMongoQuery BuildQuery()
        {
            int i = 0;
            var qc = new IMongoQuery[(Children!=null)?Children.Count:0];
            if (Children != null)
            {
                foreach (var child in Children)
                {
                    qc[i++] = child.BuildQuery();
                }
            }
            switch (Operator)
            {
                // multiple element operators
                case eOperator.AND:
                    return Query.And(qc);
                case eOperator.OR:
                    return Query.And(qc);
                // single element operators
                case eOperator.EQ:
                    return Query.EQ(Field, Value);
                case eOperator.NE:
                    return Query.NE(Field, Value);
                case eOperator.GT:
                    return Query.GT(Field, Value);
                case eOperator.GTE:
                    return Query.GTE(Field, Value);
                case eOperator.LT:
                    return Query.LT(Field, Value);
                case eOperator.LTE:
                    return Query.LTE(Field, Value);
            }
            return null;
        }
    }
相关文章：