[关闭]
@wddpct 2017-07-21T05:16:34.000000Z 字数 17410 阅读 2348

0. 写在前面

本篇文章虽说是入门学习,但是也不会循规蹈矩地把EF1.0版本一直到现在即将到来的EF Core 2.0版本相关的所有历史和细节完完整整还原出来。在后文中,笔者会直接进入正题,所以这篇文章仍然还是需要一定的EF ORM基础。

对于纯新手用户,不妨先去看看文末链接中一些优秀博客,笔者当初也是从这些博客起家,也从中得到了巨大的帮助。当然了,官方教程同样至关重要,笔者之前也贡献过部分EF CORE 官方文档资料(基本都是勘误,逃…),本篇文章中很多内容都是撷取自官方的英文文档和示例。

下文示例中将使用Visual Studio自带的Local Sql Server作为演示数据库进行演示,不过可以放心的是,大部分示例都能流畅地在各种关系型数据库中实现运行,前提是更换不同的DATABASE PROVIDERS,如NPGSQLMYSQL等。

对于未涉及到的知识点(CLI工具,Shadow Property,Logging,从Exsiting Database反向工程生成Context等),只能说笔者最近一直在忙着毕业收尾的事情,有空的时候会把草稿整理下在博文中贴出的,一晃四年,终于也要毕业了。

1. 建立运行环境

  1. //Sql Server Database Provider
  2. Install-Package Microsoft.EntityFrameworkCore.SqlServer
  3. //提供熟悉的Add-Migration,Update-Database等Powershell命令,不区分关系型数据库类型
  4. Install-Package Microsoft.EntityFrameworkCore.Tools
  1. public class MyContext : DbContext
  2. {
  3. public MyContext(DbContextOptions<MyContext> options):base(options)
  4. {
  5. }
  6. protected override void OnModelCreating(ModelBuilder modelBuilder)
  7. {
  8. }
  9. }
  1. public void ConfigureServices(IServiceCollection services)
  2. {
  3. // Add framework services.
  4. services.AddMvc();
  5. services.AddDbContext<MyContext>(options => options.UseSqlServer(Configuration.GetConnectionString("DefaultConnection")));
  6. }
  7. // 需要在appsettings.json中新增一个ConnectionStrings节点,用于存放连接字符串。
  8. "ConnectionStrings": {
  9. "DefaultConnection": "Server=(localdb)\\mssqllocaldb;Database=aspnet-WebApplication4;Trusted_Connection=True;MultipleActiveResultSets=true"
  10. },
  1. Add-Migration Initialize
  2. Update-Database

2. 添加实体和映射数据库

使用EF CORE中添加实体,约束属性和关系,最后将其映射到数据库中的方式有两种,一种是Data Annotations,另一种是Fluent Api,这两种方式并没有优劣之分,全凭开发者喜好和需求,不过相对而言,Fluent Api提供的功能更多。

1. 准备工作

  1. public class Blog
  2. {
  3. public int BlogId { get; set; }
  4. public string Url { get; set; }
  5. public List<Post> Posts { get; set; }
  6. }
  7. public class Post
  8. {
  9. public int PostId { get; set; }
  10. public string Title { get; set; }
  11. public string Content { get; set; }
  12. public Blog Blog { get; set; }
  13. }
  14. public class AuditEntry
  15. {
  16. public int AuditEntryId { get; set; }
  17. public string Username { get; set; }
  18. public string Action { get; set; }
  19. }

2. Data Annotations

  1. //在自定义的MyContext中添加以下三行代码
  2. public DbSet<Blog> Blogs { get; set; }
  3. public DbSet<Post> Posts { get; set; }
  4. public DbSet<AuditEntry> AuditEntries { get; set; }
  5. //添加Table特性,第一个属性代表数据库表名称
  6. [Table("Blogs")]
  7. public class Blog
  8. {
  9. [Key]
  10. public int BlogId { get; set; }
  11. public string Url { get; set; }
  12. public List<Post> Posts { get; set; }
  13. }
  14. //code
  1. //BLOG Table
  2. CREATE TABLE [dbo].[Blogs] (
  3. [BlogId] INT IDENTITY (1, 1) NOT NULL,
  4. [Url] NVARCHAR (MAX) NULL,
  5. CONSTRAINT [PK_Blogs] PRIMARY KEY CLUSTERED ([BlogId] ASC)
  6. );
  7. CREATE TABLE [dbo].[Posts] (
  8. [PostId] INT IDENTITY (1, 1) NOT NULL,
  9. [BlogId] INT NULL,
  10. [Content] NVARCHAR (MAX) NULL,
  11. [Title] NVARCHAR (MAX) NULL,
  12. CONSTRAINT [PK_Posts] PRIMARY KEY CLUSTERED ([PostId] ASC),
  13. CONSTRAINT [FK_Posts_Blogs_BlogId] FOREIGN KEY ([BlogId]) REFERENCES [dbo].[Blogs] ([BlogId])
  14. );
  15. //POST Table
  16. GO
  17. CREATE NONCLUSTERED INDEX [IX_Posts_BlogId]
  18. ON [dbo].[Posts]([BlogId] ASC);

3. Fluent Api

Fluent Api俗名流式接口,其实就是C#中的扩展接口形式而已,大家日常应该接触过很多了。还记得我们第一步中MyContext定义的OnModelCreating方法吗,Fluent Api就是在那里面使用的

  1. modelBuilder.Entity<Blog>().ToTable("Blogs").HasKey(c=>c.BlogId);
  2. modelBuilder.Entity<Post>().ToTable("Posts").HasKey(c=>c.PostId);
  3. modelBuilder.Entity<AuditEntry>().ToTable("AuditEntries").HasKey(c=>c.AuditEntryId);

无论是使用DbSet< TEntity >的形式抑或是使用modelBuilder.Entity< TEntity >的形式都能将定义的实体映射到数据库中,下文也会继续做出说明。

3. 包含和排除实体类型

将实体在Context中映射到数据库有多种方式:

如以下代码所示。Blog实体包含对Post实体的引用,而独立的AuditEntry则可以在OnModelCreating方法中进行配置。

  1. class MyContext : DbContext
  2. {
  3. public DbSet<Blog> Blogs { get; set; }
  4. protected override void OnModelCreating(ModelBuilder modelBuilder)
  5. {
  6. modelBuilder.Entity<AuditEntry>();
  7. }
  8. }
  9. public class Blog
  10. {
  11. public int BlogId { get; set; }
  12. public string Url { get; set; }
  13. public List<Post> Posts { get; set; }
  14. }
  15. public class Post
  16. {
  17. public int PostId { get; set; }
  18. public string Title { get; set; }
  19. public string Content { get; set; }
  20. public Blog Blog { get; set; }
  21. }
  22. public class AuditEntry
  23. {
  24. public int AuditEntryId { get; set; }
  25. public string Username { get; set; }
  26. public string Action { get; set; }
  27. }

以上内容指的是“包含实体”的操作,“排除实体”操作也十分地简便。通过以下两种配置方式,在运行了迁移命令后,BlogMetadata实体是不会映射到数据库中的。

1. Data Annotations [NotMapped] 排除实体和属性

  1. public class Blog
  2. {
  3. public int BlogId { get; set; }
  4. public string Url { get; set; }
  5. public BlogMetadata Metadata { get; set; }
  6. }
  7. [NotMapped]
  8. public class BlogMetadata
  9. {
  10. public DateTime LoadedFromDatabase { get; set; }
  11. }

2. Fluent API [Ignore] 排除实体和属性

  1. class MyContext : DbContext
  2. {
  3. public DbSet<Blog> Blogs { get; set; }
  4. protected override void OnModelCreating(ModelBuilder modelBuilder)
  5. {
  6. modelBuilder.Ignore<BlogMetadata>();
  7. }
  8. }
  9. public class Blog
  10. {
  11. public int BlogId { get; set; }
  12. public string Url { get; set; }
  13. public BlogMetadata Metadata { get; set; }
  14. }
  15. public class BlogMetadata
  16. {
  17. public DateTime LoadedFromDatabase { get; set; }
  18. }

NotMapped特性不仅可以用在实体类上,也可以用在指定的属性上。而在Fluent Api中,对应的操作则是
modelBuilder.Entity<Blog>().Ignore(b => b.LoadedFromDatabase);

4. 列名称和类型映射

Property方法对应数据库中的Column。

默认情况下,我们不需要更改任何实体中包含的属性名,EF CORE会自动地根据属性名称映射到数据库中的列名。当开发者需要进行自定义修改名称时( 比如每种关系型数据库的命名规则不一样,虽然笔者一直喜欢使用帕斯卡命名以保持和项目代码结构中的统一),可以使用以下的方式。

少数的几个CLR类型在不做处理的情况下,映射到数据库中时将存在可空选项,如string,int?,这种情况也在下列方式中做了说明。其中Data Annotations对应[Required]特性,Fluent API对应IsRequired方法。

1. Data Annotations

Column特性可用于属性上,它接收多个参数,其中比较重要的是Name和TypeName,前者表示数据库表映射的列名,后者表示数据类型和格式。假如不指定Url属性上的[Column(TypeName="varchar(200)")],数据库Blog表的Url列默认数据格式将为varchar(max)

  1. public class Blog
  2. {
  3. [Column("blog_id")]
  4. public int BlogId { get; set; }
  5. [Required]
  6. [Column(TypeName = "varchar(200)")]
  7. public string Url { get; set; }
  8. }

2. Fluent API

  1. class MyContext : DbContext
  2. {
  3. public DbSet<Blog> Blogs { get; set; }
  4. protected override void OnModelCreating(ModelBuilder modelBuilder)
  5. {
  6. modelBuilder.Entity<Blog>()
  7. .Property(b => b.BlogId)
  8. .HasColumnName("blog_id");
  9. modelBuilder.Entity<Blog>()
  10. .Property(b => b.Url)
  11. .HasColumnType("varchar(200)")
  12. .IsRequired();
  13. }
  14. }
  15. public class Blog
  16. {
  17. public int BlogId { get; set; }
  18. public string Url { get; set; }
  19. }

由于各种关系型数据库对于数据类型的名称有所区别,所以自定义数据类型时,一定要参阅目标数据库的数据类型定义。比如PostgreSql支持Json格式,那么就需要添加以下代码——builder.Entity().Property(b => b.SomeStringProperty).HasColumnType("jsonb");

5. 主键

默认情况下,EF CORE会将实体中命名为Id或者[Type]Id的属性映射为数据库表中的主键。当然有些开发者不喜欢将主键命名为Id,EF CORE也提供了两种方式进行主键的相关设置。

1. Data Annotations [Key]

Data Annotations方式不支持定义外键名称,主键配置如下代码所示。

  1. class Car
  2. {
  3. [Key]
  4. public string LicensePlate { get; set; }
  5. public string Make { get; set; }
  6. public string Model { get; set; }
  7. }

2. Fluent API [HasKey]

Fluent Api方式中的HasKey方法可以将属性映射为主键,对于复合主键(多个属性组合而成的主键标识)也可以很容易地进行表示。

  1. class MyContext : DbContext
  2. {
  3. public DbSet<Car> Cars { get; set; }
  4. protected override void OnModelCreating(ModelBuilder modelBuilder)
  5. {
  6. modelBuilder.Entity<Car>()
  7. .HasKey(c => c.LicensePlate);
  8. //复合主键
  9. //modelBuilder.Entity<Car>()
  10. //.HasKey(c => new { c.State, c.LicensePlate });
  11. modelBuilder.Entity<Post>()
  12. .HasOne(p => p.Blog)
  13. .WithMany(b => b.Posts)
  14. .HasForeignKey(p => p.BlogId)
  15. .HasConstraintName("ForeignKey_Post_Blog");
  16. }
  17. }
  18. class Car
  19. {
  20. public string State { get; set; }
  21. public string LicensePlate { get; set; }
  22. public string Make { get; set; }
  23. public string Model { get; set; }
  24. }

6. 备用键

Alternate Keys是EF CORE引入的新功能,EF 6.X版本中并没有此功能。备用键可以用作实体中除主键和索引外的唯一标识符,还可以用作外键目标。在Fluent Api中,有两种方法可以指定备用键,一种是当开发者将实体中的属性作为另一个实体的外键目标,另一种是手动指定。EF CORE的默认约束是前者。

备用键和主键的作用十分相似,同样也存在复合备用键的功能,请大家注意区分。在要求单表列的一致性的场景中,使用唯一索引比使用备用键更佳。

1. Fluent API

  1. public class MyContext : DbContext
  2. {
  3. public MyContext(DbContextOptions<MyContext> options) : base(options)
  4. {
  5. }
  6. public DbSet<Car> Cars { get; set; }
  7. public DbSet<Blog> Blogs { get; set; }
  8. public DbSet<Post> Posts { get; set; }
  9. protected override void OnModelCreating(ModelBuilder modelBuilder)
  10. {
  11. // 第一种方法
  12. modelBuilder.Entity<Post>()
  13. .HasOne(p => p.Blog)
  14. .WithMany(b => b.Posts)
  15. .HasForeignKey(p => p.BlogUrl)
  16. .HasPrincipalKey(b => b.Url);
  17. // 第二种方法
  18. modelBuilder.Entity<Car>()
  19. .HasAlternateKey(c => c.LicensePlate)
  20. .HasName("AlternateKey_LicensePlate");
  21. }
  22. }
  23. public class Car
  24. {
  25. public int CarId { get; set; }
  26. public string LicensePlate { get; set; }
  27. public string Make { get; set; }
  28. public string Model { get; set; }
  29. }
  30. public class Blog
  31. {
  32. public int BlogId { get; set; }
  33. public string Url { get; set; }
  34. public List<Post> Posts { get; set; }
  35. }
  36. public class Post
  37. {
  38. public int PostId { get; set; }
  39. public string Title { get; set; }
  40. public string Content { get; set; }
  41. public string BlogUrl { get; set; }
  42. public Blog Blog { get; set; }
  43. }

上述代码中的第一种方法指定Post实体中的BlogUrl属性作为Blog对应Post的外键,指定Blog实体中的Url属性作为备用键(HasPrincipalKey方法将在下文的唯一标识节中讲解),此时Url将被配置为唯一列,扮演BlogId的作用。

7. 计算列

计算列指的是列的数据由数据库计算生成,在EF CORE层面,我们只需要定义计算规则即可。目前EF CORE 1.1 版本中,暂不支持使用Data Annotations方式定义。

1 Fluent API

  1. class MyContext : DbContext
  2. {
  3. public DbSet<Person> People { get; set; }
  4. protected override void OnModelCreating(ModelBuilder modelBuilder)
  5. {
  6. modelBuilder.Entity<Person>()
  7. .Property(p => p.DisplayName)
  8. .HasComputedColumnSql("[LastName] + ', ' + [FirstName]");
  9. }
  10. }
  11. public class Person
  12. {
  13. public int PersonId { get; set; }
  14. public string FirstName { get; set; }
  15. public string LastName { get; set; }
  16. public string DisplayName { get; set; }
  17. }

以上代码指明DisplayName由LastName和FirstName结合计算而成,这项工作由数据库代劳,查看P的视图设计器,我们也可以发现数据库在生成表时便指定了详细规则。

  1. CREATE TABLE [dbo].[People] (
  2. [PersonId] INT IDENTITY (1, 1) NOT NULL,
  3. [DisplayName] AS (([LastName]+', ')+[FirstName]),
  4. [FirstName] NVARCHAR (MAX) NULL,
  5. [LastName] NVARCHAR (MAX) NULL,
  6. CONSTRAINT [PK_People] PRIMARY KEY CLUSTERED ([PersonId] ASC)
  7. );

8. 生成值

前文中已经介绍过,假如属性被命名为Id/[Type]Id的形式,EF CORE会将该属性设置为主键。进一步说,如果属性是整数或是Guid类型,那么该属性将会被EF CORE设置为自动生成。这是EF CORE的语法糖之一。

那由用户手动设置呢?EF CORE在Data Annotations和Fluent Api形式上为开发者分别提供了三种方法。

1 Data Annotations

  1. public class Blog
  2. {
  3. [DatabaseGenerated(DatabaseGeneratedOption.None)]
  4. public int BlogId { get; set; }
  5. public string Url { get; set; }
  6. }
  1. public class Blog
  2. {
  3. public int BlogId { get; set; }
  4. public string Url { get; set; }
  5. [DatabaseGenerated(DatabaseGeneratedOption.Identity)]
  6. public DateTime Inserted { get; set; }
  7. }
  1. public class Blog
  2. {
  3. public int BlogId { get; set; }
  4. public string Url { get; set; }
  5. [DatabaseGenerated(DatabaseGeneratedOption.Computed)]
  6. public DateTime LastUpdated { get; set; }
  7. }

2 Fluent API

  1. modelBuilder.Entity<Blog>()
  2. .Property(b => b.BlogId)
  3. .ValueGeneratedNever();
  1. modelBuilder.Entity<Blog>()
  2. .Property(b => b.Inserted)
  3. .ValueGeneratedOnAdd();
  1. modelBuilder.Entity<Blog>()
  2. .Property(b => b.LastUpdated)
  3. .ValueGeneratedOnAddOrUpdate();

值得注意的是,上述对DateTime类型的自动添加操作都是不可行的,这是因为EF CORE只支持部分类型的自动操作,详见Default Values。对于DateTime类型,我们可以用以下代码实现自动插入
modelBuilder.Entity<Blog>().Property(b => b.Created).HasDefaultValueSql("getdate()");
这也是第7点默认值的一种用法。

9. 默认值

默认值与计算列定义十分相似,只是计算列无法由用户手动输入。而默认值更多指的是当用户不手动输入时,使用默认值进行数据库相应列的填充。以下代码表示假如操作中不指定Rating的值,那么数据库将默认填充3。

  1. class MyContext : DbContext
  2. {
  3. public DbSet<Blog> Blogs { get; set; }
  4. protected override void OnModelCreating(ModelBuilder modelBuilder)
  5. {
  6. modelBuilder.Entity<Blog>()
  7. .Property(b => b.Rating)
  8. .HasDefaultValue(3);
  9. }
  10. }
  11. public class Blog
  12. {
  13. public int BlogId { get; set; }
  14. public string Url { get; set; }
  15. public int Rating { get; set; }
  16. }

10. 索引

EF CORE中的索引概念和关系型数据库中的索引概念没有什么不同,比如在Sql Server,将Blog映射到数据库时,将为BlogId建立主键默认持有的聚集索引,将Post映射到数据库中时,将为Post的BlogId建议外键默认的非聚集索引。

  1. GO
  2. CREATE NONCLUSTERED INDEX [IX_Posts_BlogId]
  3. ON [dbo].[Posts]([BlogId] ASC);

至于为一个或多个属性手动建立索引,可以使用形如以下代码。

1. Fluent API

  1. class MyContext : DbContext
  2. {
  3. public DbSet<Blog> Blogs { get; set; }
  4. public DbSet<Person> People { get; set; }
  5. protected override void OnModelCreating(ModelBuilder modelBuilder)
  6. {
  7. modelBuilder.Entity<Blog>()
  8. .HasIndex(b => b.Url)
  9. .HasName("IX_Url");
  10. modelBuilder.Entity<Person>()
  11. .HasIndex(p => new { p.FirstName, p.LastName });
  12. }
  13. }
  14. public class Blog
  15. {
  16. public int BlogId { get; set; }
  17. public string Url { get; set; }
  18. }
  19. public class Person
  20. {
  21. public int PersonId { get; set; }
  22. public string FirstName { get; set; }
  23. public string LastName { get; set; }
  24. }

假如你需要配置一个唯一索引,请使用IsUnique方法。形如以下代码:

  1. modelBuilder.Entity<Blog>()
  2. .HasIndex(b => b.Url)
  3. .HasName("IX_Url")
  4. .IsUnique();

11. 主体和唯一标识

在这一节中,让我们来回顾一下HasPrincipalKey方法和唯一标识。

在EF CORE中,主体(Principal Entity)指的是包含主键/备用键的实体。所以在一般情况下,所有的实体都是主体。而主体键(Principal Key)指的是主体中的主键/备用键。大家都知道,主键/备用键都是不可为空且唯一的,这就引出了唯一标识列的写法。

唯一标识列一般有“主体键”,“唯一索引”两种写法,其中主体键中的主键没有什么讨论的价值。让我们来看看其他两种的写法。

1. 备用键

备用键在之前的小节中已经提过,使用以下代码配置的列将自动设置为唯一标识列。

  1. modelBuilder.Entity<Car>()
  2. .HasAlternateKey(c => new {c.LicensePlate, c.Model})
  3. .HasName("AlternateKey_LicensePlate");
  4. modelBuilder.Entity<Post>()
  5. .HasOne(p => p.Blog)
  6. .WithMany(b => b.Posts)
  7. .HasForeignKey(p => p.BlogUrl)
  8. .HasPrincipalKey(b => b.Url);

注意这里的HasPrincipalKey方法,它通常跟在HasForeignKey和WithMany方法后,用以指定实体中的一个或多个属性作为备用键。再次重申一遍,备用键和主键有相似之处,它通常用来指定一个明确的外键目标——当开发者不想用单纯无意义的Id作为外键标识时。

虽然主体键也包括主键,但是主键在EF CORE中时强制定义的,所以HasPrincipalKey只会将属性配置为备用键。

2. 唯一索引

索引及其唯一性只由Fluent Api方式指定,由索引来指定唯一列是比备用键更好的选择。

  1. modelBuilder.Entity<Blog>()
  2. .HasIndex(b => b.Url)
  3. .IsUnique();

12. 继承

继承通常被用来控制实体类接口如何映射到数据库表结构中。在EF CORE 当前版本中,TPC和TPT暂不被支持,TPH是默认且唯一的继承方式。

那么什么是TPH(table-per-hierarchy)呢?顾名思义,一种继承结构全部映射到一张表中,比如Person父类,Student子类和Teacher子类,由EF CORE映射到数据库中时,将会只存在Person类,而Student和Teacher将以列标识的形式出现。

目前只有Fluent Api方式支持TPH,具体实体类代码如下,其中RssBlog继承自Blog。

  1. public class Blog
  2. {
  3. public int BlogId { get; set; }
  4. public string Url { get; set; }
  5. }
  6. public class RssBlog : Blog
  7. {
  8. public string RssUrl { get; set; }
  9. }

在MyContext中,我们将原来的代码修改成如下形式:

  1. class MyContext : DbContext
  2. {
  3. public DbSet<Blog> Blogs { get; set; }
  4. protected override void OnModelCreating(ModelBuilder modelBuilder)
  5. {
  6. modelBuilder.Entity<Blog>()
  7. .HasDiscriminator<string>("blog_type")
  8. .HasValue<Blog>("blog_base")
  9. .HasValue<RssBlog>("blog_rss");
  10. }
  11. }
  12. public class Blog
  13. {
  14. public int BlogId { get; set; }
  15. public string Url { get; set; }
  16. }
  17. public class RssBlog : Blog
  18. {
  19. public string RssUrl { get; set; }
  20. }

观察OnModelCreating方法,HasDiscriminator提供修改标识列名的功能,HasValue提供新增或修改实体时,根据实体类型将不同的标识自动写入标识列中。如新增Blog时,blog_type列将写入blog_base字符串,新增RssBlog时,blog_type列将写入blog_rss字符串。

笔者不推荐用继承的方式设计数据库,只是这个功能相对新奇,就列出来说了。

13. 关系

关系型数据库模型的设计中,最重要的一点便是“关系”的设计了。常见的关系有1-1,1-n,n-n,除此以外,关系的两边还有可空不可空的控制。那么在EF CORE中,我们怎么实现这些关系呢?

以下内容用代码的方式给出了一对一,一对多和多对多的关系,两边关系设为不可空。其实可空不可空的控制十分简单,只要注意是否需要加上IsRequired的扩展Api即可。

不得不说,相比EF6.X的HasRequired和WithOptional等方法,EF CORE中的Api和关系配置清晰直观了不少。

唯一需要注意的是,关系设置请从子端(如User和Blog呈一对多对应时,从Blog开始)开始,否则配置不慎容易出现多个外键的情况。

  1. public class MyContext : DbContext
  2. {
  3. public MyContext(DbContextOptions<MyContext> options) : base(options)
  4. {
  5. }
  6. public DbSet<User> Users { get; set; }
  7. public DbSet<UserAccount> UserAccounts { get; set; }
  8. public DbSet<Blog> Blogs { get; set; }
  9. public DbSet<Post> Posts { get; set; }
  10. public DbSet<PostTag> PostTags { get; set; }
  11. public DbSet<Tag> Tags { get; set; }
  12. protected override void OnModelCreating(ModelBuilder modelBuilder)
  13. {
  14. // Blog与Post之间为 1 - N 关系
  15. modelBuilder.Entity<Post>()
  16. .HasOne(p => p.Blog)
  17. .WithMany(b => b.Posts)
  18. .HasForeignKey(p => p.BlogId)
  19. // 使用HasConstraintName方法配置外键名称
  20. .HasConstraintName("ForeignKey_Post_Blog")
  21. .IsRequired();
  22. // User与UserAccount之间为 1 - 1 关系
  23. modelBuilder.Entity<UserAccount>()
  24. .HasKey(c => c.UserAccountId);
  25. modelBuilder.Entity<UserAccount>()
  26. .HasOne(c => c.User)
  27. .WithOne(c => c.UserAccount)
  28. .HasForeignKey<UserAccount>(c => c.UserAccountId)
  29. .IsRequired();
  30. // User与Blog之间为 1 - N 关系
  31. modelBuilder.Entity<Blog>()
  32. .HasOne(b => b.User)
  33. .WithMany(c => c.Blogs)
  34. .HasForeignKey(c => c.UserId)
  35. .IsRequired();
  36. // Post与Tag之间为 N - N 关系
  37. modelBuilder.Entity<PostTag>()
  38. .HasKey(t => new {t.PostId, t.TagId});
  39. modelBuilder.Entity<PostTag>()
  40. .HasOne(pt => pt.Post)
  41. .WithMany(p => p.PostTags)
  42. .HasForeignKey(pt => pt.PostId)
  43. .IsRequired();
  44. modelBuilder.Entity<PostTag>()
  45. .HasOne(pt => pt.Tag)
  46. .WithMany(t => t.PostTags)
  47. .HasForeignKey(pt => pt.TagId)
  48. .IsRequired();
  49. }
  50. }
  51. public class Blog
  52. {
  53. public int BlogId { get; set; }
  54. public string Url { get; set; }
  55. public List<Post> Posts { get; set; }
  56. public int UserId { get; set; }
  57. public User User { get; set; }
  58. }
  59. public class User
  60. {
  61. public int UserId { get; set; }
  62. public string UserName { get; set; }
  63. public List<Blog> Blogs { get; set; }
  64. public UserAccount UserAccount { get; set; }
  65. }
  66. public class UserAccount
  67. {
  68. public int UserAccountId { get; set; }
  69. public string UserAccountName { get; set; }
  70. public bool IsValid { get; set; }
  71. public User User { get; set; }
  72. }
  73. public class Post
  74. {
  75. public int PostId { get; set; }
  76. public string Title { get; set; }
  77. public string Content { get; set; }
  78. public int BlogId { get; set; }
  79. public Blog Blog { get; set; }
  80. public List<PostTag> PostTags { get; set; }
  81. }
  82. public class Tag
  83. {
  84. public string TagId { get; set; }
  85. public List<PostTag> PostTags { get; set; }
  86. }
  87. public class PostTag
  88. {
  89. public int PostId { get; set; }
  90. public Post Post { get; set; }
  91. public string TagId { get; set; }
  92. public Tag Tag { get; set; }
  93. }

14. Console中的EntityframeworkCore(2017年7月21日新增)

工作中时常会用到一些简单的EF场景,使用Console是最方便不过了,所以特此记录下。

  1. //Sql Server Database Provider
  2. Install-Package Microsoft.EntityFrameworkCore.SqlServer
  3. //提供熟悉的Add-Migration,Update-Database等Powershell命令,不区分关系型数据库类型
  4. Install-Package Microsoft.EntityFrameworkCore.Tools
  1. public class MyContext : DbContext
  2. {
  3. protected override void OnModelCreating(ModelBuilder modelBuilder)
  4. {
  5. }
  6. }

注意我们删除了 public MyContext(DbContextOptions<MyContext> options) : base(options) 构造方法,以便我们可以直接 using(var context = new MyContext()) 的方法。简单来说,当你有依赖注入的需求时,便需要使用第一种构造模型。

  1. Install-Package System.Text.Encoding.CodePages
  2. Install-Package Microsoft.Extensions.Configuration.Json
  3. Install-Package Microsoft.Extensions.Configuration.EnvironmentVariables
  4. // 需要新增appsettings.json文件,并添加ConnectionStrings节点,用于存放连接字符串。
  5. "ConnectionStrings": {
  6. "DefaultConnection": "Server=(localdb)\\mssqllocaldb;Database=Console4;Trusted_Connection=True;MultipleActiveResultSets=true;"
  7. },
  1. private static IConfigurationRoot Configuration { get; set; }
  2. protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
  3. {
  4. //.SetBasePath(Path.Combine(Directory.GetCurrentDirectory(), @"..\.."))
  5. var builder = new ConfigurationBuilder()
  6. .SetBasePath(Directory.GetCurrentDirectory())
  7. .AddJsonFile("appsettings.json")
  8. .AddEnvironmentVariables();
  9. Configuration = builder.Build();
  10. optionsBuilder.UseSqlServer(Configuration.GetConnectionString("DefaultConnection"));
  11. }
  1. Add-Migration Initialize
  2. Update-Database

之后便可以在Console中使用形如 using (var context = new MyContext())的语法对数据库进行操作了。

15. 参考链接和优秀博客

  1. EF CORE OFFICIAL DOC
  2. Introduction to Entity Framework
  3. Feature ​Comparison
  4. Entity Framework教程(第二版)
添加新批注
在作者公开此批注前,只有你和作者可见。
回复批注