Home Backend Development C#.Net Tutorial Extending QueryBuilder of MongoDB C# Driver

Extending QueryBuilder of MongoDB C# Driver

Feb 28, 2017 am 11:53 AM

Extending the MongoDB C# Driver's QueryBuilder

Since I don't want to directly hardcode strings like "ClassA.MemberA.MemberB", I wrote the following classes for the following common scenarios:
1. Convert expression to string function: ExpToStr()
2. Collection function: When there are collection members, you can use this class, which will return a QueryCollection object. The code of this class is appended
3. CollectionAs function: When inheritance is used, you want to convert the base class to a subclass and return the QueryCollection of the subclass
Usage example:

//获得表达式的字符串形式
1. QueryEx<ClassA>.ExpToStr ((ClassA m)=> m.MemberA.MemberB.MemberC)


//集合.成员.字段
//PoppedSegments为集合,AssignedNetwork.Name为成员
//将返回PoppedSegments.AssignedNetwork.Name
2. QueryEx<MDDelivery>.Collection(x => x.PoppedSegments).Matches(p => p.AssignedNetwork.Name, bsonRegex),


//子类集合.成员.字段
//STPaymentTransaction为基类,STPaymentCompanyCredit为子类,Company字段在子类中
//将返回Payments.Company.Name
3. QueryEx<MDDelivery>.CollectionAs<STPaymentTransaction, STPaymentCompanyCredit>(x=>x.Payments).Matches(p=>p.Company.Name, bsonRegex)


//集合.集合.成员.字段
//Parcels为集合,STCustomPropertyRuntime为基类,STNumericPropertyRuntime为子类,CustomProps为STNumericPropertyRuntime中成员,Value为CustomProp中成员
//将返回Parcels.CustomProps.Value
4. QueryEx<MDDelivery>.Collection(x=>x.Parcels).CollectionMemberAs<STCustomPropertyRuntime, STNumericPropertyRuntime>(p=>p.CustomProps).Matches(p=>p.Value, bsonRegex),
Copy after login


Implementation code:

public class QueryEx<TDocument>
    {
        public static QueryCollection<TDocument, TCollection> Collection<TCollection>(
            Expression<Func<TDocument, IEnumerable<TCollection>>> collectionExpression)
        {
            return new QueryCollection<TDocument, TCollection>(collectionExpression);
        }


        //for those cases using inheritance
        //e.g STPaymentTransaction
        //Payments will return STPaymentTransaction 
        //need to cast to sub classes(STPaymentCompanyCredit) so that be able to filter by child members (e.g. Company)
        public static QueryCollection<TDocument, TSub> CollectionAs<TCollection, TSub>(
            Expression<Func<TDocument, IEnumerable<TCollection>>> collectionExpression)
            where TSub : TCollection
        {
            var argParam = Expression.Parameter(typeof (TDocument), "x");
            var memberStr = ExpToStr(collectionExpression);
            MemberExpression nameProperty = Expression.Property(argParam, memberStr);


            var subExp = Expression.Convert(nameProperty, typeof(IEnumerable<TSub>));


            var exp = Expression.Lambda<Func<TDocument, IEnumerable<TSub>>>(
                subExp,
                argParam);


            return new QueryCollection<TDocument, TSub>(exp);
        }


        /// <summary>
        /// return string value for a expression:
        /// for s.Name.Val1.Val2 will return Name.Val1.Val2
        /// </summary>
        /// <typeparam name="MDClass"></typeparam>
        /// <typeparam name="Member"></typeparam>
        /// <param name="exp"></param>
        /// <returns></returns>
        public static string ExpToStr<TDocument, Member>(Expression<Func<TDocument, Member>> exp)
        {
            return new QueryExpressionHelper().MemberExpression(exp);
        }
    }








public class QueryCollection<TDocument, TCollection>
    {
        private readonly QueryExpressionHelper _queryExpression;
        private string _collectionName;


        public string Context
        {
            get { return _collectionName; }
        }


        public QueryCollection(Expression<Func<TDocument, IEnumerable<TCollection>>> collectionExpression)
        {
            _queryExpression = new QueryExpressionHelper();
            _collectionName = _queryExpression.MemberExpression(collectionExpression);
        }


        public QueryMember<TCollection, TMember> Member<TMember>(Expression<Func<TCollection, TMember>> exp)
        {
            var expStr = QueryEx<TCollection>.ExpToStr(exp);
            var context = string.Format("{0}.{1}", _collectionName, expStr);
            var obj = new QueryMember<TCollection, TMember>(context);


            return obj;
        }


        public QueryCollection<TCollection, TMember> CollectionMember<TMember>(
            Expression<Func<TCollection, IEnumerable<TMember>>> exp)
        {
            var expStr = QueryEx<TCollection>.ExpToStr(exp);
            var obj = new QueryCollection<TCollection, TMember>(exp)
            {
                _collectionName = string.Format("{0}.{1}", _collectionName, expStr)
            };


            return obj;
        }


        /// <summary>
        /// this method only support 1 layer nested(not for Query Collection.Collection , but for Collection.Member)
        /// if member is collection and need convert to sub class 
        /// </summary>
        /// <typeparam name="TMember">Base Type</typeparam>
        /// <typeparam name="TMemberSub">Child Class Type</typeparam>
        /// <param name="collectionExpression"></param>
        /// <returns></returns>
        public QueryCollection<TCollection, TMemberSub> CollectionMemberAs<TMember, TMemberSub>(
            Expression<Func<TCollection, IEnumerable<TMember>>> collectionExpression)
            where TMemberSub : TMember
        {
            var obj = QueryEx<TCollection>.CollectionAs<TMember, TMemberSub>(collectionExpression);
            obj._collectionName = string.Format("{0}.{1}", _collectionName, obj._collectionName);


            return obj;
        }


        public IMongoQuery LT<TMember>(Expression<Func<TCollection, TMember>> memberExpression, TMember value)
        {
            var memberName = _queryExpression.MemberExpression(memberExpression);


            return Query.LT(string.Format("{0}.{1}", _collectionName, memberName), BsonValue.Create(value));
        }


        public IMongoQuery LT<TValue>(Expression<Func<TCollection, IEnumerable<TValue>>> memberExpression, TValue value)
        {
            var memberName = _queryExpression.MemberExpression(memberExpression);


            return Query.LT(string.Format("{0}.{1}", _collectionName, memberName), BsonValue.Create(value));
        }


        public IMongoQuery EQ<TMember>(Expression<Func<TCollection, TMember>> memberExpression, TMember value)
        {
            var memberName = _queryExpression.MemberExpression(memberExpression);


            return Query.EQ(string.Format("{0}.{1}", _collectionName, memberName), BsonValue.Create(value));
        }


        public IMongoQuery EQ<TValue>(Expression<Func<TCollection, IEnumerable<TValue>>> memberExpression, TValue value)
        {
            var memberName = _queryExpression.MemberExpression(memberExpression);


            return Query.EQ(string.Format("{0}.{1}", _collectionName, memberName), BsonValue.Create(value));
        }


        public IMongoQuery NE<TMember>(Expression<Func<TCollection, TMember>> memberExpression, TMember value)
        {
            var memberName = _queryExpression.MemberExpression(memberExpression);


            return Query.NE(string.Format("{0}.{1}", _collectionName, memberName), BsonValue.Create(value));
        }


        public IMongoQuery NE<TValue>(Expression<Func<TCollection, IEnumerable<TValue>>> memberExpression, TValue value)
        {
            var memberName = _queryExpression.MemberExpression(memberExpression);


            return Query.NE(string.Format("{0}.{1}", _collectionName, memberName), BsonValue.Create(value));
        }


        public IMongoQuery In<TMember>(Expression<Func<TCollection, TMember>> memberExpression, params TMember[] values)
        {
            return In<TMember>(memberExpression, new List<TMember>(values));
        }


        public IMongoQuery In<TMember>(Expression<Func<TCollection, TMember>> memberExpression,
            IEnumerable<TMember> values)
        {
            var memberName = _queryExpression.MemberExpression(memberExpression);
            return Query.In(string.Format("{0}.{1}", _collectionName, memberName), values.Select(x => BsonValue.Create(x)));
        }


        public IMongoQuery In<TCastC, TMember>(Expression<Func<TCastC, TMember>> memberExpression,
            IEnumerable<TMember> values) where TCastC : TCollection
        {
            var memberName = _queryExpression.MemberExpression(memberExpression);
            return Query.In(string.Format("{0}.{1}", _collectionName, memberName), values.Select(x => BsonValue.Create(x)));
        }


        public IMongoQuery In<TValue>(Expression<Func<TCollection, IEnumerable<TValue>>> memberExpression, IEnumerable<TValue> values)
        {
            var memberName = _queryExpression.MemberExpression(memberExpression);
            return Query.In(string.Format("{0}.{1}", _collectionName, memberName), values.Select(x => BsonValue.Create(x)));
        }


        public IMongoQuery In<TCastC, TValue>(Expression<Func<TCastC, IEnumerable<TValue>>> memberExpression, IEnumerable<TValue> values) where TCastC : TCollection
        {
            var memberName = _queryExpression.MemberExpression(memberExpression);
            return Query.In(string.Format("{0}.{1}", _collectionName, memberName), values.Select(x => BsonValue.Create(x)));
        }




        public IMongoQuery Matches<TMember>(Expression<Func<TCollection, TMember>> memberExpression, BsonRegularExpression value)
        {
            var memberName = _queryExpression.MemberExpression(memberExpression);


            return Query.Matches(string.Format("{0}.{1}", _collectionName, memberName), value);
        }


        public IMongoQuery Matches<TValue>(Expression<Func<TCollection, IEnumerable<TValue>>> memberExpression, BsonRegularExpression value)
        {
            var memberName = _queryExpression.MemberExpression(memberExpression);


            return Query.Matches(string.Format("{0}.{1}", _collectionName, memberName), value);
        }
    }








public class QueryMember<TDocument, TCollection>
    {
        private readonly QueryExpressionHelper _queryExpression;
        private string _collectionName;


        public string Context
        {
            get { return _collectionName; }
        }


        public QueryMember(Expression<Func<TDocument, TCollection>> exp)
        {
            _queryExpression = new QueryExpressionHelper();
            _collectionName = _queryExpression.MemberExpression(exp);
        }


        public QueryMember(string context)
        {
            _collectionName = context;
        }


    }




public class QueryExpressionHelper
    {
        public string Context;


        public string MemberExpression<TMember>(Expression<TMember> expression)
        {
            MemberExpression me;
            switch (expression.Body.NodeType)
            {
                case ExpressionType.MemberAccess:
                    me = expression.Body as MemberExpression;
                    break;
                case ExpressionType.Convert:
                    dynamic convertedBody = expression.Body;
                    me = convertedBody.Operand as MemberExpression;
                    break;


                default:
                    throw new NotSupportedException(string.Format("Member with node type {0} is not supported. expression {1}", 
                    expression.Body.NodeType, expression));
            }
            var stack = new Stack<string>();


            while (me != null)
            {
                stack.Push(me.Member.Name);
                me = me.Expression as MemberExpression;
            }


            var expStr = string.Join(".", stack.ToArray());
            return expStr;


           
        }
    }




public static class QueryMoney
    {
        public static IMongoQuery Value(string name, double val)
        {
            var accuracy = 0.005;


            return Query.And(
                Query.LT(name, new BsonDouble(val + accuracy)),
                Query.GT(name, new BsonDouble(val - accuracy)));
        }
    }
Copy after login

The above is the content of extending QueryBuilder of MongoDB C# Driver. For more related content, please pay attention to the PHP Chinese website (www.php.cn)!


Statement of this Website
The content of this article is voluntarily contributed by netizens, and the copyright belongs to the original author. This site does not assume corresponding legal responsibility. If you find any content suspected of plagiarism or infringement, please contact admin@php.cn

Hot AI Tools

Undresser.AI Undress

Undresser.AI Undress

AI-powered app for creating realistic nude photos

AI Clothes Remover

AI Clothes Remover

Online AI tool for removing clothes from photos.

Undress AI Tool

Undress AI Tool

Undress images for free

Clothoff.io

Clothoff.io

AI clothes remover

Video Face Swap

Video Face Swap

Swap faces in any video effortlessly with our completely free AI face swap tool!

Hot Tools

Notepad++7.3.1

Notepad++7.3.1

Easy-to-use and free code editor

SublimeText3 Chinese version

SublimeText3 Chinese version

Chinese version, very easy to use

Zend Studio 13.0.1

Zend Studio 13.0.1

Powerful PHP integrated development environment

Dreamweaver CS6

Dreamweaver CS6

Visual web development tools

SublimeText3 Mac version

SublimeText3 Mac version

God-level code editing software (SublimeText3)

C# vs. C  : History, Evolution, and Future Prospects C# vs. C : History, Evolution, and Future Prospects Apr 19, 2025 am 12:07 AM

The history and evolution of C# and C are unique, and the future prospects are also different. 1.C was invented by BjarneStroustrup in 1983 to introduce object-oriented programming into the C language. Its evolution process includes multiple standardizations, such as C 11 introducing auto keywords and lambda expressions, C 20 introducing concepts and coroutines, and will focus on performance and system-level programming in the future. 2.C# was released by Microsoft in 2000. Combining the advantages of C and Java, its evolution focuses on simplicity and productivity. For example, C#2.0 introduced generics and C#5.0 introduced asynchronous programming, which will focus on developers' productivity and cloud computing in the future.

Use Composer to solve the dilemma of recommendation systems: andres-montanez/recommendations-bundle Use Composer to solve the dilemma of recommendation systems: andres-montanez/recommendations-bundle Apr 18, 2025 am 11:48 AM

When developing an e-commerce website, I encountered a difficult problem: how to provide users with personalized product recommendations. Initially, I tried some simple recommendation algorithms, but the results were not ideal, and user satisfaction was also affected. In order to improve the accuracy and efficiency of the recommendation system, I decided to adopt a more professional solution. Finally, I installed andres-montanez/recommendations-bundle through Composer, which not only solved my problem, but also greatly improved the performance of the recommendation system. You can learn composer through the following address:

What is the CentOS MongoDB backup strategy? What is the CentOS MongoDB backup strategy? Apr 14, 2025 pm 04:51 PM

Detailed explanation of MongoDB efficient backup strategy under CentOS system This article will introduce in detail the various strategies for implementing MongoDB backup on CentOS system to ensure data security and business continuity. We will cover manual backups, timed backups, automated script backups, and backup methods in Docker container environments, and provide best practices for backup file management. Manual backup: Use the mongodump command to perform manual full backup, for example: mongodump-hlocalhost:27017-u username-p password-d database name-o/backup directory This command will export the data and metadata of the specified database to the specified backup directory.

How to encrypt data in Debian MongoDB How to encrypt data in Debian MongoDB Apr 12, 2025 pm 08:03 PM

Encrypting MongoDB database on a Debian system requires following the following steps: Step 1: Install MongoDB First, make sure your Debian system has MongoDB installed. If not, please refer to the official MongoDB document for installation: https://docs.mongodb.com/manual/tutorial/install-mongodb-on-debian/Step 2: Generate the encryption key file Create a file containing the encryption key and set the correct permissions: ddif=/dev/urandomof=/etc/mongodb-keyfilebs=512

From Web to Desktop: The Versatility of C# .NET From Web to Desktop: The Versatility of C# .NET Apr 15, 2025 am 12:07 AM

C#.NETisversatileforbothwebanddesktopdevelopment.1)Forweb,useASP.NETfordynamicapplications.2)Fordesktop,employWindowsFormsorWPFforrichinterfaces.3)UseXamarinforcross-platformdevelopment,enablingcodesharingacrossWindows,macOS,Linux,andmobiledevices.

What are the tools to connect to mongodb What are the tools to connect to mongodb Apr 12, 2025 am 06:51 AM

The main tools for connecting to MongoDB are: 1. MongoDB Shell, suitable for quickly viewing data and performing simple operations; 2. Programming language drivers (such as PyMongo, MongoDB Java Driver, MongoDB Node.js Driver), suitable for application development, but you need to master the usage methods; 3. GUI tools (such as Robo 3T, Compass) provide a graphical interface for beginners and quick data viewing. When selecting tools, you need to consider application scenarios and technology stacks, and pay attention to connection string configuration, permission management and performance optimization, such as using connection pools and indexes.

How to sort mongodb index How to sort mongodb index Apr 12, 2025 am 08:45 AM

Sorting index is a type of MongoDB index that allows sorting documents in a collection by specific fields. Creating a sort index allows you to quickly sort query results without additional sorting operations. Advantages include quick sorting, override queries, and on-demand sorting. The syntax is db.collection.createIndex({ field: &lt;sort order&gt; }), where &lt;sort order&gt; is 1 (ascending order) or -1 (descending order). You can also create multi-field sorting indexes that sort multiple fields.

The Continued Relevance of C# .NET: A Look at Current Usage The Continued Relevance of C# .NET: A Look at Current Usage Apr 16, 2025 am 12:07 AM

C#.NET is still important because it provides powerful tools and libraries that support multiple application development. 1) C# combines .NET framework to make development efficient and convenient. 2) C#'s type safety and garbage collection mechanism enhance its advantages. 3) .NET provides a cross-platform running environment and rich APIs, improving development flexibility.

See all articles