ASP.NET MVC - Entity Framework

2022-06-01 23:58:28

实体关系

关系是某个实体（表）的一条记录对应于另一个实体（表）的一条或多条记录。

一对多关系

单方面的包含关系称为一对多，而一对多和一对一其实是一回事，只是站在不同的角度去看就会有不同的结果，比如有员工表和性向表，站在员工角度去看，一个员工对应了一种性向，而站在性向角度去看，一种性向对应于多名员工。

单向一对一

employee引用了sexual

双向一对一

employee引用了sexual，sexual也引用了employee

多对多

双方面的包含关系，称为多对多。一个艺术家对应于多张专辑，一张专辑对应于多个艺术家。通过链表存储对两张表的引用就可以实现多对多关系。

EF设计器

创建一个CUI项目，右击项目创建ADO实体数据模型

这会在项目中生成一个edmx文件，双击该文件可以打开实体设计器。

创建EF上下文对象

右击实体设计器- 属性，可以配置EF上下文对象

创建实体

右击实体设计器- 新增，可以增加实体

创建属性

右击创建好的实体，可以创建以下类型的属性

以下创建了一个实体，并添加了两个属性

设置实体集的名称

实体就是一条记录，实体集就是多条记录，实体集对应于数据库的表，在.Net项目中，通过EF上下文对象调用实体集可执行Linq查询。单击实体，可以设置实体集的名称，下面将实体集的名称改为了复数。

根据实体生成数据库

右击设计器 - 根据模型生成数据库

选择新建连接

输入数据库名称 - 确定，这会根据数据库连接自动生成数据库。完成后，数据库就自动建好了。

根据数据库生成实体

右击实体设计器 - 从数据库更新模型，这会自动根据数据库创建实体模型。

操作实体

对实体的操作，增删改查都是通过DBContext上下文对象来实现的，它提供了获取实体集（表）的属性。

public void Test( )
{
    DBContext EFContext = new DBContext( );
    //新增
    List<Person> list = new List<Person>
    {
            new Person{ Name="sam" },
            new Person{ Name="leo" }
    };
    EFContext.Persons.AddRange( list ); //or Add
    EFContext.SaveChanges( );

//查询记录
var result = EFContext.Persons;

//删除
    //需要先查询
    EFContext.Persons.RemoveRange( result ); //or Remove
    EFContext.SaveChanges( );
}

实体关系

实体关系在EF中以导航属性的形式存在

一对多关系

一个部门下有多名员工，以下创建两个实体。

右击主键实体 - 新增 - 关联，可以创建一对多关系。一个部门对应多个员工，Person实体出现了一个导航属性Department和一个标量属性DepartmentId，Department实体出现了一个导航属性Peoples，DepartmentId会变成数据库表字段，而导航属性不会变成表字段，导航属性只在你的项目代码中使用，用以表示实体关系。Person作为外键表引用了Department主键表，所以它有一个DepartmentId指向一个部门的Id。

EFContext.Deparments.Single( ).Peoples; //一个部门有多个员工
EFContext.Persons.Single( ).Deparment; //一个员工隶属于一个部门

多对多关系

一张专辑有多个艺术家，一个艺术家有多张专辑，双方面的包含关系，称为多对多。

以下创建两种多对多关系，第一种是两个实体相互引用，第二种是两个实体对链表的引用。它们在数据库中生成的表没有什么区别，但在EF设计器中的实体会有一些变化。

第一种多对多关系

DBContext EFContext = new DBContext( );

EFContext.Artists.Add( new Artist
{
    ArtistName = "pink floyd",
    Albums = new List<Album> {
    new Album{ AlbumName="The Division Bell" },
    new Album{ AlbumName="Ummagumma" }
}
} );

EFContext.SaveChanges( );

第二种多对多关系

以一个链表实体存储对双方的引用。

DBContext EFContext = new DBContext( );
ICollection<AlbumLinkArtist> list= EFContext.Artists.Single( ).AlbumLinkArtists; //一个艺术家对应多张专辑，专辑id存储在AlbumLinkArtist表中
ICollection<AlbumLinkArtist> list2 = EFContext.Albums.Single( ).AlbumLinkArtists; //一个专辑对于多个艺术家，艺术家id存储在AlbumLinkArtist表中

//增
var artist = new Artist { ArtistName = "Pink Floyd" };
//为同一个艺术家增加两张专辑
AlbumLinkArtist albumLinkArtist1 = new AlbumLinkArtist
{
    Artist = artist,//同一个艺术家
    Album = new Album { AlbumName = "The Division Bell" }
};
AlbumLinkArtist albumLinkArtist2 = new AlbumLinkArtist
{
    Artist = artist,//同一个艺术家
    Album = new Album { AlbumName = "Ummagumma" }
};

EFContext.AlbumLinkArtists.AddRange( new List<AlbumLinkArtist> {
albumLinkArtist1,
albumLinkArtist2
} );
EFContext.SaveChanges( );

//查
foreach (var artist in EFContext.Artists)
{
    Console.WriteLine( artist.ArtistName );
    foreach(var AlbumLinkArtist in artist.AlbumLinkArtist)
    {
        Console.WriteLine( AlbumLinkArtist.Album.AlbumName );
    }
}

如果是从数据库生成实体，那么多对多关系的数据库表在生成实体时会有以上两种情况，如果链表只存储了双方的主键id，则生成第一种多对多，如果链表存储了额外的字段，比如Description，则生成第二种多对多实体，也即会多出一个链表实体。无论是哪种多对多实体，表达的都是一个概念，没有区别，只是我们在使用实体时需要加以区分。

自引用关系

在一些表示分类的具有层级关系的表中，表可能会引用自身来表示父节点和子节点，在设计器中可以先创建节点实体，只指定其主键和名称，先不要增加父节点id，如下：

接着创建自引用关系，右击实体 - 关联，如下设置：

将自动生成的引用Id改为ParentId以便于理解，然后将ParentId设为可为null，因为*节点没有父节点。

手动插入记录时注意，不需要指定节点的ParentId，由于实体是面向对象的，所以，节点通过其Childs导航属性的Add方法就可以将其它节点作为子节点添加到自身了。

DBContext EFContext = new DBContext( );
Node father = new Node { NodeName = "书籍" };
Node child1 = new Node { NodeName = "哲学" };
Node child1HasChild1 = new Node { NodeName = "性经验史" };
Node child1HasChild2 = new Node { NodeName = "存在与虚无" };

//书籍
//    哲学
//      性经验史
//      存在与虚无

child1.Childs.Add( child1HasChild1 );
child1.Childs.Add( child1HasChild2 );
father.Childs.Add( child1 );
EFContext.Nodes.Add( father );
EFContext.SaveChanges( );

深度查询

//先获取根节点
var roots=EFContext.Nodes.Where( node => node.ParentId == null );
StringBuilder builder = new StringBuilder( );
foreach (var node in roots)
{
ShowNode( node, 0, builder );
}
Console.WriteLine( builder.ToString( ) );
}

public static StringBuilder ShowNode( Node fatherNode, int deep, StringBuilder builder )
{
builder.Append( new string(' ',deep)+ fatherNode.NodeName+"\n" );
foreach (var node in fatherNode.Childs)
{
ShowNode( node, deep+1, builder );
deep = fatherNode.Childs.Last( ) == node ? 0 : deep;
}
return builder;
}

Code First模式

新建一个类库项目，命名为MyEF，添加Entity framework的引用，在项目中创建Model目录用来存放领域模型，右击Model目录添加类。

namespace MyEF.Model
{
    public class Person
    {
        public int PersonId { get; set; }
        public string PersonName { get; set; }
    }
}

创建一个自定义的EF上下文，从DBContext派生

using System.Data.Entity;
using MyEF.Model;

namespace MyEF
{
    public class EFContext : DbContext //自定义EF上下文
    {
        public DbSet<Person> Persons { get; set; } //实体模型必须在此处注册，这就是一张表，记录的集合

        public EFContext() : base("name=MyEF") //实例构造函数接收数据库连接字符或数据库名称，如果是连接字符，则是config中的ConnectionString=MyEF
        {

}

static EFContext() //静态构造函数可用于指定数据库的创建模式
        {
            //无论怎样，删除同名数据库，再重新创建：
            Database.SetInitializer(new DropCreateDatabaseAlways<EFContext>());
            //默认，参数可为null，当数据库不存在时，自动创建数据库：
            //Database.SetInitializer ( new CreateDatabaseIfNotExists<EFContext> ( ) );
            //如果实体模型发生改变，则先删除同名数据库，再重新创建：
            //Database.SetInitializer ( new DropCreateDatabaseIfModelChanges<EFContext> ( ) );
            // 使数据库保持现状，如果你是后来为已经存在的数据库增加表或表的字段，那么可应用此配置，null表示不做任何改动，但你必须手动Code First增加实体或者为实体增加相应的字段：
            //Database.SetInitializer<EFContext>(null); 或  Database.SetInitializer<EFContext>(new NullDatabaseInitializer<EFContext> );
        }
    }
}

在code first中定义导航属性，导航属性都是类类型且必须修饰为virtual，用以表示实体之间的引用关系。

namespace MyEF.Model
{
    public class Department
    {
        public int DepartmentId { get; set; }
        public string DepartmentName { get; set; }
        public virtual List<Person> Persons { get; set; } //一个部门对应多个员工
    }

public class Person
    {
        public int PersonId { get; set; }
        public string PersonName { get; set; }
        //此处没有显示创建标量的外键DepartmentId，这样，EF会根据导航属性Department在数据库Person表中自动创建一个外键字段
        public virtual Department Department { get; set; } //一个员工对应一个部门
    }
}

再创建一个控制台引用程序，设置app.config，增加一个数据库连接字符串

static void Main(string[] args)
{
//向数据库插入数据时会自动创建表

// 默认情况下，数据库文件存储在C:\Program Files\Microsoft SQL Server\MSSQL11.MSSQLSERVER\MSSQL\DATA\
    EFContext EFContext = new EFContext();
    Department department = new Department
    {
        DepartmentName = "xxx",
        Persons = new List<Person>
            {
                new Person{ PersonName="sam" },
                new Person{ PersonName="leo" }
            }
    };
    EFContext.Departments.Add(department);
    EFContext.SaveChanges();
}

Code First模式创建实体关系映射

实体间的引用关系是指实体的导航属性与另一个实体关联，下面的方法就是根据导航属性来设置实体间的引用关系。

实体关系的设置分三个步骤

1.创建一个从EntityTypeConfiguration<T>（System.Data.Entity.ModelConfiguration）派生的类型，比如EmployeeConfig.cs文件，然后在这个类型的构造函数中设置实体关系。设置实体关系需要用到以下几个方法，

Has方法：设置单方面的引用关系

HasMany（lambda）
//根据实体间一对多的引用关系为另一方生成可null的外键

HasRequired（lambda）
//根据实体间一对一的引用关系为当前方生成不可null的外键

HasOptional（lambda）
//根据实体间一对一的引用关系为当前方生成可null的外键

由于一对一在多数情况下可以当做一对多，比如一个名员工对应一个部门，但是一个部门也可以对应多个员工，所以一对一和一对多没有区别。
但也有可能出现这种情况：一个员工对应一个住址，但一个住址通常都不会对应多个员工

With方法只能在调用了Has方法后才可以调用，表示进一步设置引用关系

WithMany（[lambda]）
//无参版：根据实体间一对多的引用关系为双方都生成可null的外键（如果只有单方面的引用则只生成单方面的外键）

WithOptional（[lambda]）
//无参版：根据实体间一对一的引用关系为另一方生成可null的外键，如果在此方法后调用了HasForeignKey方法，则表示手动指定另一方的外键（假如你没有指定外键表的哪个键作为外键，那么EF会自动根据主键表的主键为外键表增加一个外键字段）

WithRequired（[lambda]）
//无参版：根据实体间一对一的引用关系为另一方生成不可null的外键，如果在此方法后调用了HasForeignKey方法，则表示手动指定另一方的外键（假如你没有指定外键表的哪个键作为外键，那么EF会自动根据主键表的主键为外键表增加一个外键字段）

HasMany可组合三个With方法，而HasRequired与HasOptional只能组合WithMany方法

2.在EF上下文的派生上下文中重写基类的OnModelCreating方法，将从EntityTypeConfiguration<T>派生的类型注册到配置集合中

protected override void OnModelCreating(DbModelBuilder modelBuilder)
{
modelBuilder.Configurations.Add(new EmployeeConfig()).Add(/*……*/); //链式操作注册关系配置
}

一对一的code first

如果实体A引用了实体B，但实体B并不引用实体A，这就是单向的一对一。如果实体A引用了实体B，实体B也引用了实体A，这就是双向的一对一。

单向引用：在实体没有外键的情况下由EF自动创建数据库表的外键

public class Employee
{
    public int EmployeeId { get; set; }
    public string EmployeeName { get; set; }
    public virtual Address Address { get; set; }
}

public class Address
{
public int AddressId { get; set; }
public string AddressName { get; set; }
}

//一对一的单向引用，EF自动创建数据库表的外键
public class EmployeeConfig : EntityTypeConfiguration<Employee>
{
    public EmployeeConfig()
    {
        HasKey(employee => employee.EmployeeId);

HasOptional(employee => employee.Address);
        //等同于：
        HasOptional(employee => employee.Address).WithMany();
    }
}

单向引用：在实体有外键的情况下由你自己手动指定数据库表的外键

public class Employee
{
    public int EmployeeId { get; set; }
    public string EmployeeName { get; set; }
    public int? AddressId { get; set; } //外键可null时，注意必须设为int?，否则抛错
    public virtual Address Address { get; set; }
}

public class Address
{
public int AddressId { get; set; }
public string AddressName { get; set; }
}

//一对一的单向引用，手动指定数据库表的外键
public class EmployeeConfig : EntityTypeConfiguration<Employee>
{
    public EmployeeConfig()
    {
        HasKey(employee => employee.EmployeeId);
        HasOptional(employee => employee.Address).WithMany().HasForeignKey(employee=>employee.AddressId);
    }
}

最后，将配置类注册到配置集合中就OK了。

public class EFContext : DbContext
{
public DbSet<Employee> Employees { get; set; }
public DbSet<Address> Addresss { get; set; }

//……

protected override void OnModelCreating(DbModelBuilder modelBuilder)
    {
        modelBuilder.Configurations.Add(new EmployeeConfig()).Add(new AddressConfig());
    }
}

双向引用：在实体没有外键的情况下由EF自动创建数据库表的外键

public class Employee
{
    public int EmployeeId { get; set; }
    public string EmployeeName { get; set; }
    public virtual Address Address { get; set; } //双向引用，则双方实体都必须有导航属性
}

public class Address
{
    public int AddressId { get; set; }
    public string AddressName { get; set; }
    public virtual Employee Employee { get; set; } //双向引用，则双方实体都必须有导航属性
}

//一对一的双向引用，EF自动创建数据库表的外键
public class EmployeeConfig : EntityTypeConfiguration<Employee>
{
    public EmployeeConfig()
    {
        HasKey(employee => employee.EmployeeId);
        //双向引用，双方的外键不可能都是不可null的，如果都是不可null，那么向任何一方插入数据时都必定会抛错
        //所以只可能创建双方外键都可null
        HasOptional(employee => employee.Address).WithMany();
    }
}

双向引用：在实体有外键的情况下由你自己手动指定数据库表的外键

public class Address
{
    public int AddressId { get; set; }
    public string AddressName { get; set; }
    public int? EmployeeId { get; set; } //外键可null时，注意必须设为int?，否则抛错
    public virtual Employee Employee { get; set; } //双向引用，则双方实体都必须有导航属性
}

//一对一的双向引用，手动指定数据库表的外键
public class EmployeeConfig : EntityTypeConfiguration<Employee>
{
    public EmployeeConfig()
    {
        HasKey(employee => employee.EmployeeId);
        //手动指定数据库表的外键，这需要在双方的配置类中都显示指定外键才可以
        HasOptional(employee => employee.Address).WithMany().HasForeignKey(employee=>employee.AddressId);
    }
}

public class AddressConfig : EntityTypeConfiguration<Address>
{
    public AddressConfig()
    {
        HasKey(address => address.AddressId);
        //手动指定数据库表的外键，这需要在双方的配置类中都显示指定外键才可以
        HasOptional(address => address.Employee).WithMany().HasForeignKey(address => address.EmployeeId);
    }
}

一对多的code first

在实体没有外键的情况下由EF自动创建数据库表的外键

public class Department
{
    public int DepartmentId { get; set; }
    public string DepartmentName { get; set; }
    public virtual List<Employee> Employees { get; set; }
    public Department()
    {
        Employees = new List<Employee>();
    }
}

public class Employee
{
public int EmployeeId { get; set; }
public string EmployeeName { get; set; }
}

//一对多，EF自动创建数据库表的外键
public class DepartmentConfig : EntityTypeConfiguration<Department>
{
    public DepartmentConfig()
    {
        HasKey(department => department.DepartmentId);
        HasMany(department => department.Employees);
        //等同于
        HasMany(department => department.Employees).WithOptional();
    }
}

在实体有外键的情况下由你自己手动指定数据库表的外键

public class Employee
{
    public int EmployeeId { get; set; }
    public string EmployeeName { get; set; }
    public int? DepartmentId { get; set; }
}

//一对多，手动指定数据库表的外键
public class DepartmentConfig : EntityTypeConfiguration<Department>
{
    public DepartmentConfig()
    {
        HasKey(department => department.DepartmentId);
        HasMany(department => department.Employees).WithOptional().HasForeignKey(employee=>employee.DepartmentId);
    }
}

多对多的code first

public class Artist
{
    public int ArtistId { get; set; }
    public string ArtistName { get; set; }
    public virtual List<Album> Albums { get; set; }
    public Artist()
    {
        Albums = new List<Album>();
    }
}

public class Album
{
    public int AlbumId { get; set; }
    public string AlbumName { get; set; }
    public virtual List<Artist> Artists { get; set; }
    public Album()
    {
        Artists = new List<Artist>();
    }
}

//多对多，EF自动创建数据库表的外键
public class ArtistConfig : EntityTypeConfiguration<Artist>
{
    public ArtistConfig()
    {
        HasKey(artist => artist.ArtistId);
        //数据库将自动生成一张链表，EF自动创建对两张表的引用外键
        HasMany(artist => artist.Albums).WithMany(album => album.Artists);
    }
}

//多对多，手动指定数据库表的外键
public class ArtistConfig : EntityTypeConfiguration<Artist>
{
    public ArtistConfig()
    {
        HasKey(artist => artist.ArtistId);
        HasMany(artist => artist.Albums).WithMany(album => album.Artists).Map(m => {
            m.ToTable("ArtistAndAlbum");
            m.MapLeftKey("ArtistId");
            m.MapRightKey("AlbumId");
        });
    }
}

自引用的code first

public class Node
{
    public int NodeId { get; set; }
    public string NodeName { get; set; }
    public int? ParentId { get; set; }
    public virtual Node Parent { get; set; }
    public virtual List<Node> Childs { get; set; }
}

public class NodeConfig : EntityTypeConfiguration<Node>
{
    public NodeConfig()
    {
        HasKey(node => node.NodeId);
        //Node有多个Node
        //当前Node表使用Childs外键引用Node表，外键可null，EF会自动创建一个自动命名的外键
        HasMany(node => node.Childs);
        //手动指定外键
        HasMany(node => node.Childs).WithOptional(node => node.Parent).HasForeignKey(node => node.ParentId);
    }
}

数据库的code first

和先code再生成数据库没有区别，只不过是先有数据库和表，再使用向导完成实体和EF上下文的、映射类的生成。其实数据库的code first应该更灵活，因为你可以随时在数据库更改表字段或增删字段，然后手动更新实体类型的字段即可。如果是使用来自已经创建好的数据库的code first，而数据库表并未定义任何外键关系，那么也可以按照以上方式建立实体在程序中的映射关系，也即如果表没有外键，表与表之间也可以自动关联在一起。如果后来增加了数据库表，那么也只需要在项目中填写一个新的实体即可。

配置实体属性

有两种方式可为属性增加配置，Data Annotations和Fluent API，前者配置方便，后者提供更强大的清洁配置。（如果不喜欢到处贴标签）

1.Data Annotations配置（System.ComponentModel.DataAnnotations）

[Table("Animal")]
//将类映射为Animal表

[Key]
//主键，且种子增量每次+1，即自动增长，增量为1

[Key, DatabaseGenerated(System.ComponentModel.DataAnnotations.Schema.DatabaseGeneratedOption.Identity)]
//如果主键类型是Guid，则必须配置此特性，否则不会自动生成唯一标识

[System.ComponentModel.DataAnnotations.Schema.ForeignKey]
//设置为外键

[Required]
//不允许空值

[MaxLength(255)]
//最大长度

[MinLength(10)]
//最小长度

[Timestamp]
//并发时间戳，为开放式并发环境配置时间戳。一个实体只能有一个byte [ ] 类型的属性可设置此特性，Sql Server称其为TimeStamp（时间戳），其他数据库称其为RowVersion（行版本）

[ConcurrencyCheck]
//并发非时间戳，当并发冲突发生时，这将为并发提供检查确保不会发生异常。对应的字段类似：public int SocialSecurityNumber { get; set; }

[NotMapped]

//不映射到数据库的列，System.ComponentModel.DataAnnotations.Schema

2.Fluent API配置（System.Data.Entity.ModelConfiguration和System.Data.Entity）

创建一个从EntityTypeConfiguration<T>（System.Data.Entity.ModelConfiguration）派生的类型，然后在这个类型的构造函数中设置实体属性的特性，然后重写自定义的EF上下文从基类继承的OnModelCreating()方法，该方法会在创建表之前将配置信息应用到数据库，所以将每一个实体类属性的配置信息注册在ModelBuilder.Configurations集合中即可。

ToTable(tableNameString )
//设置映射为数据库的表名

HasKey(lambda )
//主键，且种子增量每次+1，即自动增长，增量为1

HasPrecision(n1 , n2 )
//为decimal类型的属性保留有效位数和小数位数，n1为有效位数，n2为小数位数

Property(lambda ).HasDatabaseGeneratedOption(System.ComponentModel.DataAnnotations.Schema.DatabaseGeneratedOption.Identity )
//如果主键类型是Guid，则必须配置此项，否则不会自动生成唯一标识

Property(lambda ).IsRequired()
//不允许空

Property(lambda ).HasMaxLength()
//字符长度，与数据库表字段的字符长度一样，设为100则生成nvarchar(100)

Property(lambda ).HasColumnType(DBTableColumnType )
//设置字段在数据库表中的列的数据类型，C#有int string datetime类型，但没有数据库表字段的image、text类型，这两个类型可以使用HasColumnType

Property(lambda ).IsRowVersion()
//并发时间戳，为开放式并发环境配置时间戳。一个实体只能有一个byte [ ] 类型的属性可设置此特性，Sql Server称其为TimeStamp（时间戳），其他数据库称其为RowVersion（行版本）

Property(lambda ).IsConcurrencyToken(annotationName , val )
//添加约束
//示例：为多个字段添加同一个唯一性约束
using System.Data.Entity.Infrastructure.Annotations;
using System.ComponentModel.DataAnnotations.Schema;
Property(lambda ).HasColumnAnnotation(IndexAnnotation.AnnotationName , new IndexAnnotation( new IndexAttribute( "Un_sameRecords" , 1 ) { IsUnique = true } ) );
Property(d => d.TbRightId ).HasColumnAnnotation(IndexAnnotation.AnnotationName , new IndexAnnotation( new IndexAttribute( "Un_sameRecords" , 2 ) { IsUnique = true } ) );

拆分实体到多个表

一个实体拆分成两张表

public class Employee
{
    public int EmployeeId { get; set; }
    public string EmployeeName { get; set; }
    public string EmployeeAddress { get; set; }
}

public class EmployeeConfig : EntityTypeConfiguration<Employee>
{
    public EmployeeConfig()
    {
        HasKey(employee => employee.EmployeeId);
        Map(m => {
            m.Properties( property => new { property.EmployeeId, property.EmployeeName });
            m.ToTable("Employees");
        })
        .Map(m => {
            m.Properties( property => new { property.EmployeeId, property.EmployeeAddress });
            m.ToTable("EmployeeInfos"); });
    }
}

待续……

参考资料

EF里一对一、一对多、多对多关系的配置和级联删除

Entity Framework Code First （五）Fluent API - 配置关系

《Entity Framework 6 Recipes》中文翻译系列

//双向引用

码农公寓

实体关系

一对多关系

单向一对一

双向一对一

多对多

EF设计器

创建EF上下文对象

创建实体

创建属性

设置实体集的名称

根据实体生成数据库

根据数据库生成实体

操作实体

实体关系

一对多关系

多对多关系

第一种多对多关系

第二种多对多关系

自引用关系

Code First模式

Code First模式创建实体关系映射

实体关系的设置分三个步骤

一对一的code first

单向引用：在实体没有外键的情况下由EF自动创建数据库表的外键

单向引用：在实体有外键的情况下由你自己手动指定数据库表的外键

双向引用：在实体没有外键的情况下由EF自动创建数据库表的外键

双向引用：在实体有外键的情况下由你自己手动指定数据库表的外键

一对多的code first

在实体没有外键的情况下由EF自动创建数据库表的外键

在实体有外键的情况下由你自己手动指定数据库表的外键

多对多的code first

自引用的code first

数据库的code first

配置实体属性

1.Data Annotations配置（System.ComponentModel.DataAnnotations）

2.Fluent API配置 （System.Data.Entity.ModelConfiguration和System.Data.Entity）

拆分实体到多个表

相关文章

2.Fluent API配置（System.Data.Entity.ModelConfiguration和System.Data.Entity）