不知道大伙伴们有没有这样的想法：如果我不定义实体类，那 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 写错，导致各种错误。
因此，不定义实体类的方案可以使用，但不建议全用，可以仅在部分表或视图的映射中使用。
好了，今天咱们就水到这里了。
此内容由惯性聚合(RSS阅读器)自动聚合整理，仅供阅读参考。 原文来自 — 版权归原作者所有。