前言

 
我在为EF core 封装一个 UpdateOrCreateAsync 的方法时，需要动态的Lamdba 来配合我

方法

        /// <summary>
        /// 异步更新或创建新的对象
        /// </summary>
        /// <typeparam name="T">类型</typeparam>
        /// <param name="data">数据</param>
        /// <param name="keyField">主键字段，大小写敏感</param>
        /// <returns>T</returns>
        public async Task<T> UpdateOrCreateAsync<T>(T data, string keyField = "ID") where T : class, new()
        {
                        //反射获取对应字段的值
            var dataInfo = typeof(T).GetProperty(keyField);
            var value = dataInfo.GetValue(data);

            //Func<类名, 参数类型>
            var lamdba = BuildPredicate<T>(keyField, value);
            var entity = await GetEntityAsync<T>(lamdba);


            if (entity == null)
            {
                entity = new T();
                //data 中的字段映射到entity 中
                entity.UpdateModel(data);
                await InsertAsync(entity);
            }
            else
            {
                    //data 中的字段映射到entity 中
                entity.UpdateModel(data);
                await UpdateAsync(entity);
            }

            return entity;
        }

动态生成布尔值的lamdba

        /// <summary>
        /// 动态生成返回布尔值的Lamdba 表达式
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="propertyName">对象中的属性名称，大小写敏感</param>
        /// <param name="value">属性的值</param>
        /// <returns></returns>
        private static Expression<Func<T, bool>> BuildPredicate<T>(string propertyName, object value)
        {
            var parameter = Expression.Parameter(typeof(T), "x");
            var property = Expression.Property(parameter, propertyName);
            var constant = Expression.Constant(value);

            var equal = Expression.Equal(property, constant);
            return Expression.Lambda<Func<T, bool>>(equal, parameter);
        }

使用实例

//这将返回一个代表 x => x.MyProperty == 42 的 Expression<Func<MyClass, bool>> 对象。
var predicate = BuildPredicate<MyClass>("MyProperty", 42);