实体框架：带有未知类型列的通用表中的数据

Question

我是实体框架的新手，在我的项目中，我必须执行通用查询以检索数据库列的最大值。假设这是我的主要方法：

long GetMaxValue(string tableName, string columnName)
{
    // code here
}

从字面上看，SQL等效是

SELECT MAX(<columnName>) FROM <tableName>

我创建了一个genericdbentity类，该类仅包含numericColumn代表本列的属性，以及在实现的实现中onModeLcreating我的dbContext我有：

modelBuilder.Entity<GenericDbEntity>().ToTable(tableName).HasNoKey();
modelBuilder.Entity<GenericDbEntity>().Property(e => e.NumericColumn)
                                      .HasColumnName(columnName)
                                      .HasConversion(p => (?)p, (? p) => Convert.ToInt64(p));

hasconversion内的问号是因为我实际上不知道该列的DB类型是哪个DB类型（我只知道它是数字），但是我想将其转换为long，因为那是genericdbentity.numericcolumn的数据类型。我试图用对象替换问号，但它说：

属性“ genericdbentity.numericcolumn”是类型为“对象”，当前数据库提供商不支持。要么更改属性CLR类型，要么使用“ [notmapped]''属性或使用“ enmodeLcreating”中的'entityTypebuilder.ignore'忽略属性。

有什么简单的方法可以实现这一目标吗？

PS：我还尝试使用Dynamic，包括hasConversion和作为numericColumn的数据类型，但这无济于事。

编辑：所谓的编译查询是这个：

private static readonly Func<DatabaseContext, long> getMaxValue =
    EF.CompileQuery((DatabaseContext context) =>
                        context.GenericEntity
                               .Max(e => e.NumericColumn));

Answer 1

添加了为特定表和列生成LINQ查询的解决方案。为了使其正常工作，您必须删除 hasConversion，因为带有转换器的属性在LINQ查询中无法使用。

例如，

var maxValue = context.GetMaxValue("Persons", "id");

将生成并执行以下查询：

var maxValue = (long)context.Set<Person>().Max(e => e.Id);

实现

public static class QueryableExtensions
{
    public static long GetMaxValue(this DbContext ctx, string tableName, string columnName)
    {
        var model = ctx.Model;

        var entityType = model.GetEntityTypes().FirstOrDefault(et => tableName.Equals(et.GetTableName(), StringComparison.InvariantCultureIgnoreCase));

        if (entityType == null)
            throw new InvalidOperationException($"Entity for table '{tableName}' not found.");

        // GetColumnName() can be obsolete, it depends on EF Core version.
        var prop = entityType.GetProperties().FirstOrDefault(p => columnName.Equals(p.GetColumnName(), StringComparison.InvariantCultureIgnoreCase));

        if (prop == null)
            throw new InvalidOperationException($"Property for column '{tableName}'.'{columnName}' not found.");

        var entityParam = Expression.Parameter(entityType.ClrType, "e");
        var ctxParam = Expression.Parameter(typeof(DbContext), "ctx");

        // ctx.Set<entityType>()
        var setQuery = Expression.Call(ctxParam, nameof(DbContext.Set), new[] {entityType.ClrType});

        Expression propExpression;
        if (prop.PropertyInfo == null)
        {
            // 'prop' is Shadow property, so call via EF.Property(e, "name")
            propExpression = Expression.Call(typeof(EF), nameof(EF.Property), new[] { prop.ClrType },
                entityParam, Expression.Constant(prop.Name));
        }
        else
        {
            propExpression = Expression.MakeMemberAccess(entityParam, prop.PropertyInfo);
        }

        // e => e.Prop
        var propLambda = Expression.Lambda(propExpression, entityParam);

        // ctx.Set<entityType>().Max(e => e.Prop)
        Expression maxCall = Expression.Call(typeof(Queryable), nameof(Queryable.Max),
            new[] { entityType.ClrType, prop.ClrType }, 
            setQuery, propLambda);

        // cast if needed
        if (maxCall.Type != typeof(long))
            maxCall = Expression.Convert(maxCall, typeof(long));

        // ctx => ctx.Set<entityType>().Max(e => e.Prop)
        var maxLambda = Expression.Lambda<Func<DbContext, long>>(maxCall, ctxParam);

        // probably we can cache such compiled retrieving function
        var func = maxLambda.Compile();

        return func(ctx);
    }
}