【配置关系】—Entity Framework实例详解

实体间的关系，简单来说无非就是一对一、一对多、多对多，根据方向性来说又分为双向和单向。Code First在实体关系上有以下约定：

1. 两个实体，如果一个实体包含一个引用属性，另一个实体包含一个集合属性，Code First默认约定它们为一对多关系。
2. 两个实体，如果只有一个实体包含一个导航属性或一个集合属性，Code First也默认约定它们是一对多关系。
3. 两个实体分别包含一个集合属性，Code First默认约定它们为多对多关系。
4. 两个实体分别包含一个引用属性，Code First默认约定它们为一对一关系。
5. 在一对一关系情况下，需要提供给Code First额外的信息，以确定它们的主从关系。
6. 在实体中定义一个外键属性，Code First使用属性是否为空来确定关系是必须还是可选。

一、一对一

在Code First中，一对一关系总是需要配置，因为两个实体都包含有一个引用属性，无法确定它们的主从关系。

配置一对一关系常用的方法：

HasRequired ,HasOptional ,WithOptional ,WithRequiredPrincipal,WithRequiredDependent

下面是用到的类：

    public class Person
    {
        public int PersonId { get; set; }
        public int SocialSecurityNumber { get; set; }
        public string FirstName { get; set; }
        public string LastName { get; set; }
        public byte[] RowVersion { get; set; }
        public PersonPhoto Photo { get; set; }
    }

    public class PersonPhoto
    {
        public int PersonId { get; set; }
        public byte[] Photo { get; set; }
        public string Caption { get; set; }
        public Person PhotoOf { get; set; }
    }

因为Photo是具体人的，所以PersonPhoto使用PersonId作为主键。

下面是一对一关系配置的几种情况：

1.PersonPhoto必须属于一个Person，但是Person不一定有PersonPhoto，这种关系是1:0..1，此种情况下Person是一定存在的，所以它是主从关系主的一方。

HasRequired(t => t.PhotoOf).WithOptional(t => t.Photo);

或

HasOptional(t => t.Photo).WithRequired(t => t.PhotoOf);

2.PersonPhoto必须属于一个Person，Person也必须有PersonPhoto，这种关系式1:1，此种情况下，两个都一定存在，要确定主从关系，需要使用WithRequiredPrincipal或WithRequiredDependent。

HasRequired(t => t.PhotoOf).WithRequiredDependent(t => t.Photo);

或

HasRequired(t => t.Photo).WithRequiredPrincipal(t => t.PhotoOf);

上述两种情况都是真实存在的，不真实存在的就不说了。

下面配置一对一关系贴出Demo：

public class Person
{
    public int PersonId { get; set; }
    public int SocialSecurityNumber { get; set; }
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public byte[] RowVersion { get; set; }
    public PersonPhoto Photo { get; set; }
}

public class PersonPhoto
{
    public int PersonId { get; set; }
    public byte[] Photo { get; set; }
    public string Caption { get; set; }
    public Person PhotoOf { get; set; }
}

//配置Person
public class PersonConfiguration : EntityTypeConfiguration<Person>
{
    public PersonConfiguration()
    {
        //主键
        HasKey(t => t.PersonId);
        //并发检查
        Property(t => t.SocialSecurityNumber).HasDatabaseGeneratedOption(DatabaseGeneratedOption.None).IsConcurrencyToken();
        //长度50 不为空
        Property(t => t.FirstName).IsRequired().HasMaxLength(50);
        //长度50 不为空
        Property(t => t.LastName).IsRequired().HasMaxLength(50);
        //并发检查
        Property(t => t.RowVersion).IsRowVersion();
        //HasRequired(t => t.Photo).WithRequiredPrincipal(t => t.PhotoOf);
        //HasOptional(t => t.Photo).WithRequired(t => t.PhotoOf);
    }
}

//配置PersonPhoto
public class PersonPhotoConfiguration : EntityTypeConfiguration<PersonPhoto>
{
    public PersonPhotoConfiguration()
    {
        //主键
        HasKey(t => t.PersonId);
        //长度50
        Property(t => t.Caption).HasMaxLength(50);
        //必须从属于Person
        HasRequired(t => t.PhotoOf).WithRequiredDependent(t => t.Photo);
    }
}

public class BreakAwayContext : DbContext
{
    public DbSet<Person> People { get; set; }
    public DbSet<PersonPhoto> Photos { get; set; }

    protected override void OnModelCreating(DbModelBuilder modelBuilder)
    {
        modelBuilder.Configurations.Add(new PersonConfiguration());
        modelBuilder.Configurations.Add(new PersonPhotoConfiguration());
        base.OnModelCreating(modelBuilder);
    }
}

public class Initializer : DropCreateDatabaseAlways<BreakAwayContext>
{
    public Initializer()
    {
    }

    //创建数据库时 Seed数据
    protected override void Seed(BreakAwayContext context)
    {
        context.People.Add(new Person()
        {
            FirstName = "E",
            LastName = "F",
            SocialSecurityNumber = 123456,
            Photo = new PersonPhoto()
            {
                Caption = "这是照片",
                Photo = new byte[] { }
            }
        });
        context.SaveChanges();
    }
}

测试程序

[TestClass]
public class UnitTest1
{
    [TestMethod]
    public void ShouldReturnAPersonWithPhoto()
    {
        //Arrange
        var init = new Initializer();
        Person person;
        using (var context = new BreakAwayContext())
        {
            init.InitializeDatabase(context);
            //Act
            person = context.People.Include(t => t.Photo).FirstOrDefault();
        }
        //Assert
        Assert.IsNotNull(person);
        Assert.IsNotNull(person.Photo);
    }
}

测试结果：

二、一对多

下面是用到的类：

    public class Blog
    {
        public Blog()
        {
            Posts = new List<Post>();
        }

        public int Id { get; set; }
        public DateTime Creationdate { get; set; }
        public string ShortDescription { get; set; }
        public string Title { get; set; }
        public List<Post> Posts { get; set; }
    }

    public class Post
    {
        public int Id { get; set; }
        public string Title { get; set; }
        public string Content { get; set; }
        public DateTime PostedDate { get; set; }

        public Nullable<int> BlogId { get; set; }
        public virtual Blog Blog { get; set; }

        public int PrimaryAuthorId { get; set; }
        public virtual Author PrimaryAuthor { get; set; }
        public Nullable<int> SecondaryAuthorId { get; set; }
        public virtual Author SecondaryAuthor { get; set; }
    }

    public class Author
    {
        public int Id { get; set; }
        public string Name { get; set; }
        public string Email { get; set; }
        //个人简历
        public string Bio { get; set; }

        public List<Post> PrimaryAuthorFor { get; set; }
        public List<Post> SecondaryAuthorFor { get; set; }
    }

配置一对多关系常用的方法有：

HasOptional ,HasRequired ,HasMany

Has方法后面往往跟着With方法

WithOptional ,WithRequired ,WithMany

下面配置一对多的几种情况：

1.Post一定归属于一个Blog，这种关系是1:n。

HasMany(x => x.Posts).WithRequired(x =>x.Blog)

或

HasRequired(x => x.Blog).WithMany(x => x.Posts)

2.Post可以单独存在，不用归属于Blog，这种关系是0..1:n。

HasMany(x => x.Posts).WithOptional(x => x.Blog)

或

HasOptional(x => x.Blog).WithMany(x => x.Posts)

设置外键

外键的默认约定：

[Target Type Key Name], [Target Type Name] + [Target Type Key Name], or [Navigation
Property Name] + [Target Type Key Name]

本例中，匹配的是[Target Type Name] + [Target Type Key Name]，目标类型是Blog，目标类型主键是Id，加起来就是BlogId。下面使用Fluent API显示设置外键：

HasMany(x => x.Posts).WithOptional(x => x.Blog).HasForeignKey(x => x.BlogId)

设置级联删除

HasMany(x => x.Posts).WithOptional(x => x.Blog).HasForeignKey(x => x.BlogId).WillCascadeOnDelete();

反转属性

在Post实体中，有两个属性：PrimaryAuthor和SecondaryAuthor，第一作者和第二作者。在Author中有两个集合属性，Code First默认不能确定哪个集合属性和Post中的导航属性相匹配。使用Fluent API配置反转属性，如下：

HasRequired(t => t.PrimaryAuthor).WithMany(t => t.PrimaryAuthorFor);
HasOptional(t => t.SecondaryAuthor).WithMany(t => t.SecondaryAuthorFor);

下面是配置一对多关系的Demo:

public class Blog
{
    public Blog()
    {
        Posts = new List<Post>();
    }

    public int Id { get; set; }
    public DateTime Creationdate { get; set; }
    public string ShortDescription { get; set; }
    public string Title { get; set; }
    public List<Post> Posts { get; set; }
}

public class Post
{
    public int Id { get; set; }
    public string Title { get; set; }
    public string Content { get; set; }
    public DateTime PostedDate { get; set; }

    //Post可以不归属到Blog独立存在，注意这里的外键属性要设置为可空的
    public Nullable<int> BlogId { get; set; }
    public virtual Blog Blog { get; set; }

    public int PrimaryAuthorId { get; set; }
    public virtual Author PrimaryAuthor { get; set; }
    public Nullable<int> SecondaryAuthorId { get; set; }
    public virtual Author SecondaryAuthor { get; set; }
}

public class Author
{
    public int Id { get; set; }
    public string Name { get; set; }
    public string Email { get; set; }
    //个人简历
    public string Bio { get; set; }

    public List<Post> PrimaryAuthorFor { get; set; }
    public List<Post> SecondaryAuthorFor { get; set; }
}

public class BlogConfiguratioin : EntityTypeConfiguration<Blog>
{
    public BlogConfiguratioin()
    {
        ToTable("Blogs");
        HasKey(t => t.Id);
        Property(t => t.Id).HasDatabaseGeneratedOption(DatabaseGeneratedOption.Identity);
        Property(t => t.Title).IsRequired().HasMaxLength(250);
        Property(t => t.Creationdate).HasColumnName("CreationDate").IsRequired();
        Property(t => t.ShortDescription).HasColumnType("Text").IsMaxLength().IsOptional().HasColumnName("Description");
        //配置Blog和Post的一对多关系，Blog对Post是可选的，外键BlogId，并设置为级联删除
        HasMany(t => t.Posts).WithOptional(t => t.Blog).HasForeignKey(t => t.BlogId).WillCascadeOnDelete();
    }
}

public class PostConfiguration : EntityTypeConfiguration<Post>
{
    public PostConfiguration()
    {
        ToTable("Posts");
        HasKey(t => t.Id);
        Property(t => t.Id).HasColumnName("PostId").HasDatabaseGeneratedOption(DatabaseGeneratedOption.Identity);
        Property(t => t.Content).HasColumnName("Body").IsMaxLength();
        Property(t => t.PostedDate).HasColumnName("PostedDate");
        Property(t => t.Title).HasColumnName("Title").IsMaxLength();
        //配置反转属性，集合属性PrimaryAuthorFor匹配PrimaryAuthor
        HasRequired(t => t.PrimaryAuthor).WithMany(t => t.PrimaryAuthorFor);
        //配置反转属性,集合属性SecondaryAuthorFor匹配SecondaryAuthor
        HasOptional(t => t.SecondaryAuthor).WithMany(t => t.SecondaryAuthorFor);
    }
}

public class AuthorConfiguration : EntityTypeConfiguration<Author>
{
    public AuthorConfiguration()
    {
        ToTable("Authors");
        HasKey(t => t.Id).Property(t => t.Id).HasColumnName("AuthorId").HasDatabaseGeneratedOption(DatabaseGeneratedOption.Identity);
        Property(t => t.Name).IsRequired().HasMaxLength(50);
        Property(t => t.Email).IsRequired().HasMaxLength(50);
        Property(t => t.Bio).HasMaxLength(1000);
    }
}

public class BreakAwayContext : DbContext
{
    public DbSet<Blog> Blogs { get; set; }
    public DbSet<Post> Posts { get; set; }
    public DbSet<Author> Authors { get; set; }

    protected override void OnModelCreating(DbModelBuilder modelBuilder)
    {
        modelBuilder.Configurations.Add(new BlogConfiguratioin());
        modelBuilder.Configurations.Add(new PostConfiguration());
        modelBuilder.Configurations.Add(new AuthorConfiguration());
        base.OnModelCreating(modelBuilder);
    }
}

public class Initializer : DropCreateDatabaseAlways<BreakAwayContext>
{
    public Initializer()
    {
    }

    protected override void Seed(BreakAwayContext context)
    {
        var primaryAuthor = new Author()
        {
            Name = "张三",
            Email = "zhangsan@126.com",
            Bio = "张三的简历"
        };
        var secondaryAuthor = new Author()
        {
            Name = "李四",
            Email = "lisi@126.com",
            Bio = "李四的简历"
        };
        var blog = new Blog()
        {
            Title = "EF",
            ShortDescription = "关于EF的博客",
            Creationdate = DateTime.Now
        };
        blog.Posts.Add(new Post()
        {
            Title = "配置关系",
            PostedDate = DateTime.Now,
            Content = "这是Post的内容",
            PrimaryAuthor = primaryAuthor,
            SecondaryAuthor = secondaryAuthor
        });
        context.Blogs.Add(blog);
        context.SaveChanges();
    }
}

测试程序：

[TestClass]
public class OneToManyTest
{
    [TestMethod]
    public void ShouldReturnBlogWithPosts()
    {
        //Arrage
        Database.SetInitializer(new Initializer());
        var context = new BreakAwayContext();
        //Act
        var blog = context.Blogs.Include(t => t.Posts).FirstOrDefault();
        //Assert
        Assert.IsNotNull(blog);
        Assert.IsNotNull(blog.Posts);
        Assert.IsNotNull(blog.Posts.FirstOrDefault().PrimaryAuthor);
    }
}

测试结果：

三、多对多

下面是配置多对多关系用到的类，跟一对多差不多，只不过Post和Author的关系变成多对多的了。

    public class Post
    {
        public int Id { get; set; }
        public string Title { get; set; }
        public string Content { get; set; }
        public DateTime PostedDate { get; set; }

        public virtual List<Author> Authors { get; set; }
    }

    public class Author
    {
        public int Id { get; set; }
        public string Name { get; set; }
        public string Email { get; set; }
        //个人简历
        public string Bio { get; set; }

        public virtual List<Post> Posts { get; set; }
    }

一篇文章有多个作者，一个作者著有多篇文章。

配置多对多关系使用HasMany和WithMany方法，可以使用Map配置生成关联表的名字。

下面是配置多对多关系的Demo：

public class Post
{
    public Post()
    {
        Authors = new List<Author>();
    }

    public int Id { get; set; }
    public string Title { get; set; }
    public string Content { get; set; }
    public DateTime PostedDate { get; set; }

    public virtual List<Author> Authors { get; set; }
}

public class Author
{
    public Author()
    {
        Posts = new List<Post>();
    }

    public int Id { get; set; }
    public string Name { get; set; }
    public string Email { get; set; }
    //个人简历
    public string Bio { get; set; }

    public virtual List<Post> Posts { get; set; }
}

public class PostConfiguration : EntityTypeConfiguration<Post>
{
    public PostConfiguration()
    {
        ToTable("Posts");
        HasKey(t => t.Id);
        Property(t => t.Id).HasColumnName("PostId").HasDatabaseGeneratedOption(DatabaseGeneratedOption.Identity);
        Property(t => t.Content).HasColumnName("Body").IsMaxLength();
        Property(t => t.PostedDate).HasColumnName("PostedDate");
        Property(t => t.Title).HasColumnName("Title").IsMaxLength();
        //配置多对多关系 ToTable 配置生成的关联表名字 MapLeftKey默认表示调用HasMany的实体的主键
        //本例中如果不使用MapLeftKey默认生成Post_Id
        HasMany(t => t.Authors).WithMany(t => t.Posts).Map(m =>
            {
                m.ToTable("PostAuthor");
                m.MapLeftKey("PostId");
                m.MapRightKey("AuthorId");
            });
    }
}

public class AuthorConfiguration : EntityTypeConfiguration<Author>
{
    public AuthorConfiguration()
    {
        ToTable("Authors");
        HasKey(t => t.Id);
        Property(t => t.Id).HasColumnName("AuthorId").HasDatabaseGeneratedOption(DatabaseGeneratedOption.Identity);
        Property(t => t.Bio).HasColumnType("Text").IsMaxLength();
        Property(t => t.Email).HasMaxLength(100).IsRequired();
        Property(t => t.Name).HasMaxLength(100).IsRequired();
    }
}

public class TestContext : DbContext
{
    public DbSet<Post> Posts { get; set; }
    public DbSet<Author> Authors { get; set; }

    protected override void OnModelCreating(DbModelBuilder modelBuilder)
    {
        modelBuilder.Configurations.Add(new PostConfiguration());
        modelBuilder.Configurations.Add(new AuthorConfiguration());
        base.OnModelCreating(modelBuilder);
    }
}

public class Initializer : DropCreateDatabaseAlways<TestContext>
{
    protected override void Seed(TestContext context)
    {
        var post = new Post()
        {
            Title = "Post1",
            Content = "Content1",
            PostedDate = DateTime.Now
        };
        var author = new Author()
        {
            Name = "张三",
            Email = "zhangsan@126.com",
            Bio = "张三的简历"
        };
        var author1 = new Author()
        {
            Name = "李四",
            Email = "lisi@126.com",
            Bio = "李四的简历"
        };
        var author2 = new Author()
        {
            Name = "王五",
            Email = "wangwu@126.com",
            Bio = "王五的简历"
        };
        post.Authors.Add(author);
        post.Authors.Add(author1);
        context.Posts.Add(post);
        post = new Post()
        {
            Title = "Post2",
            Content = "Content2",
            PostedDate = DateTime.Now
        };
        post.Authors.Add(author);
        post.Authors.Add(author2);
        context.Posts.Add(post);
        context.SaveChanges();
    }
}

测试程序：

[TestClass]
public class ManyToManyTest
{
    [TestMethod]
    public void ShouldReturnPostWithAuthors()
    {
        //Arrage
        var init = new Initializer();
        var context = new ManyToMany.TestContext();
        init.InitializeDatabase(context);
        //Act
        var post = context.Posts.Include(t => t.Authors).FirstOrDefault();
        //Assert
        Assert.IsNotNull(post);
        Assert.AreEqual(2, post.Authors.Count);
        Assert.AreEqual("李四", post.Authors[1].Name);
    }
}

测试结果：

现在关联表中只有两个字段，如下图所示：

如果再加个字段，比如DateAdd，这就需要给关联表定义一个实体。

    public class PostAuthor
    {
        public int PostId { get; set; }
        public int AuthorId { get; set; }

        public Post Post { get; set; }
        public Author Author { get; set; }

        public DateTime DateAdd { get; set; }
    }

另外需要在Post和Author实体中加入一个集合属性：

        public virtual List<PostAuthor> PostAuthors { get; set; }

另外还需要配置PostAuthor实体，具体代码如下面的Demo所示：

public class Post
{
    public Post()
    {
        PostAuthors = new List<PostAuthor>();
    }

    public int Id { get; set; }
    public string Title { get; set; }
    public string Content { get; set; }
    public DateTime PostedDate { get; set; }

    //public virtual List<Author> Authors { get; set; }
    public virtual List<PostAuthor> PostAuthors { get; set; }
}

public class Author
{
    public Author()
    {
        PostAuthors = new List<PostAuthor>();
    }

    public int Id { get; set; }
    public string Name { get; set; }
    public string Email { get; set; }
    //个人简历
    public string Bio { get; set; }

    //public virtual List<Post> Posts { get; set; }
    public virtual List<PostAuthor> PostAuthors { get; set; }
}

//关联表的实体
public class PostAuthor
{
    public int PostId { get; set; }
    public int AuthorId { get; set; }

    public Post Post { get; set; }
    public Author Author { get; set; }

    public DateTime? DateAdd { get; set; }
}

public class PostConfiguration : EntityTypeConfiguration<Post>
{
    public PostConfiguration()
    {
        ToTable("Posts");
        HasKey(t => t.Id);
        Property(t => t.Id).HasColumnName("PostId").HasDatabaseGeneratedOption(DatabaseGeneratedOption.Identity);
        Property(t => t.Content).HasColumnName("Body").IsMaxLength();
        Property(t => t.PostedDate).HasColumnName("PostedDate");
        Property(t => t.Title).HasColumnName("Title").IsMaxLength();
    }
}

public class AuthorConfiguration : EntityTypeConfiguration<Author>
{
    public AuthorConfiguration()
    {
        ToTable("Authors");
        HasKey(t => t.Id);
        Property(t => t.Id).HasColumnName("AuthorId").HasDatabaseGeneratedOption(DatabaseGeneratedOption.Identity);
        Property(t => t.Bio).HasColumnType("Text").IsMaxLength();
        Property(t => t.Email).HasMaxLength(100).IsRequired();
        Property(t => t.Name).HasMaxLength(100).IsRequired();
    }
}

//配置关联表实体
public class PostAuthorConfiguration : EntityTypeConfiguration<PostAuthor>
{
    public PostAuthorConfiguration()
    {
        ToTable("PostAuthors");
        //配置组合主键
        HasKey(t => new { t.PostId, t.AuthorId });
        Property(t => t.PostId).HasColumnOrder(0);
        Property(t => t.AuthorId).HasColumnOrder(1);
        //这里是配置一对多关系
        HasRequired(t => t.Post).WithMany(t => t.PostAuthors).HasForeignKey(t => t.PostId);
        HasRequired(t => t.Author).WithMany(t => t.PostAuthors).HasForeignKey(t => t.AuthorId);
    }
}

public class TestContext : DbContext
{
    public DbSet<Post> Posts { get; set; }
    public DbSet<Author> Authors { get; set; }
    public DbSet<PostAuthor> PostAuthors { get; set; }

    protected override void OnModelCreating(DbModelBuilder modelBuilder)
    {
        modelBuilder.Configurations.Add(new PostConfiguration());
        modelBuilder.Configurations.Add(new AuthorConfiguration());
        modelBuilder.Configurations.Add(new PostAuthorConfiguration());
        base.OnModelCreating(modelBuilder);
    }
}

public class Initializer : DropCreateDatabaseAlways<TestContext>
{
    protected override void Seed(TestContext context)
    {
        var post = new Post()
        {
            Title = "Post1",
            Content = "Content1",
            PostedDate = DateTime.Now
        };
        post = context.Posts.Add(post);
        var author = new Author()
        {
            Name = "张三",
            Email = "zhangsan@126.com",
            Bio = "张三的简历"
        };
        var author1 = new Author()
        {
            Name = "李四",
            Email = "lisi@126.com",
            Bio = "李四的简历"
        };
        author = context.Authors.Add(author);
        author1 = context.Authors.Add(author1);
        context.SaveChanges();
        PostAuthor pa1 = new PostAuthor()
        {
            PostId = post.Id,
            AuthorId = author.Id,
            DateAdd = DateTime.Now
        };
        PostAuthor pa2 = new PostAuthor()
        {
            PostId = post.Id,
            AuthorId = author1.Id,
            DateAdd = DateTime.Now
        };
        context.PostAuthors.Add(pa1);
        context.PostAuthors.Add(pa2);
        context.SaveChanges();
    }
}

测试程序：

[TestMethod]
public void ShouldReturnAuthorsWithDateAdd()
{
    //Arrage
    var init = new Initializer();
    var context = new ManyToMany.TestContext();
    init.InitializeDatabase(context);
    //Act
    var post = context.Posts.Include(t => t.PostAuthors).FirstOrDefault();
    //Assert
    Assert.IsNotNull(post);
    Assert.AreEqual(2, post.PostAuthors.Count);
    Assert.IsNotNull(post.PostAuthors[0].DateAdd);
}

测试结果：

生成的关联表如下图所示：

四、结束语

点击查看《Entity Framework实例详解》系列的其他文章。

如果遇到问题，可以访问Entity Framework社区，网址是www.ef-community.com或www.ef-community.cn 。