Code First之所以能夠讓開發人員以一種更加高效、靈活的方式進行資料操作有一個重要的原因在於它的約定配置。現在軟體開發越來複雜，大家也都試圖將軟體設計的越來越靈活，很多內容我們都希望是可配置的，但是過多的配置也會帶來很大的工作量，解決這個問題的方法就是約定。對於一些簡單的，不太可能經常變化的內容我們以一種約定的方式進行設計。使用過其他ORM框架的朋友可能知道一般ORM都有對應的對映配置檔案（一般是一個Xml檔案），但是EF並沒有。在EF中是以一種約定的方式進行表、列同實體類進行對映的，與此同時為了提高最大的靈活性EF中可以通過Fluent API和Data Annotations兩種方式對對映進行靈活配置。

EF預設約定

我們先來看一下EF對於資料類（概念模型，或域模型）的預設約定：

• 將資料類的類名複數形式作為資料表名稱，並且使用“dbo”作為預設架構。

例如定義一個Person資料類，那麼將會自動生成“dbo.People”表。

• 將資料類中的“ID”屬性或者“<類名>+ID”作為主鍵（不區分大小寫），並且如果該列為數值型別或者GUID列將作為標識列。

例如在Order類中如果有ID或者OrderID屬性將預設作為主鍵，二者均出現優先使用 “ID”屬性。

• 使用導航屬性約束兩個表之間的關係，在從表資料類中除了導航屬性，推薦定義一個外來鍵屬性在從表資料類中（如果不指定將預設生成一個“<主表類名>+<主表類的主鍵名>”的外來鍵列；此外在主表中推薦定義一個集合從表屬性使用者導航，當然這個屬性不定義也可以正常生成外來鍵關係但是不利於使用），具體規則：“<導航屬性名>+<主表的主鍵屬性名>”或者“<主表類名>+<主鍵屬性名>”又或者“<主表的主鍵屬性名>”,其屬性名不區分大小寫並且如果出現多種匹配按照先後順序匹配；如果不存在外來鍵屬性則外來鍵關係註冊為可選的，否則註冊為必選項並且此時將設定級聯刪除關係；如果在從表類中有多個導航屬性對應同一個資料類那麼需要使用fluent API或者Data Annotations進行手動配置。

例如有一個Order類，主鍵為OrderID，在OrderDetail類中有一個導航屬性Order（Order型別），那麼當你定義一個OrderID在OrderDetail中，那麼在Order和OrderDetail直接將建立一個級聯刪除關係。

• 當EF按照上述規則在資料類中沒有找到主鍵屬性時(或者通過fluent API、Data Annotations沒有定義)將認為此類為“複雜型別”（對於不瞭解複雜型別的朋友請點選這裡What is a Complex Type）。

例如在“Person”資料類中有一個“Name”屬性，但是資料庫中可能將“Name”分為FirstName和LastName儲存，此時就可以定義一個Name類，在此類中不定義主鍵列定義“FirstName”和“LastName”屬性，就會在表“dbo.People”中生成“Name_FirstName”和“Name_LastName”列。

定義約定

EF的預設約定不是一成不變的，我們可以選擇移除和修改它，例如EF預設生成資料表時將資料類名的複數形式作為表名，下面的程式碼就可以移除這個規則：

1. using System;  
2. using System.Collections.Generic;  
3. using System.Linq;  
4. using System.Text;  
5. using System.Data.Entity;  
6. using CodeFirst.Entities;  
7. using System.ComponentModel.DataAnnotations.Schema;  
8. using System.Data.Entity.ModelConfiguration.Conventions;  
9. namespace CodeFirst  
10. {  
11.     publicclass OrderContext:DbContext  
12.     {  
13.         public OrderContext()  
14.             : base("CodeFirstDb")  
15.         {  
16.             Database.SetInitializer<OrderContext>(  
17.                 new DropCreateDatabaseIfModelChanges<OrderContext>()  
18.             );  
19.         }  
20.         public DbSet<Person> Person  
21.         {  
22.             get;  
23.             set;  
24.         }  
25.         protectedoverridevoid OnModelCreating(DbModelBuilder modelBuilder)  
26.         {  
27.             base.OnModelCreating(modelBuilder);  
28.             modelBuilder.Conventions.Remove<PluralizingTableNameConvention>();  
29.         }  
30.     }  
31. }  

這些規則都在“System.Data.Entity.ModelConfiguration.Conventions”名稱空間下，可以根據實際情況進行選擇。

一般情況下我們是不需要移除預設約定的，我們更多的時候是要修改豐富這些約定，達到對生成規則的更多細節控制。在EF提供了兩種方式進行對映配置：Data Annotations和Fluent API。

DataAnnotations

DataAnnotations是ASP.NET WEB中新增的一種驗證方式，但是在EF中它又可以對對映關係進行控制，相比較Fluent API使用起來要簡單一些。下面我們通過一個例子對DataAnnotations進行說明。在此我們假設有一個“Employee”類用於描述員工資訊，一個“Customer”類用於描述客戶資訊，還有一個“Order”類用於描述訂單資訊，此外還有一個“Name”複雜型別表示人員姓名。在Order類中有一個屬性“Customer”用於描述此訂單的客戶，它是“Customer”型別；還有一個“DeliverPerson”屬性用於描述訂單發貨人，一個“CheckPerson”屬性使用者描述訂單揀貨人，它們都是“Employee”型別。下面是具體程式碼：

Employee類：

1. using System;  
2. using System.Collections.Generic;  
3. using System.ComponentModel.DataAnnotations;  
4. using System.ComponentModel.DataAnnotations.Schema;  
5. using System.Linq;  
6. using System.Text;  
7. namespace CodeFirst.Entities  
8. {  
9.     [Table("People",Schema="Person")]  
10.     publicclass Employee  
11.     {  
12.         [Key]  
13.         publicint No  
14.         {  
15.             get;  
16.             set;  
17.         }  
18.         public Name Name  
19.         {  
20.             get;  
21.             set;  
22.         }  
23.         [MinLength(5),MaxLength(30)]  
24.         publicstring Title  
25.         {  
26.             get;  
27.             set;  
28.         }  
29.         [Required]  
30.         public DateTime BirthDate  
31.         {  
32.             get;  
33.             set;  
34.         }  
35.         [ConcurrencyCheck]  
36.         publicstring Address  
37.         {  
38.             get;  
39.             set;  
40.         }  
41.         [Column("Notes",TypeName="ntext",Order=5)]  
42.         publicstring Note  
43.         {  
44.             get;  
45.             set;  
46.         }  
47.         [DatabaseGenerated(System.ComponentModel.DataAnnotations.Schema.DatabaseGeneratedOption.Computed)]  
48.         public DateTime CreateDate  
49.         {  
50.             get;  
51.             set;  
52.         }  
53.         [NotMapped]  
54.         publicstring PhotoPath  
55.         {  
56.             get;  
57.             set;  
58.         }  
59.         [Timestamp]  
60.         publicbyte[] TimeStamp  
61.         {  
62.             get;  
63.             set;  
64.         }  
65.         [InverseProperty("DeliverPerson")]  
66.         public List<Order> DeliverOrder  
67.         {  
68.             get;  
69.             set;  
70.         }  
71.         [InverseProperty("CheckPerson")]  
72.         public List<Order> CheckOrder  
73.         {  
74.             get;  
75.             set;  
76.         }  
77.     }  
78. }  

Customer類：

1. using System;  
2. using System.Collections.Generic;  
3. using System.Linq;  
4. using System.Text;  
5. namespace CodeFirst.Entities  
6. {  
7.     publicclass Customer  
8.     {  
9.         publicint CustomerID  
10.         {  
11.             get;  
12.             set;  
13.         }  
14.         publicstring CompanyName  
15.         {  
16.             get;  
17.             set;  
18.         }  
19.     }  
20. }  

Name類：

1. using System;  
2. using System.Collections.Generic;  
3. using System.ComponentModel.DataAnnotations.Schema;  
4. using System.Linq;  
5. using System.Text;  
6. namespace CodeFirst.Entities  
7. {  
8.     [ComplexType]//根據前面我們說的預設約定，不標記為ComplexType只有沒有找到ID也會將Name作為一個複雜型別
9.     publicclass Name  
10.     {  
11.         publicstring FirstName  
12.         {  
13.             get;  
14.             set;  
15.         }  
16.         publicstring LastName  
17.         {  
18.             get;  
19.             set;  
20.         }  
21.     }  
22. }  

Order類：

1. using System;  
2. using System.Collections.Generic;  
3. using System.ComponentModel.DataAnnotations.Schema;  
4. using System.Linq;  
5. using System.Text;  
6. namespace CodeFirst.Entities  
7. {  
8.     publicclass Order  
9.     {  
10.         publicint OrderID   
11.         {   
12.             get;   
13.             set;   
14.         }  
15.         publicstring OrderTitle   
16.         {   
17.             get;   
18.             set;   
19.         }  
20.         publicstring CustomerName   
21.         {   
22.             get;   
23.             set;   
24.         }  
25.         public DateTime TransactionDate   
26.         {   
27.             get;   
28.             set;   
29.         }  
30.         publicint CustomerNo  
31.         {  
32.             get;  
33.             set;  
34.         }  
35.         [ForeignKey("CustomerNo")]  
36.         public Customer Customer  
37.         {  
38.             get;  
39.             set;  
40.         }  
41.         public Employee DeliverPerson  
42.         {  
43.             get;  
44.             set;  
45.         }  
46.         public Employee CheckPerson  
47.         {  
48.             get;  
49.             set;  
50.         }  
51.     }  
52. }  

這是通過Data Annotations配置後EF生成的資料庫表結構：

下面解釋每個配置的作用

Table：用於指定生成表的表名、架構資訊。

Column：用於指定生成資料表的列資訊，如列名、資料型別、順序等。

Key：用於指定任何名稱的屬性作為主鍵列並且預設將此列作為標識列（如果不想預設生成標識可以指定“DatabaseGenerated”屬性的值為“None”），如果不指定此標記屬性，將根據EF預設約定建立主鍵。如上程式碼指定“No”為“Employee”的主鍵。

Required：使用者指定非空列，如上面的“BirthDay”建立列之後為“not null”列。

MinLength、MaxLength：指定欄位長度（此屬性通常可以使用者客戶端驗證），例如上面“Title”定義成了“nvarchar(30)”。

ComplexType：用於標記複雜型別，對於包含複雜型別資料屬性的類在生成資料表時複雜型別中每個屬性都將作為其中一列。

DatabaseGenerated：用於指定資料庫欄位生成列，此類EF將不會直接更新。可以指定為計算列、標識列和非資料庫生成列（例如給主鍵列指定此屬性為“None”則不會生成標識列）。需要注意的是如果使用Code First欄位生成資料庫，那麼此屬性僅僅可以用於byte、timestamp列上，否則請應用在已經存在資料庫的情況下，因為Code First無法判定生成具體計算列的公式（至少目前Code First還不支援公式配置）。

NotMapped：使用者指定非對映列，標記此屬性的列將不會在資料庫中生成相應的列，例如上面的“PhotoPath ”沒有在資料庫中生成具體列，實際使用中它可能是通過其他具體規則得到的。

ConcurrencyCheck：用於進行併發檢查，當一個使用者A獲得實體後通常會與資料庫斷開，此時如果另一個使用者B也獲得了實體並進行了修改，那麼當A再進行更新時如果進行了“ConcurrencyCheck”標記則會進行併發檢查，並根據原始值判斷該實體是否存在，如果不存在則丟擲異常。

TimeStamp：用於指定時間戳列，一個實體只能有一個TimeStamp列。在EF中TimeStamp是另一種併發控制方式，當EF遇到TimeStamp列會自動配置 “ConcurrencyCheck”及“DatabaseGenerated.Computed”來控制併發（通常我們推薦使用此方法）。

ForeignKey：用於指定外來鍵列，我們知道按照上面提到的預設約定第三條，當我們在“Order”中定義了“Customer”屬性後，如果定義“CustomerID” 屬性（當然還有其他形式，大家可以按照宣告說的預設約定3進行測試），那麼EF會在“Order”表中建立一個“CustomerID”列並建立與“Customer”表的外來鍵關係。但是如果像上面定義“CustomerNo”屬性並且不指定“ForeignKey”標記的話將達不到我們的預期，EF將預設建立一個“Customer_CustomerID”列並建立與“Customer”的外來鍵約束，同時建立一個“CustomerNo”列。當然解決的方式大家已經看到了那就是給導航屬性“Customer”指定“ForegnKey”標記並且指定外來鍵列為“CustomerNo”（注意雖然在“Customer”中不定義“Order的導航屬性”生成的表中也並沒用任何問題，但是我們推薦您定義相應的導航屬性）。

InverseProperty：用於定義多重外來鍵關係約束。我們在EF中通過導航屬性定義主外來鍵關係，但是當主表中有兩個外來鍵約束時可能僅僅通過新增相應的導航屬性就無法完成了，例如上面“Order”中“DeliverPerson”和“CheckPerson”均為“Employee”型別，按我們的預期當然是在生成“Order”表時生成兩個外來鍵列並建立與“Employee”外來鍵約束關係，但是如果沒有在“Employee”類的“DeliverOrder”和“CheckOrder”屬性上標記 “InverseProperty”屬性EF是無法識別這種關係的（具體結果可以看下圖），當然解決方式就是在對應導航屬性中標記“InverseProperty”並指定對於的列名。

注意：DataAnnotations可以同時在同一個類後者屬性上使用多個標記屬性，上面的例子中對於每個類或屬性只使用了一個單獨的標記屬性是為了說明起來更加簡單；另外宣告的例子中同時使用“ConcurrencyCheck”和“TimeStamp”指定了不同的列只是為了演示，一般情況下我們通過其中一種方式即可。

Fluent API

Fluent API一般配置

儘管我們可以通過Data Annotations進行對映關係約定，但是相比較而言Fluent API的功能更加強大，從功能上而言Data Annotations是Fluent API的一個子集， Data Annotations可以實現的功能Fluent API都能實現。下面我們先看一個例子，在這個例子中我們通過Fluent API約定方式實現上面Data Annotations的功能並且包含更多控制：

1. using System;  
2. using System.Collections.Generic;  
3. using System.Linq;  
4. using System.Text;  
5. using System.Data.Entity;  
6. using CodeFirst.Entities;  
7. using System.ComponentModel.DataAnnotations.Schema;  
8. using System.Data.Entity.ModelConfiguration.Conventions;  
9. namespace CodeFirst  
10. {  
11.     publicclass OrderContext:DbContext  
12.     {  
13.         public OrderContext()  
14.             : base("CodeFirstDb")  
15.         {  
16.             Database.SetInitializer<OrderContext>(  
17.                 new DropCreateDatabaseIfModelChanges<OrderContext>()  
18.             );  
19.         }  
20.         public DbSet<Order> Orders  
21.         {  
22.             get;  
23.             set;  
24.         }  
25.         public DbSet<Employee> Employees  
26.         {  
27.             get;  
28.             set;  
29.         }  
30.         protectedoverridevoid OnModelCreating(DbModelBuilder modelBuilder)  
31.         {  
32.             base.OnModelCreating(modelBuilder);  
33.             modelBuilder.Entity<Employee>().ToTable("People", "Person");//指定“Employee”對應表名及架構
34.             modelBuilder.Entity<Employee>().HasKey(emp => emp.No);//定義主鍵為“No”
35.             //modelBuilder.Entity<Employee>().HasKey(emp => new { emp.No, emp.Title });//指定"No"和“Title”作為複合主鍵，使用Data Annotations無法做到
36.             modelBuilder.Entity<Employee>().Property(emp => emp.No).HasDatabaseGeneratedOption(DatabaseGeneratedOption.None);//去掉標識列，前面我們也提到過通過Data Annotations通用可以去掉主鍵預設標示屬性
37.             modelBuilder.Entity<Employee>().Property(emp => emp.Title).HasMaxLength(30);//指定“Title”最大長度為30
38.             modelBuilder.Entity<Employee>().Property(emp => emp.BirthDate).IsRequired();//指定“BirthDate”為不可為空
39.             modelBuilder.Entity<Employee>().Property(emp => emp.Note).HasColumnName("Notes").HasColumnType("ntext");//指定“Note”對應列名為“Notes”，並指定資料型別
40.             modelBuilder.Entity<Employee>().Ignore(emp => emp.PhotoPath);//指定“PhotoPath”為非對映列
41.             modelBuilder.Entity<Employee>().Property(emp => emp.Title).IsUnicode(true);//“Title”列是否支援Unicode編碼
42.             modelBuilder.ComplexType<Name>().Property(n=>n.FirstName).HasMaxLength(50);//指定Name為複雜資料型別，並指定複雜型別中“FirstName”長度
43.             //modelBuilder.Entity<Employee>().Property(emp => emp.Name.LastName).HasMaxLength(20);//還可以通過這種方式指定複雜型別“Name”的“LastName”列的長度
44.             //modelBuilder.Entity<Employee>().Property(emp => emp.Address).IsConcurrencyToken();//指定“Address”進行併發控制,通常這一列我們知道為“TimeStamp”列而不是“Addree”這裡只是為了說明可以標記其他列
45.             modelBuilder.Entity<Employee>().Property(emp => emp.TimeStamp).IsRowVersion();//通過指定“TimeStamp”進行併發版本控制
46.         }  
47.     }  
48. }  

從上面的程式碼中可以看到基本上在Data Annotations中實現的功能使用Fluent API都實現了，並且在上面的程式碼註釋中我也提到了一些Data Annotations無法實現的功能，具體程式碼基本上都已經註釋了在此也不再解釋了。

Fluent API關係配置

下面讓看一下EF中關係配置的實現，看一下Fluent API如何進行實體關係約束，這裡假設每個公司員工“Employee”在企業內部都有一個通訊賬戶“MessagingAcount”，這二者之間是一對一的關係；同時新增一個產品類“Product”，它與“Order”的關係是多對多的關係，具體定義如下：

MessageAcount類：

1. using System;  
2. using System.Collections.Generic;  
3. using System.ComponentModel.DataAnnotations;  
4. using System.Linq;  
5. using System.Text;  
6. namespace CodeFirst.Entities  
7. {  
8.     publicclass MessagingAccount  
9.     {  
10.         [Key()]  
11.         publicint EmployeeNo  
12.         {  
13.             get;  
14.             set;  
15.         }  
16.         public Employee Employee  
17.         {  
18.             get;  
19.             set;  
20.         }  
21.         publicstring UserName  
22.         {  
23.             get;  
24.             set;  
25.         }  
26.         publicstring Password  
27.         {  
28.             get;  
29.             set;  
30.         }  
31.     }  
32. }  

Product類：

1. using System;  
2. using System.Collections.Generic;  
3. using System.Linq;  
4. using System.Text;  
5. namespace CodeFirst.Entities  
6. {  
7.     publicclass Product  
8.     {  
9.         publicint ProductID  
10.         {  
11.             get;  
12.             set;  
13.         }  
14.         publicstring ProductName  
15.         {  
16.             get;  
17.             set;  
18.         }  
19.         publicdouble UnitPrice  
20.         {  
21.             get;  
22.             set;  
23.         }  
24.         publicint OrderID  
25.         {  
26.             get;  
27.             set;  
28.         }  
29.         public List<Order> Orders  
30.         {  
31.             get;  
32.             set;  
33.         }  
34.     }  
35. }  

Employee類（添加了對應的屬性）：

1. using System;  
2. using System.Collections.Generic;  
3. using System.ComponentModel.DataAnnotations;  
4. using System.ComponentModel.DataAnnotations.Schema;  
5. using System.Linq;  
6. using System.Text;  
7. namespace CodeFirst.Entities  
8. {  
9.     publicclass Employee  
10.     {  
11.         publicint No  
12.         {  
13.             get;  
14.             set;  
15.         }  
16.         public Name Name  
17.         {  
18.             get;  
19.             set;  
20.         }  
21.         publicstring Title  
22.         {  
23.             get;  
24.             set;  
25.         }  
26.         public DateTime BirthDate  
27.         {  
28.             get;  
29.             set;  
30.         }  
31.         publicstring Address  
32.         {  
33.             get;  
34.             set;  
35.         }  
36.         publicstring Note  
37.         {  
38.             get;  
39.             set;  
40.         }  
41.         public DateTime CreateDate  
42.         {  
43.             get;  
44.             set;  
45.         }  
46.         publicstring PhotoPath  
47.         {  
48.             get;  
49.             set;  
50.         }  
51.         publicbyte[] TimeStamp  
52.         {  
53.             get;  
54.             set;  
55.         }  
56.         public List<Order> DeliverOrder  
57.         {  
58.             get;  
59.             set;  
60.         }  
61.         public List<Order> CheckOrder  
62.         {  
63.             get;  
64.             set;  
65.         }  
66.         public MessagingAccount Acount  
67.         {  
68.             get;  
69.             set;  
70.         }  
71.     }  
72. }  

Order類（添加了對應的屬性）：

1. using System;  
2. using System.Collections.Generic;  
3. using System.ComponentModel.DataAnnotations.Schema;  
4. using System.Linq;  
5. using System.Text;  
6. namespace CodeFirst.Entities  
7. {  
8.     publicclass Order  
9.     {  
10.         publicint OrderID   
11.         {   
12.             get;   
13.             set;   
14.         }  
15.         publicstring OrderTitle   
16.         {   
17.             get;   
18.             set;   
19.         }  
20.         publicstring CustomerName   
21.         {   
22.             get;   
23.             set;   
24.         }  
25.         public DateTime TransactionDate   
26.         {   
27.             get;   
28.             set;   
29.         }  
30.         publicint CustomerNo  
31.         {  
32.             get;  
33.             set;  
34.         }  
35.         public Customer Customer  
36.         {  
37.             get;  
38.             set;  
39.         }  
40.         publicint ProductID  
41.         {  
42.             get;  
43.             set;  
44.         }  
45.         public List<Product> Products  
46.         {  
47.             get;  
48.             set;  
49.         }  
50.         public Employee DeliverPerson  
51.         {  
52.             get;  
53.             set;  
54.         }  
55.         public Employee CheckPerson  
56.         {  
57.             get;  
58.             set;  
59.         }  
60.     }  
61. }  

OrderContext類，定義了資料類之間的關係，主要是關係配置部分：

1. using System;  
2. using System.Collections.Generic;  
3. using System.Linq;  
4. using System.Text;  
5. using System.Data.Entity;  
6. using CodeFirst.Entities;  
7. using System.ComponentModel.DataAnnotations.Schema;  
8. using System.Data.Entity.ModelConfiguration.Conventions;  
9. namespace CodeFirst  
10. {  
11.     publicclass OrderContext:DbContext  
12.     {  
13.         public OrderContext()  
14.             : base("CodeFirstDb")  
15.         {  
16.             Database.SetInitializer<OrderContext>(  
17.                 new DropCreateDatabaseIfModelChanges<OrderContext>()  
18.             );  
19.         }  
20.         public DbSet<Order> Orders  
21.         {  
22.             get;  
23.             set;  
24.         }  
25.         public DbSet<Employee> Employees  
26.         {  
27.             get;  
28.             set;  
29.         }  
30.         protectedoverridevoid OnModelCreating(DbModelBuilder modelBuilder)  
31.         {  
32.             base.OnModelCreating(modelBuilder);  
33.             modelBuilder.Entity<Employee>().ToTable("People", "Person");//指定“Employee”對應表名及架構
34.             modelBuilder.Entity<Employee>().HasKey(emp => emp.No);//定義主鍵為“No”
35.             //modelBuilder.Entity<Employee>().HasKey(emp => new { emp.No, emp.Title });//指定"No"和“Title”作為複合主鍵，使用Data Annotations無法做到
36.             modelBuilder.Entity<Employee>().Property(emp => emp.No).HasDatabaseGeneratedOption(DatabaseGeneratedOption.None);//去掉標識列，前面我們也提到過通過Data Annotations通用可以去掉主鍵預設標示屬性
37.             modelBuilder.Entity<Employee>().Property(emp => emp.Title).HasMaxLength(30);//指定“Title”最大長度為30
38.             modelBuilder.Entity<Employee>().Property(emp => emp.BirthDate).IsRequired();//指定“BirthDate”為不可為空
39.             modelBuilder.Entity<Employee>().Property(emp => emp.Note).HasColumnName("Notes").HasColumnType("ntext");//指定“Note”對應列名為“Notes”，並指定資料型別
40.             modelBuilder.Entity<Employee>().Ignore(emp => emp.PhotoPath);//指定“PhotoPath”為非對映列
41.             //modelBuilder.Entity<Customer>().HasRequired(c=>c.Orders).WithMany().Map(m=>m.MapKey("CustomerOrder"));
42.             modelBuilder.Entity<Employee>().Property(emp => emp.Title).IsUnicode(true);//“Title”列是否支援Unicode編碼
43.             modelBuilder.ComplexType<Name>().Property(n=>n.FirstName).HasMaxLength(50);//指定Name為複雜資料型別，並指定複雜型別中“FirstName”長度
44.             //modelBuilder.Entity<Employee>().Property(emp => emp.Name.LastName).HasMaxLength(20);//還可以通過這種方式指定複雜型別“Name”的“LastName”列的長度
45.             //modelBuilder.Entity<Employee>().Property(emp => emp.Address).IsConcurrencyToken();//指定“Address”進行併發控制,通常這一列我們知道為“TimeStamp”列而不是“Addree”這裡只是為了說明可以標記其他列
46.             modelBuilder.Entity<Employee>().Property(emp => emp.TimeStamp).IsRowVersion();//通過指定“TimeStamp”進行併發版本控制
47.             /*下面程式碼演示EF中的關係約束*/
48.             //modelBuilder.Entity<MessagingAccount>().HasRequired(a => a.Employee).WithOptional(emp => emp.Acount);//配置一對零關係，允許存在一個Employee而不存在MessagingAcount的情況(注意在Employee中新增Acont屬性)
49.             modelBuilder.Entity<Employee>().HasRequired(emp => emp.Acount).WithRequiredPrincipal(a => a.Employee);//配置一對一關係，和上面的WithOptionnal關係區別是每個Employee必須有一個MessagingAcount而每個MessageAcount也必須有一個Employee；但是Employee是主表，此時允許Employee單獨持久化而不允許MessagingAcount單獨持久化
50.             //注意配置一對一關係也可以使用WithRequiredDependent，只不過主表發生了變化，上面的語句與下面的語句是等價的
51.             //modelBuilder.Entity<MessagingAccount>().HasRequired(a => a.Employee).WithRequiredDependent(a => a.Acount);//
52.             //下面的方法解決了一對一的關係，此時Employee和MessageAcount將必須同時存在
53.             //modelBuilder.Entity<Employee>().HasRequired(emp => emp.Acount).WithMany().HasForeignKey(emp => emp.MessagingAccountID);
54.             //modelBuilder.Entity<MessagingAccount>().HasRequired(a => a.Employee).WithMany().HasForeignKey(a => a.EmployeeNo);
55.             //modelBuilder.Entity<Order>().HasRequired(o=>o.Customer).WithMany();//一對多的關係，一個Customer有多個Order（注意，執行之前先把Order中CustomerNo和Customer中的Orders屬性刪除掉，否則將生成兩個外來鍵一個是自動生成的另一個是Fluent API配置生成的，對應這種關係推薦使用預設生成）
56.             //modelBuilder.Entity<Order>().HasRequired(o => o.Customer).WithMany().WillCascadeOnDelete();//新增新增級聯刪除
57.             //modelBuilder.Entity<Order>().HasRequired(o => o.Customer).WithMany().Map(m=>m.MapKey("Customer_Order");//外來鍵重新命名
58.             //modelBuilder.Entity<Order>().HasRequired(o => o.Customer).WithMany().HasForeignKey(o => new { o.CustomerNo,o.CustomerName});//組合外來鍵，注意本例中沒有組合外來鍵（CustomerName不是外來鍵），這裡只是舉例而已
59.             //modelBuilder.Entity<Order>().HasRequired(o => o.Customer).WithMany(c=>c.Orders).HasForeignKey(o => o.CustomerNo);//指定外來鍵（一般使用者外來鍵名不符合預設約束命名時）
60.             modelBuilder.Entity<Order>().HasMany(o => o.Products).WithMany(p => p.Orders).Map(m => {  
61.                 m.ToTable("OrderDetails");  
62.                 m.MapLeftKey("OrderID");  
63.