How to dynamically create lambda expressions in C#

C# dynamically creates lambda expressions

Recently, I used the EF framework. I didn’t know how to do it when I was doing a multi-condition where query. I searched online. At first, I used the <T> method to write SQL statements. Later, I encountered another problem that SqlParamterCollection has been defined in another way. I searched for it and found out about what the problem was. I felt that using EF was really inconvenient, and it was better to use Dapper to develop efficiently. Then I searched the Internet for keywords EF framework, which opened the door to a new world.

I learned how to write it dynamically

The code is as follows:

           //querydata is Dictionary<string,string> Put the attribute name and corresponding value to query            ParameterExpression pe = (typeof(Customer), "customer");//The parameters in the lambda expression are single parameters here            Expression left;//A equivalent to a=b            Expression right;//B equivalent to a=b            Expression e;//As the vector of the final expression formed            //Put an initial value first and then replace it otherwise it will be inconvenient to use in the loop            left = (pe, typeof(Customer).GetProperty("name"));//
            right = ("Peak Poplar");//Constant method sets the value corresponding to the attribute            e = (left, right);//=="Peak Poplar"            //Dictionary of circular query condition             foreach (var item in querydata)
            {
                if (!().Trim().Equals(""))
                {
                    left = (pe, typeof(SFC_Package).GetProperty());
                    right = ();
                    if (index == 0)
                    {
                        e = (left, right);
                        index++;
                    }
                    else
                    {
                        if (e != null)
                        {
                            Expression tempe;
                            tempe = (left, right);
                            e = (tempe, e);//Add one && to connect two judgments                        }
                    }
                }
            }
            
            IQueryable&lt;Customer&gt; queryableData = &lt;Customer&gt;();//Convert the IEnumerable type to IQueryable            //The lambda expression of the Where method            MethodCallExpression whereCallExpression = (
            typeof(Queryable),
            "Where",
            new Type[] {  },
            ,
            &lt;Func&lt;SFC_Package, bool&gt;&gt;(e, new ParameterExpression[] { pe }));
            //The lambda expression of the OrderBy method is a bit redundant. I am not used to writing it for the first time. I think about it and I repeated it a lot.            var propertyinfo=typeof(Customer).GetProperty("Name");
            Expression body=(pe,propertyinfo);
            Type nametype=;
            MethodCallExpression orderByCallExpression = (
             typeof(Queryable),
            "OrderBy",
            new Type[] { , nametype},//In fact, it can be written as ("Name").PropertyType            whereCallExpression,
            (body, pe));
            //Query data using the created lambda expression ps:IQueryable and IEnumerable can convert and process query results easily.             IQueryable&lt;SFC_Package&gt; results = &lt;Customer&gt;(orderByCallExpression);

There is also a simple multi-condition query method on the Internet, which is equivalent to

var data=(o=&gt;=="Ximen Chuxue");
data=(o=&gt;="Male God")

Using loops to implement multiple conditions in Where multiple conditions can cause multiple database queries, but it is used in Linq to Object

It should be pretty good on it.

The last learning dynamic creation of lambda expression addressesClick to open the link

Lambda expression dynamic stitching generation tool class

    public static class LambdaUtil&lt;T&gt;
    {
        /// &lt;summary&gt;
        /// lambda expression: t=>true        /// &lt;/summary&gt;
        /// &lt;returns&gt;&lt;/returns&gt;
        public static Expression&lt;Func&lt;T, bool&gt;&gt; True()
        {
            return t =&gt; true;
        }
 
        /// &lt;summary&gt;
        /// lambda expression: t=>false        /// &lt;/summary&gt;
        /// &lt;returns&gt;&lt;/returns&gt;
        public static Expression&lt;Func&lt;T, bool&gt;&gt; False()
        {
            return t =&gt; false;
        }
 
        /// &lt;summary&gt;
        /// lambda expression: t=>        /// Mostly used for order sorting        /// &lt;/summary&gt;
        /// <typeparam name="T">param type</typeparam>        /// <typeparam name="TKey">Return type</typeparam>        /// <param name="propName">Property name</param>        /// &lt;returns&gt;&lt;/returns&gt;
        private static Expression&lt;Func&lt;T, TKey&gt;&gt; Order&lt;TKey&gt;(string propName)
        {
            // Create node parameter t            ParameterExpression parameter = (typeof(T), "t");
            // Create a property            MemberExpression property = (parameter, propName);
            // Generate lambda expressions            return &lt;Func&lt;T, TKey&gt;&gt;(property, parameter);
        }
 
        /// &lt;summary&gt;
        /// lambda expression: t=>==propValue        /// Mostly used in where conditions        /// &lt;/summary&gt;
        /// <typeparam name="T">param type</typeparam>        /// <param name="propName">Property name</param>        /// <param name="propValue">Property value</param>        /// &lt;returns&gt;&lt;/returns&gt;
        public static Expression&lt;Func&lt;T, bool&gt;&gt; Equal(string propName, object propValue)
        {
            // Create node parameter t            ParameterExpression parameter = (typeof(T), "t");
            // Create a member (field/properties)            MemberExpression member = (parameter, propName);
            // Create a constant            ConstantExpression constant = (propValue);
            // Create an equal comparison Expression            BinaryExpression binary = (member, constant);
            // Generate lambda expressions            return &lt;Func&lt;T, bool&gt;&gt;(binary, parameter);
        }
 
        /// &lt;summary&gt;
        /// lambda expression: t=>!=propValue        /// Mostly used in where conditions        /// &lt;/summary&gt;
        /// <typeparam name="T">param type</typeparam>        /// <param name="propName">Property name</param>        /// <param name="propValue">Property value</param>        /// &lt;returns&gt;&lt;/returns&gt;
        public static Expression&lt;Func&lt;T, bool&gt;&gt; NotEqual(string propName, object propValue)
        {
            // Create node parameter t            ParameterExpression parameter = (typeof(T), "t");
            // Create a member (field/properties)            MemberExpression member = (parameter, propName);
            // Create a constant            ConstantExpression constant = (propValue);
            // Create an unequal comparison Expression            BinaryExpression binary = (member, constant);
            // Generate lambda expressions            return &lt;Func&lt;T, bool&gt;&gt;(binary, parameter);
        }
 
        /// &lt;summary&gt;
        /// lambda expression: t=>&lt;propValue        /// Mostly used in where conditions        /// &lt;/summary&gt;
        /// <typeparam name="T">param type</typeparam>        /// <param name="propName">Property name</param>        /// <param name="propValue">Property value</param>        /// &lt;returns&gt;&lt;/returns&gt;
        public static Expression&lt;Func&lt;T, bool&gt;&gt; LessThan(string propName, object propValue)
        {
            // Create node parameter t            ParameterExpression parameter = (typeof(T), "t");
            // Create a member (field/properties)            MemberExpression member = (parameter, propName);
            // Create a constant            ConstantExpression constant = (propValue);
            // Create an unequal comparison Expression            BinaryExpression binary = (member, constant);
            // Generate lambda expressions            return &lt;Func&lt;T, bool&gt;&gt;(binary, parameter);
        }
 
        /// &lt;summary&gt;
        /// lambda expression: t=>&lt;=propValue        /// Mostly used in where conditions        /// &lt;/summary&gt;
        /// <typeparam name="T">param type</typeparam>        /// <param name="propName">Property name</param>        /// <param name="propValue">Property value</param>        /// &lt;returns&gt;&lt;/returns&gt;
        public static Expression&lt;Func&lt;T, bool&gt;&gt; LessThanOrEqual(string propName, object propValue)
        {
            // Create node parameter t            ParameterExpression parameter = (typeof(T), "t");
            // Create a member (field/properties)            MemberExpression member = (parameter, propName);
            // Create a constant            ConstantExpression constant = (propValue);
            // Create an unequal comparison Expression            BinaryExpression binary = (member, constant);
            // Generate lambda expressions            return &lt;Func&lt;T, bool&gt;&gt;(binary, parameter);
        }
 
        /// &lt;summary&gt;
        /// lambda expression: t=>>propValue        /// Mostly used in where conditions        /// &lt;/summary&gt;
        /// <typeparam name="T">param type</typeparam>        /// <param name="propName">Property name</param>        /// <param name="propValue">Property value</param>        /// &lt;returns&gt;&lt;/returns&gt;
        public static Expression&lt;Func&lt;T, bool&gt;&gt; GreaterThan(string propName, object propValue)
        {
            // Create node parameter t            ParameterExpression parameter = (typeof(T), "t");
            // Create a member (field/properties)            MemberExpression member = (parameter, propName);
            // Create a constant            ConstantExpression constant = (propValue);
            // Create an unequal comparison Expression            BinaryExpression binary = (member, constant);
            // Generate lambda expressions            return &lt;Func&lt;T, bool&gt;&gt;(binary, parameter);
        }
 
        /// &lt;summary&gt;
        /// lambda expression: t=>>=propValue        /// Mostly used in where conditions        /// &lt;/summary&gt;
        /// <typeparam name="T">param type</typeparam>        /// <param name="propName">Property name</param>        /// <param name="propValue">Property value</param>        /// &lt;returns&gt;&lt;/returns&gt;
        public static Expression&lt;Func&lt;T, bool&gt;&gt; GreaterThanOrEqual(string propName, object propValue)
        {
            // Create node parameter t            ParameterExpression parameter = (typeof(T), "t");
            // Create a member (field/properties)            MemberExpression member = (parameter, propName);
            // Create a constant            ConstantExpression constant = (propValue);
            // Create an unequal comparison Expression            BinaryExpression binary = (member, constant);
            // Generate lambda expressions            return &lt;Func&lt;T, bool&gt;&gt;(binary, parameter);
        }
 
        /// &lt;summary&gt;
        /// lambda expression: t=>{(propvalue1) ||...||(propvalueN)}        /// Mostly used in where conditions        /// &lt;/summary&gt;
        /// <typeparam name="T">param type</typeparam>        /// <param name="propName">Property name</param>        /// <param name="propValues">Attribute value array</param>        /// &lt;returns&gt;&lt;/returns&gt;
        public static Expression&lt;Func&lt;T, bool&gt;&gt; In(string propName, string[] propValues)
        {
            // Create node parameter t            ParameterExpression parameter = (typeof(T), "t"); // left
            // Create a member (field/properties)            MemberExpression member = (parameter, propName);
            // Create a constant            Expression constant = (false);
            // Create a method            MethodInfo method = typeof(string).GetMethod("Contains", new[] { typeof(string) });
            foreach (string item in propValues)
            {
                // Create a method with parameter expression                MethodCallExpression methodCall = (member, method, (item)); // right
                // Connect parameter method                constant = (methodCall, constant);
            }
 
            // Generate lambda expressions            return &lt;Func&lt;T, bool&gt;&gt;(constant, new ParameterExpression[] { parameter });
        }
 
        /// &lt;summary&gt;
        /// lambda expression: t=>{!((propvalue1) ||...||(propvalueN))}        /// Mostly used in where conditions        /// &lt;/summary&gt;
        /// <typeparam name="T">param type</typeparam>        /// <param name="propName">Property name</param>        /// <param name="propValues">Attribute value array</param>        /// &lt;returns&gt;&lt;/returns&gt;
        public static Expression&lt;Func&lt;T, bool&gt;&gt; NotIn(string propName, string[] propValues)
        {
            // Create node parameter t            ParameterExpression parameter = (typeof(T), "t");
            // Create a member (field/properties)            MemberExpression member = (parameter, propName);
            // Create a constant            Expression constant = (false);
            // Create a method            MethodInfo method = typeof(string).GetMethod("Contains", new[] { typeof(string) });
            foreach (string item in propValues)
            {
                // Create a method with parameter expression                MethodCallExpression methodCall = (member, method, (item)); // right
                // Connect parameter method                constant = (methodCall, constant);
            }
 
            // Generate lambda expressions            return &lt;Func&lt;T, bool&gt;&gt;((constant), new ParameterExpression[] { parameter });
        }
 
        /// &lt;summary&gt;
        /// lambda expression: t=>(propValue)        /// Mostly used in where conditions        /// &lt;/summary&gt;
        /// <typeparam name="T">param type</typeparam>        /// <param name="propName">Property name</param>        /// <param name="propValue">Property value</param>        /// &lt;returns&gt;&lt;/returns&gt;
        public static Expression&lt;Func&lt;T, bool&gt;&gt; Contains(string propName, string propValue)
        {
            // Create node parameter t            ParameterExpression parameter = (typeof(T), "t");
            // Create a member (field/properties)            MemberExpression member = (parameter, propName);
            // Create a constant            ConstantExpression constant = (propValue, typeof(string));
            // Create a method            MethodInfo method = typeof(string).GetMethod("Contains", new[] { typeof(string) });
            // Create a method with parameter expression            MethodCallExpression methodCall = (member, method, constant);
            // Generate lambda expressions            return &lt;Func&lt;T, bool&gt;&gt;(methodCall, parameter);
        }
 
        /// &lt;summary&gt;
        /// lambda expression: t=>(propValue)        /// Mostly used in where conditions        /// &lt;/summary&gt;
        /// <typeparam name="T">param type</typeparam>        /// <param name="propName">Property name</param>        /// <param name="propValue">Property value</param>        /// &lt;returns&gt;&lt;/returns&gt;
        public static Expression&lt;Func&lt;T, bool&gt;&gt; StartWith(string propName, string propValue)
        {
            // Create node parameter t            ParameterExpression parameter = (typeof(T), "t");
            // Create a member (field/properties)            MemberExpression member = (parameter, propName);
            // Create a constant            ConstantExpression constant = (propValue, typeof(string));
            // Create a method            MethodInfo method = typeof(string).GetMethod("StartsWith", new[] { typeof(string) });
            // Create a method with parameter expression            MethodCallExpression methodCall = (member, method, constant);
            // Generate lambda expressions            return &lt;Func&lt;T, bool&gt;&gt;(methodCall, parameter);
        }
 
        /// &lt;summary&gt;
        /// lambda expression: t=>(propValue)        /// Mostly used in where conditions        /// &lt;/summary&gt;
        /// <typeparam name="T">param type</typeparam>        /// <param name="propName">Property name</param>        /// <param name="propValue">Property value</param>        /// &lt;returns&gt;&lt;/returns&gt;
        public static Expression&lt;Func&lt;T, bool&gt;&gt; EndsWith(string propName, string propValue)
        {
            // Create node parameter t            ParameterExpression parameter = (typeof(T), "t");
            // Create a member (field/properties)            MemberExpression member = (parameter, propName);
            // Create a constant            ConstantExpression constant = (propValue, typeof(string));
            // Create a method            MethodInfo method = typeof(string).GetMethod("EndsWith", new[] { typeof(string) });
            // Create a method with parameter expression            MethodCallExpression methodCall = (member, method, constant);
            // Generate lambda expressions            return &lt;Func&lt;T, bool&gt;&gt;(methodCall, parameter);
        }
 
        /// &lt;summary&gt;
        /// lambda expression:!(t=>(propValue))        /// Mostly used in where conditions        /// &lt;/summary&gt;
        /// <typeparam name="T">param type</typeparam>        /// <param name="propName">Property name</param>        /// <param name="propValue">Property value</param>        /// &lt;returns&gt;&lt;/returns&gt;
        public static Expression&lt;Func&lt;T, bool&gt;&gt; NotContains(string propName, string propValue)
        {
            // Create node parameter t            ParameterExpression parameter = (typeof(T), "t");
            // Create a member (field/properties)            MemberExpression member = (parameter, propName);
            // Create a constant            ConstantExpression constant = (propValue, typeof(string));
            // Create a method            MethodInfo method = typeof(string).GetMethod("Contains", new[] { typeof(string) });
            // Create a method with parameter expression            MethodCallExpression methodCall = (member, method, constant);
            // Generate lambda expressions            return &lt;Func&lt;T, bool&gt;&gt;((methodCall), parameter);
        }
 
        /// &lt;summary&gt;
        /// lambda expression: t=>{left and right}        /// Mostly used in where conditions        /// &lt;/summary&gt;
        /// <param name="left">Left conditions</param>        /// <param name="right">Right condition</param>        /// &lt;returns&gt;&lt;/returns&gt;
        public static Expression&lt;Func&lt;T, bool&gt;&gt; And(Expression&lt;Func&lt;T, bool&gt;&gt; left, Expression&lt;Func&lt;T, bool&gt;&gt; right)
        {
            // Create parameter expression            InvocationExpression invocation = (right, &lt;Expression&gt;());
            // Create and operation            BinaryExpression binary = (, invocation);
            // Generate lambda expressions            return &lt;Func&lt;T, bool&gt;&gt;(binary, );
        }
 
        /// &lt;summary&gt;
        /// lambda expression: t=>{left or right}        /// Mostly used in where conditions        /// &lt;/summary&gt;
        /// <param name="left">Left conditions</param>        /// <param name="right">Right condition</param>        /// &lt;returns&gt;&lt;/returns&gt;
        public static Expression&lt;Func&lt;T, bool&gt;&gt; Or(Expression&lt;Func&lt;T, bool&gt;&gt; left, Expression&lt;Func&lt;T, bool&gt;&gt; right)
        {
            // Create parameter expression            InvocationExpression invocation = (right, &lt;Expression&gt;());
            // Create or operation            BinaryExpression binary = (, invocation);
            // Generate lambda expressions            return &lt;Func&lt;T, bool&gt;&gt;(binary, );
        }
    }

Summarize

The above is personal experience. I hope you can give you a reference and I hope you can support me more.