在代码优先的EF存储库中传递动态表达式

本文关键字：动态 表达式 存储 代码 EF | 更新日期: 2023-09-27 18:10:41

我们已经编写了一个泛型函数，首先在存储库模式中从EF代码中获取记录。Rest似乎没问题，但当传递一个整数到动态顺序时，它说Cannot cast System.Int32 to System.Object

的表达式如下:

Expression<Func<HeadOffice, object>> orderByFunc = o =>  o.Id;
if (options.sort == "Id")
{
         // this is an Integer
    orderByFunc = o => o.Id;
}
if (options.sort =="Name")
{
   // string
    orderByFunc = o => o.Name;
}
if (options.sort == "Code")
{
    orderByFunc = o => o.Code;
}

泛型方法如下:

public virtual IEnumerable<TEntity> GetSorted<TSortedBy>(
    Expression<Func<TEntity, object>> order,
    int skip, int take, 
    params Expression<Func<TEntity, object>>[] includes)
{
    IQueryable<TEntity> query = dbSet;
    foreach (var include in includes)
    {
        query = dbSet.Include(include);
    }
    IEnumerable<TEntity> data = query.OrderBy(order).Skip(skip).Take(take).ToList();
    return data;
}

如果我们将Expression<Func<TEntity, object>>转换为Expression<Func<TEntity, int>>，那么它似乎可以很好地处理整数，但不能处理字符串

感谢您的帮助。

在代码优先的EF存储库中传递动态表达式

如果您更改此Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>> orderBy的参数类型，可能会使您的工作更轻松:

public virtual IEnumerable<TEntity> GetSorted(Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>> orderBy,...)
{
    IQueryable<TEntity> query = dbSet;
    //...
    if (orderBy != null)
    {
        query = orderBy(query);
    }
    //...
}

这样你可以像这样传递一个Func:

Func<IQueryable<HeadOffice>, IOrderedQueryable<HeadOffice>> orderBy=null;
if (options.sort == "Id")
{
   orderBy= query=>query.OrderBy(o => o.Id);
}
//...

更新我现在注意到的另一件事是你没有使用TSortedBy通用参数，所以，你也可以这样做: 
public virtual IEnumerable<TEntity> GetSorted<TSortedBy>(Expression<Func<TEntity, TSortedBy>> order,
                                                         int skip, int take, 
                                                         params Expression<Func<TEntity, object>>[] includes)
{
}

但无论如何，我认为最好使用第一个选项并删除该泛型参数

创建一个Sorter类。我们还需要一个与属性类型无关的基类:

public class SorterBase<TEntity>
{                                                               
    public abstract IEnumerable<TEntity> GetSorted( // Note, no order argument here
        int skip, int take, 
        params Expression<Func<TEntity, object>>[] includes);
}
public class Sorter<TEntity, TSortProp> : SorterBase<TEntity>
{                                                               
    private Expression<Func<TEntity, TSortProp>> _order;
    public Sorter(Expression<Func<TEntity, TSortProp>> order)
    {
        _order = order;
    }
    public override IEnumerable<TEntity> GetSorted(...)
    {
       // Use _order here ...
    }
}

现在将排序决定更改为:

SorterBase<HeadOffice> sorter;
if (options.sort == "Id") {
    sorter = new Sorter<HeadOffice, int>(o => o.Id);
} else if (options.sort == "Name") {
    sorter = new Sorter<HeadOffice, string>(o => o.Name);
}
...
var result = sorter.GetSorted(skip, take, includes);

一个解决方案是使用两个重载方法，一个使用

Expression<Func<TEntity, int>>

和

Expression<Func<TEntity, string>>

为了尽量减少代码重复，将公共代码(例如查询初始化语句和for循环)提取到一个共享方法中，然后让这两个方法调用这个共享方法，然后对结果调用OrderBy。

如果所有答案都不适合您，则必须使用顺序表达式

Expression<Func<TEntity,object>>

则尝试以下解决方案:

public class ExpressionHelper : ExpressionVisitor
{
    private MemberExpression m_MemberExpression;
    public MemberExpression GetPropertyAccessExpression(Expression expression)
    {
        m_MemberExpression = null;
        Visit(expression);

        return m_MemberExpression;
    }
    protected override Expression VisitMember(MemberExpression node)
    {
        var property = node.Member as PropertyInfo;
        if (property != null)
        {
            m_MemberExpression = node;
        }
        return base.VisitMember(node);
    }
}
public class DataClass<TEntity>
{
    private readonly IQueryable<TEntity> m_Queryable;
    public DataClass(IQueryable<TEntity> queryable)
    {
        m_Queryable = queryable;
    }

    public virtual IEnumerable<TEntity> GetSorted(
        Expression<Func<TEntity, object>> order,
        int skip, int take,
        params Expression<Func<TEntity, object>>[] includes)
    {
        var property_access_expression = new ExpressionHelper().GetPropertyAccessExpression(order);
        if(property_access_expression == null)
            throw new Exception("Expression is not a property access expression");
        var property_info = (PropertyInfo) property_access_expression.Member;
        var covert_method = this.GetType().GetMethod("Convert").MakeGenericMethod(property_info.PropertyType);
        var new_expression = covert_method.Invoke(this, new object[] {property_access_expression, order.Parameters });

        var get_sorted_method = this.GetType()
            .GetMethod("GetSortedSpecific")
            .MakeGenericMethod(property_info.PropertyType);

        return (IEnumerable<TEntity>)get_sorted_method.Invoke(this, new object[] { new_expression, skip, take, includes });
    }
    public virtual IEnumerable<TEntity> GetSortedSpecific<TSortedBy>(
        Expression<Func<TEntity, TSortedBy>> order,
        int skip, int take,
        params Expression<Func<TEntity, object>>[] includes)
    {
        IQueryable<TEntity> query = m_Queryable;
        //Here do your include logic and any other logic
        IEnumerable<TEntity> data = query.OrderBy(order).Skip(skip).Take(take).ToList();
        return data;
    }
    public Expression<Func<TEntity, TNewKey>> Convert<TNewKey>(
        MemberExpression expression, ReadOnlyCollection<ParameterExpression> parameter_expressions )
    {
        return Expression.Lambda<Func<TEntity, TNewKey>>(expression, parameter_expressions);
    }
}

我是这样测试的:

    void Test()
    {
        Expression<Func<Entity, object>> exp = (x) => x.Text;
        List<Entity> entities = new List<Entity>();
        entities.Add(new Entity()
        {
            Id = 1,
            Text = "yacoub"
        });

        entities.Add(new Entity()
        {
            Id = 2,
            Text = "adam"
        });

        DataClass<Entity> data = new DataClass<Entity>(entities.AsQueryable());
        var result = data.GetSorted(exp, 0, 5, null);
    }

我测试了这两个整数和字符串属性。

请注意，这只适用于简单的属性访问表达式。

您可以增强GetSorted方法，使其适用于更复杂的情况。

相关文章：