【EF Core】未定义实体类的数据库模型

不知道大伙伴们有没有这样的想法：如果我不定义实体类，那 EF Core 能建模吗？能正常映射数据库吗？能正常增删改查吗？

虽然一般开发场景很少这么干，但有时候，尤其是数据库中的某些视图，就不太想给它定义实体类。好消息，EF Core 还真支持不定义实体类的。可是，你一定会疑惑了，不定义实体类，那还怎么面向对象呢？不急，咱们一个个去探寻真相。

先看看这个自定义的上下文类。

public class MyDbContext : DbContext
{
    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
    {
        optionsBuilder.UseSqlServer("server=...");
    }

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        EntityTypeBuilder ent = modelBuilder.Entity("Student");
        // 先把它标记为无主键，避免报错
        ent.HasNoKey();
    }
}

这里我给数据库模型添加了一个叫 Student 的实体，我可没有定义对应的类。然后我们打印一下模型信息，看看能不能建模。

internal class Program
{
    static void Main(string[] args)
    {
        using var context = new MyDbContext();
        // 打印模型信息
        Console.WriteLine(context.Model.ToDebugString());
    }
}

运行一下，好家伙，你看，还真的能建模了。

Model:
  EntityType: Student (Dictionary<string, object>) CLR Type: **Dictionary\<string, object\>** Keyless

注意 CLR Type 后面的信息。这下懂了，当你不给 EF Core 提供实体类时，它会默认使用字典类型，Key 是字符串，Value 是 object 类型。

我们继续验证，既然能建模了，那定义些属性，包括主键。

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    EntityTypeBuilder ent = modelBuilder.Entity("Student");
    // 添加属性
    ent.Property<int>("StuID");
    ent.Property<string>("Name").IsRequired(true);
    ent.Property<int>("Age").IsRequired();
    ent.Property<string>("Major").IsRequired(false);
    // 主键
    ent.HasKey("StuID");
}

Property 方法要指定属性的类型，因为没有对应的 CLR 属性，不然 EF 不知道这个属性是什么类型。这个其实就像影子属性。

现在再看看模型的信息。

Model:
  EntityType: Student (Dictionary<string, object>) CLR Type: Dictionary<string, object>
    Properties:
      StuID (no field, int) Indexer Required PK AfterSave:Throw ValueGenerated.OnAdd
      Age (no field, int) Indexer Required
      Major (no field, string) Indexer
      Name (no field, string) Indexer Required
    Keys:
      StuID PK

看来是没问题的。

好，进入下一个验证阶段。我们用这个模型去创建数据库（这里我用的是 SQL Server）。

public class MyDbContext : DbContext
{
    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
    {
        optionsBuilder.UseSqlServer("server=(localdb)\\MSSQLLocalDB;database=my_school");
    }

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        ......
    }
}

internal class Program
{
    static void Main(string[] args)
    {
        using var context = new MyDbContext();
        ......
        // 创建数据库
        context.Database.EnsureCreated();
    }
}

运行后，成功创建数据库，包含数据表 Student。

CREATE TABLE [dbo].[Student] (
    [StuID] INT            IDENTITY (1, 1) NOT NULL,
    [Age]   INT            NOT NULL,
    [Major] NVARCHAR (MAX) NULL,
    [Name]  NVARCHAR (MAX) NOT NULL,
    CONSTRAINT [PK_Student] PRIMARY KEY CLUSTERED ([StuID] ASC)
);

默认它使用了 Student 为表名。

咱们的数据库上下文还少了一个 DbSet<> 属性，为了能访问数据，应当定义此属性。不过，这样定义是错误的。

public class MyDbContext : DbContext
{
      ......

    public DbSet<Dictionary<string, object>> Students { get; set; }
}

虽然在运行的时候没有抛出异常，但是，Students 属性在 DbContext 初始化时，DbSet<> 没有被正确设置，即内部的 InternalDbSet 类初始化失败。说白了这个 DbSet 类型的属性你不能正常访问。

什么原因？当我们通过 LINQ 查询时，由于 DbSet 本身就是实现了 IQueryable<> 接口的，因此，EntityQueryable 属性会被 IEnumerable.GetEnumerator() 等方法访问。

然后我们再看 EntityQueryable 属性的代码。

private EntityQueryable<TEntity> EntityQueryable
{
    get
    {
        CheckState();

        return NonCapturingLazyInitializer.EnsureInitialized(
            ref field,
            this,
            static internalSet => internalSet.CreateEntityQueryable());
    }
}

这里触发了CheckState 方法。

private void CheckState()
    // ReSharper disable once AssignmentIsFullyDiscarded
    => _ = EntityType;

CheckState 方法又访问了 EntityType 属性。

public override IEntityType EntityType
{
    get
    {
        if (field != null)
        {
            return field;
        }

        field = _entityTypeName != null
            ? _context.Model.FindEntityType(_entityTypeName)
            : _context.Model.FindEntityType(typeof(TEntity));

        if (field == null)
        {
            if (_context.Model.IsShared(typeof(TEntity)))
            {
                throw new InvalidOperationException(CoreStrings.InvalidSetSharedType(typeof(TEntity).ShortDisplayName()));
            }

            ......

        return field;
    }
}

其他地方不用看，重点是发现中间有一段是判断实体的类型是否为共享类型。IsShared 方法是 Model 类中定义的。

public virtual bool IsShared([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.Interfaces)] Type type)
    => FindIsSharedConfigurationSource(type) != null
        || Configuration?.GetConfigurationType(type) == TypeConfigurationType.SharedTypeEntityType;


public virtual ConfigurationSource? FindIsSharedConfigurationSource(Type type)
    => _sharedTypes.TryGetValue(type, out var existingTypes) ? existingTypes.ConfigurationSource : null;

_sharedTypes 是 Model 类的字段，从初始化时，它就把 Dictionary<string, object> 设定为共享类型。

    public static readonly Type DefaultPropertyBagType = typeof(Dictionary<string, object>);

    private readonly Dictionary<Type, (ConfigurationSource ConfigurationSource, SortedSet<EntityType> Types)> _sharedTypes =
        new() { { **DefaultPropertyBagType**, (ConfigurationSource.Explicit, new SortedSet<EntityType>(TypeBaseNameComparer.Instance)) } };

看到没，_sharedTypes 字段从 new 那一刻起，它里面就包含了 Dictionary<string, object> 类型。

共享类型的特点是允许多个实体使用同一个 .NET 类，而字典类型就是默认的共享类型。而使用 DbSet<...> Students { get; set; } 这种格式定义的属性，在 DbContext 类的内部，只用实体类的 Type 作为索引的 Key，没有命名。一旦 Type 是多个实体共享的类型，就破坏了唯一性。这时候必须同时用 Type 和 name 来标识 DbSet 才能做到唯一区分。看看 DbContext 类内部的 DbSet 列表是怎么缓存的。

private Dictionary<(Type Type, string? Name), object>? _sets;

说白了，DbContext 类的内部是用一个字典来缓存 DbSet 的（看，字典类型真是好用，哪儿都能用得上它），其中 Key 是由两个值构成的：实体的类型 + 实体的名字。对于常见的实体类，因为类是唯一的，不共享的，所以，Name 的值可以忽略；而共享类型则不同，多个实体的 Type 是相同的，不用 Name 的话无法区分。所以，对于咱们这个未定义实体类的 Student 实体，只能调用 Set 方法来返回，并且要显式地指定一个名字，名字必须和模型中注册的实体名相同，否则，查询的时候还是找不到映射的。

废话了那么多，正确的属性定义应当是这样的。

public DbSet<Dictionary<string, object>> Students => Set<Dictionary<string, object>>("Student");

咱们把表映射完善一下。

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        EntityTypeBuilder ent = modelBuilder.Entity("Student");
        // 添加属性
        ent.Property<int>("StuID")
                                .HasColumnName("f_stuid");
        ent.Property<string>("Name")
                                .IsRequired(true)
                                .HasMaxLength(15)
                                .HasColumnName("f_name");
        ent.Property<int>("Age")
                                .IsRequired()
                                .HasColumnName("f_age");
        ent.Property<string>("Major")
                                .IsRequired(false)
                                .HasMaxLength(30)
                                .HasColumnName("f_major");
        // 主键
        ent.HasKey("StuID").HasName("PK_stu_id");
        // 表名
        ent.ToTable("tb_students");
    }

然后创建的数据库是这样的。

逐渐对味了，这一关可以 pass 了。

接下来咱们还要验证一下，增删改查是否可行。

A、先插入五条记录。

// 插入数据
// Name：姓名；Age：年龄；Major：专业
Dictionary<string, object>[] newRecs =
[
    new()
    {
        ["Name"] = "刘桂圆",
        ["Age"] = 19,
        ["Major"] = "人力资源管理裁员方向"
    },
    new()
    {
        ["Name"] = "方小同",
        ["Age"] = 20,
        ["Major"] = "调酒师"
    },
    new()
    {
        ["Name"] = "程河洛",
        ["Age"] = 20,
        ["Major"] = "兽医"
    },
    new()
    {
        ["Name"] = "史地分",
        ["Age"] = 22,
        ["Major"] = "堪舆学"
    },
    new()
    {
        ["Name"] = "吴胜隆",
        ["Age"] = 18,
        ["Major"] = "行星科学"
    }
];

context.Students.AddRange(newRecs);
// 提交更改
int n = context.SaveChanges();
Console.WriteLine("已更新{0}条数据", n);

结果如下：

B、现在看一下数据更新。把 ID=3 的同学的专业改为"土狗工程"。

int n = context.Students
        .Where(stu => (int)stu["StuID"] == 3)
        .ExecuteUpdate(setter=> setter.SetProperty(s => s["Major"], "土狗工程"));
Console.WriteLine("更新了{0}条记录", n);

这个写法可能有大伙伴没看懂，老周解释一下。

首先，用 ExecuteUpdate 方法的好处是只生成一条 UPDATE 语句，提高了效率。如果你先查询 ID=3 的数据，然后修改其属性，然后再提交更改。那样 EF 会先生成 SELECT 语句，返回数据后，在内存中修改，再生成 UPDATE 语句，这样不太必要。

ExecuteUpdate 方法生成的 UPDATE 语句，它的 Where 子句是和 LINQ 查询匹配的，由于我们要改 id=3 的记录，所以要先调用 Where 方法，让 EF 记住有筛选条件，然后再调用 ExecuteUpdate 方法生成 SET 子句。

ExecuteUpdate 是扩展方法，这里我调用的以下重载：

public static int ExecuteUpdate<TSource>(this IQueryable<TSource> source, Action<UpdateSettersBuilder<TSource>> setPropertyCalls)

参数是一只委托，委托有个输入参数，类型是 UpdateSettersBuilder<TSource>。UpdateSettersBuilder 类的功能是帮助框架生成更新语句的 SET 子句。即调用它的 SetProperty 方法给实体的属性赋值。为了保持高度的灵活性和可扩展性，SetProperty 方法采用表达树的方式传参。此处，我使用的是以下重载：

public UpdateSettersBuilder<TSource> SetProperty<TProperty>(
    Expression<Func<TSource, TProperty>> propertyExpression,
    TProperty valueExpression
)

根据 C# 语句可以隐式转化为 Expression 的原则，propertyExpression 参数可以简化理解为 Func<TSource, TProperty>，即你要告 EF 我要更新实体的哪个属性，比如，我要更新 Car.Speed 属性，那么就是 c => c.Speed，其中，c 是 Car 实例。不过，这里我们的 Student 实体是没有定义类的，它是个字典，但没关系，我们就告诉框架要更新哪个 Key 的值就好了。也就是 s => s["Major"]。

第二个参数 valueExpression 就是属性的新的值。

所以，综合起来，整个 ExecuteUpdate 方法的调用就是

ExecuteUpdate(
     setter => setter.SetProperty(s => s["Major"], 
     "土狗工程"
));

等等啊，各位，别忙着按【F5】，上面代码还有个问题，如果你直接运行，就会报类型映射失败的错误。问题就出在这个 Lambda 表达式：s => s["Major"]。我们还记得，它的类型是 Dictionary<string, object>，也就是说，s["Major"] 给表达式树处理引擎提供的类型是 object，而 Major 属性其实要的是 string。

怎么解决呢，简单啊，把它强制转换为 string 就完事了。

ExecuteUpdate(
    setter => setter.SetProperty(s => (string)s["Major"], 
    "土狗工程"
));

现在运行代码就不会出错了。生成的 SQL 语句如下：

 UPDATE [t]
      SET [t].[f_major] = @p
      FROM [tb_students] AS [t]
      WHERE [t].[f_stuid] = 3

咱们验证一下，看到底改了没有。

嗯，已经改了。

C、删除数据。现在咱们把 ID=3 的数据记录删除。为了提高效率，我们用 ExecuteDelete 方法。

 int n = context.Students
             .Where(stu => (int)stu["StuID"] == 3)
             .ExecuteDelete();
 Console.WriteLine("已删除{0}条记录", n);

ExecuteDelete 方法不需要参数，因为生成 DELTE FROM ... 语句一般只要带个 WHERE 子句作为筛选条件就可以了。所以，要先调用 Where 方法做筛选，然后才调用 ExecuteDelete 方法。不然会把整个表的记录删除。

生成的 SQL 语句如下：

DELETE FROM [t]
      FROM [tb_students] AS [t]
      WHERE [t].[f_stuid] = 3

运行代码后，ID=3 的记录就没了。

严重注意：凡是调用 ExecuteXXX 方法处理数据的，不要再调用 SaveChanges 方法了。ExecuteXXX 方法不需要跟踪实体更改，而是直接生成 SQL 发送到数据库执行的。

D、查询数据。就剩下最后一个操作了。咱们把所有记录查询出来，并输出到控制台。

var stuArr = context.Students.ToArray();
// 打印
var q = from s in stuArr
        select new
        {
            StuID = (int)s["StuID"],
            Name = (string)s["Name"],
            Age = (int)s["Age"],
            Major = (string)s["Major"]
        };
foreach(var x in q)
{
    Console.WriteLine($"{x.Name}（{x.StuID}）\t{x.Age}岁，{x.Major}专业");
}

context.Students.ToArray 由于调用了 ToArray 扩展方法，所以查询会执行，从而触发翻译为 SQL 语句，并发送到数据库，返回查询结果。生成 SQL 如下：

 SELECT [t].[f_stuid], [t].[f_age], [t].[f_major], [t].[f_name]
      FROM [tb_students] AS [t]

控制台输出结果如下：

刘桂圆（1）     19岁，人力资源管理裁员方向专业
方小同（2）     20岁，调酒师专业
史地分（4）     22岁，堪舆学专业
吴胜隆（5）     18岁，行星科学专业

在查询的时候，你也可以直接用 SQL 语句，例如查询 ID=1 的记录。

int qid = 1;
var stuArr = context
                 .Students
                 .FromSql($"select * from tb_students where f_stuid = {qid}")
                 .ToArray();

建议使用这种格式化的方式来组织 SQL 语句，而不用 Raw SQL 来拼接，因为用格式化字符串构建 SQL 语句默认使用参数化查询，可以避免特殊字符注入攻击，保证安全。

经过咱们一系列验证，表明不定义类的实体也可以正常完成增删改查操作的。只是使用 Dictionary<string, object> 类型在书写查询的时候，Key 的名称容易写错。尤其是项目你做了一半，让后别人接盘，这种情况很容易把 Key 写错，导致各种错误。

因此，不定义实体类的方案可以使用，但不建议全用，可以仅在部分表或视图的映射中使用。

好了，今天咱们就水到这里了。