《Entity Framework 6 Recipes》中文翻译系列 (41) ------ 第七章 使用对象服务之标识关系中使用依赖实体与异步查询保存

时间:2022-09-15 10:37:26

翻译的初衷以及为什么选择《Entity Framework 6 Recipes》来学习,请看本系列开篇

7-7  标识关系中使用依赖实体

问题

  你想在标识关系中插入,更新和删除一个依赖实体。

解决方案

  假设你有如图7-8所示的模型。实体LineItem的实体键是一个复合键。由InvoiceNumber和ItemNumber复合而成。InvoiceNumber同是也是一个外键。

《Entity Framework 6 Recipes》中文翻译系列 (41) ------ 第七章 使用对象服务之标识关系中使用依赖实体与异步查询保存

图7-8. Invoie和LineItem是一个标识关系,这是因为实体LineItem的复合实体键

  当实体的一个属性,既是实体键又是外键时,就可以说这个实体在一个标识关系中。在我们的模型里,实体LineItem的实体键,它的标识,同时也是相对于实体Invoice的外键。实体LineItem被称作依赖实体(depaendent entity),Invoice被称作主实体(principal entity)。

  实体框架在处理如何删除标识关系中的依赖实体时,有所不同。因为依赖实体不能离开标识关系而存在。简单地从主实体的集合中删除依赖实体,在实体框架中的结果是,删除的依赖实体被标记为删除状态。另外,删除主实体,会连同依赖实体一直被标记为删除。这让我们想起数据库中级联删除。当然,实体框架还允许显式删除依赖实体。 代码清单7-5演示了这三种不同的场景。

代码清单7-5. 删除依赖实体

  public static class Recipe7Program
{
public static void Run()
{
using (var context = new Recipe7Context())
{ var invoice1 = new Invoice
{
BilledTo = "Julie Kerns",
InvoiceDate = DateTime.Parse("9/19/2013")
};
var invoice2 = new Invoice
{
BilledTo = "Jim Stevens",
InvoiceDate = DateTime.Parse("9/21/2013")
};
var invoice3 = new Invoice
{
BilledTo ="Juanita James",
InvoiceDate = DateTime.Parse("9/23/2013")
};
context.LineItems.Add(new LineItem
{
Cost = 99.29M,
Invoice = invoice1
});
context.LineItems.Add(new LineItem
{
Cost = 29.95M,
Invoice = invoice1
});
context.LineItems.Add(new LineItem
{
Cost = 109.95M,
Invoice = invoice2
});
context.LineItems.Add(new LineItem
{
Cost = 49.95M,
Invoice = invoice3
});
context.SaveChanges(); // 显示LineItems
Console.WriteLine("Original set of line items...");
DisplayLineItems(); //从invoice1的集合中移除一个LineItem
var item = invoice1.LineItems.ToList().First();
invoice1.LineItems.Remove(item);
context.SaveChanges();
Console.WriteLine("\nAfter removing a line item from an invoice...");
DisplayLineItems(); // 移除 invoice2
context.Invoices.Remove(invoice2);
context.SaveChanges();
Console.WriteLine("\nAfter removing an invoice...");
DisplayLineItems(); //单独移除一个LineItem
context.LineItems.Remove(invoice1.LineItems.First());
context.SaveChanges();
Console.WriteLine("\nAfter removing a line item...");
DisplayLineItems(); //单独更新一个LineItem
var item2 = invoice3.LineItems.ToList().First();
item2.Cost = 39.95M;
context.SaveChanges();
Console.WriteLine("\nAfter updating a line item from an invoice …");
DisplayLineItems();
}
} static void DisplayLineItems()
{
bool found = false;
using (var context = new Recipe7Context())
{
foreach (var lineitem in context.LineItems)
{
Console.WriteLine("Line item: Cost {0}",
lineitem.Cost.ToString("C"));
found = true;
}
}
if (!found)
Console.WriteLine("No line items found!");
} }

代码清单7-5的输出如下:

Original set of line items...
Line item: Cost $99.29
Line item: Cost $29.95
Line item: Cost $109.95
Line item: Cost $49.95
After removing a line item from an invoice...
Line item: Cost $29.95
Line item: Cost $109.95
Line item: Cost $49.95
After removing an invoice...
Line item: Cost $29.95
After removing a line item...
Line item: Cost $49.95
After updating a line item...
Line item: Cost $39.95

原理

  代码清单7-5使用三种方法删除LineItem。第一种从Invoice的集合中删除。因为一个LineItem依赖Invoice的标识,实体框架标记引用的LineItme对象为删除状态。第二种是删除invoice对象,实体框架会标记所有的依赖于此对象的lineItme为删除状态。最后一种,是直接调用Remove()方法从上下文对象中的LineItems实体集中删除最后剩下的一个lineItem对象。

  你可以修改依赖实体的,除了标识关系中的属性以外的所有属性。在我们的模型中,可以修改实体LineItem中的Cost属性。但不能修改Invoice导航属性。

  当我们保存一个标识关系中的主实体对象时,它的实体键值是从数据库中产生(由存储层产生值),并被写回到主实体对象,以及它的所有依赖实体中的。这得确保所有的操作在数据库上下文中都是同步进行的。

7-8  使用数据库上下文插入实体

问题

  你想使用数据上下文将模型中实体插入到数据库中。

解决方案

  假设你有如图7-9所示的模型。

《Entity Framework 6 Recipes》中文翻译系列 (41) ------ 第七章 使用对象服务之标识关系中使用依赖实体与异步查询保存

图7-9 一个包含实体employee和task的模型

  图7-9中的模型表示员工和他们的任务。你想插入一个新的员工和它的任务到数据库中。为了插入一个员工,创建一个Employee的实例并调用上下文对象中Employees实体集中的方法Add()。为了添加员工的一个任务,创建一个Task的实例,并将它添加到employee对象的Tasks集合中。 你还必须调用Add()方法将employee和task添加到数据库上下文中。最后,调用SaveChanges()方法,将这些变化持久化到数据库中。

  代码清单7-6演示了,使用Add()方法添加新对象到上下文中,并调用SaveChanges()方法持久化到数据库中。

代码清单7-6. 插入新实体到数据库

  public static class Recipe8Program
{
public static void Run()
{
using (var context = new Recipe8Context())
{
var employee1 = new Employee
{
EmployeeNumber = ,
Name = "Robin Rosen",
Salary = 106000M
};
var employee2 = new Employee
{
EmployeeNumber = ,
Name = "Bill Moore",
Salary = 62500M
};
var task1 = new Task { Description = "Report 3rd Qtr Accounting" };
var task2 = new Task { Description = "Forecast 4th Qtr Sales" };
var task3 = new Task { Description = "Prepare Sales Tax Report" }; //在Employees实体集上使用Add()方法
context.Employees.Add(employee1); //添加两个新的task到employee1的Tasks中
employee1.Tasks.Add(task1);
employee1.Tasks.Add(task2); // 添加一个task到employee2的Tasks中,并使用Add()方法添加task到上下文中
employee2.Tasks.Add(task3);
context.Tasks.Add(task3); //持久化到数据库
context.SaveChanges();
} using (var context = new Recipe8Context())
{
foreach (var employee in context.Employees)
{
Console.WriteLine("Employee: {0}'s Tasks", employee.Name);
foreach (var task in employee.Tasks)
{
Console.WriteLine("\t{0}", task.Description);
}
}
} }
}

代码清单7-6的输出如下:

Employee: Bill Moore's Tasks
Prepare Sales Tax Repor
Employee: Robin Rosen's Tasks
Report 3rd Qtr Accounti
Forecast 4th Qtr Sales

原理

  在代码清单7-6中,我们使用实体集Employees和Tasks中的Add()方法,添加实体到数据库上下文中。

  当你添加一个实体到上下文中,实体框架会为这个新加入的实体,创建一个临时实体键。 实体框架使用这个临时的键来唯一标识该实体。当实体被持久化到数据库后,这个临时的实体键,会被一个真正的键值给替换。如果添加到数据库中的两个实体被分配相同的实体键,实体框架会抛出一个异常。这种情况一般发生在客户端或者存储生成过程,给实体分配了相同的键值。

  对于外键关联,你可以使用关联实体的实体键分配给实体的外键属性。虽然涉及临时键值,但实体框架会在实体被保存到数据库后,正确地修正键和关系。

  你还可以使用Attach()方法来添加一个实体到上下文中。这是一个分为两步的过程,首先是调用Attach()方法。它将添加实体到上下文中,但是变化跟踪器一开始将实体标记为Unchanged状态。如果这时调用SaveChanges()方法,它不会将实体保存到数据库。第二步是,将实体递给上下文的Entry()方法,获得一个DBEntityEntry实例,并设置它的属性State为新的状态:EntityState.Added。这时调用SaveChanges()方法会将新实体保存到数据库。

7-9  异步查询和保存

问题

  你想在执行查询和持久化变更时,保持应用程序的响应性。

解决方案

  假设你有POCO实体,Account和Transaction,你想使用Code-First建模,如代码清单7-7所示。

  public class Account
{
public int AccountNumber { get; set; }
public string AccountHolder { get; set; } public virtual ICollection<Transaction> Transactions { get; set; }
} public class Transaction
{
public int AccountNumber { get; set; }
public int TransactionNumber { get; set; }
public DateTime TransactionDate { get; set; }
public decimal Amount { get; set; }
}

  实体Transaction显然是实体Account的依赖实体,所以我们通过创建一个EntityTypeConfiguration子类来为每个实体配置关系。如代码清单7-8所示。

代码清单7-8. 配置实体Account和Transaction

  public class AccountTypeConfiguration : EntityTypeConfiguration<Account>
{
public AccountTypeConfiguration()
{
HasKey(a => a.AccountNumber); Property(a => a.AccountNumber)
.HasDatabaseGeneratedOption(DatabaseGeneratedOption.Identity); HasMany(a => a.Transactions)
.WithRequired();
}
} public class TransactionTypeConfiguration : EntityTypeConfiguration<Transaction>
{
public TransactionTypeConfiguration()
{
HasKey(t => new {t.AccountNumber, t.TransactionNumber}); Property(t => t.TransactionNumber)
.HasDatabaseGeneratedOption(DatabaseGeneratedOption.Identity);
}
}

  最后,在代码清单7-9中,我们创建DbContext的子类并重写OnModelCreating方法,在这个方法中,我们添加实体配置到模型构建器的配置集合中。

代码清单7-9. 创建DbContext的子类

  public class Recipe9Context : DbContext
{
public DbSet<Account> Accounts { get; set; }
public DbSet<Transaction> Transactions { get; set; } public Recipe9Context() : base("name=EF6CodeFirstRecipesContext")
{ } protected override void OnModelCreating(DbModelBuilder modelBuilder)
{
base.OnModelCreating(modelBuilder); modelBuilder.Configurations.Add(new AccountTypeConfiguration());
modelBuilder.Configurations.Add(new TransactionTypeConfiguration());
}
}

  为了异步查询和保存,我们将分别使用LINQ to Entities方法ForEachAsync(),和上下文DbContext的方法SaveChangesAsync()。代码清单7-10演示了这两个方法的用法。

代码清单7-10. 异步查询和保存

  public static class Recipe9Program
{
public static async Task Run()
{
using (var context = new Recipe9Context())
{
var account1 = new Account
{
AccountHolder = "Robert Dewey",
Transactions = new HashSet<Transaction>()
{
new Transaction
{
TransactionDate = Convert.ToDateTime("07/05/2013"),
Amount = 104.00M
},
new Transaction
{
TransactionDate = Convert.ToDateTime("07/12/2013"),
Amount = 104.00M
},
new Transaction
{
TransactionDate = Convert.ToDateTime("07/19/2013"),
Amount = 104.00M
}
}
};
var account2 = new Account
{
AccountHolder = "James Cheatham",
Transactions = new List<Transaction>
{
new Transaction
{
TransactionDate = Convert.ToDateTime("08/01/2013"),
Amount = 900.00M
},
new Transaction
{
TransactionDate = Convert.ToDateTime("08/02/2013"),
Amount = -42.00M
}
}
};
var account3 = new Account
{
AccountHolder = "Thurston Howe",
Transactions = new List<Transaction>
{
new Transaction
{
TransactionDate = Convert.ToDateTime("08/05/2013"),
Amount = 100.00M
}
}
}; context.Accounts.Add(account1);
context.Accounts.Add(account2);
context.Accounts.Add(account3);
context.SaveChanges(); //为每个account添加每月的服务费
foreach (var account in context.Accounts)
{
var transactions = new List<Transaction>
{
new Transaction
{
TransactionDate = Convert.ToDateTime("08/09/2013"),
Amount = -5.00M
},
new Transaction
{
TransactionDate = Convert.ToDateTime("08/09/2013"),
Amount = -2.00M
}
}; Task saveTask = SaveAccountTransactionsAsync(account.AccountNumber, transactions); Console.WriteLine("Account Transactions for the account belonging to {0} (acct# {1})", account.AccountHolder, account.AccountNumber);
await saveTask;
await ShowAccountTransactionsAsync(account.AccountNumber);
} } } private static async Task SaveAccountTransactionsAsync(int accountNumber, ICollection<Transaction> transactions)
{
using (var context = new Recipe9Context())
{
var account = new Account { AccountNumber = accountNumber };
context.Accounts.Attach(account);
context.Entry(account).Collection(a => a.Transactions).Load(); foreach (var transaction in transactions.OrderBy(t => t.TransactionDate))
{
account.Transactions.Add(transaction);
} await context.SaveChangesAsync(); } } private static async Task ShowAccountTransactionsAsync(int accountNumber)
{
Console.WriteLine("TxNumber\tDate\tAmount");
using (var context = new Recipe9Context())
{
var transactions = context.Transactions.Where(t => t.AccountNumber == accountNumber);
await transactions.ForEachAsync(t => Console.WriteLine("{0}\t{1}\t{2}", t.TransactionNumber, t.TransactionDate, t.Amount));
}
}
}

原理

  示例中使用的异步结构是.NET4.5引入的,用来降低平常编写异步代码的复杂性。当我们调用SaveAccountTransactionsAsync()方法时,我们将它分配给Task对象。它调用方法并向调用者返回执行权。同时,异步部分,SaveAccounTransactionsAsync()也在执行。调用ShowAccountTransactionsAsync()方法的代码与调用SaveAccountTransactionsAsync()方法类似。当等待两个方法的调用返回时,执行权返回到await语句的下一行代码。

  重要的是,要知道.NET4.5中的异步模型是单线程,不是多线程,所以,代码 await SaveAccountTransactionsAsync()会被挂起,直到这个方法返回。另外需要知道的是 ,任何方法在调用一个async方法时,它自己必须被async修改符标记,并且返回一个Task类型或者Task<T>类型。

  代码清单7-10的输出如下:

Account Transactions for the account belonging to Robert Dewey (acct# )
TxNumber Date Amount
// :: AM 104.00
// :: AM 104.00
// :: AM 104.00
// :: AM -5.00
// :: AM -2.00
Account Transactions for the account belonging to James Cheatham (acct# )
TxNumber Date Amount
// :: AM 900.00
// :: AM -42.00
// :: AM -5.00
// :: AM -2.00
Account Transactions for the account belonging to Thurston Howe (acct# )
TxNumber Date Amount
// :: AM 100.00
// :: AM -5.00
// :: AM -2.00

至此,第七章结束,下篇我们开始第八章。感谢你的阅读。

实体框架交流QQ群:  458326058,欢迎有兴趣的朋友加入一起交流

谢谢大家的持续关注,我的博客地址:http://www.cnblogs.com/VolcanoCloud/