自跟踪实体演练Self-Tracking Entities Walkthrough

重要

我们不再建议使用自跟踪实体模板。 它将仅继续用于支持现有应用程序。 如果应用程序需要使用断开连接的实体图，请考虑其他替代方案，例如可跟踪实体，它与自跟踪实体类似，社区在更积极地开发这种技术，或使用低级别更改跟踪 API 编写自定义代码。

本演练演示了 Windows Communication Foundation （WCF）服务公开返回实体关系图的操作的情况。 接下来，客户端应用程序操作该图并将修改提交给使用实体框架验证和保存数据库更新的服务操作。

在完成本演练之前，请务必阅读 “自跟踪实体“ 页。

此演练完成以下操作：

  • 创建要访问的数据库。
  • 创建包含模型的类库。
  • 交换到 “自跟踪实体生成器” 模板。
  • 将实体类移到单独的项目中。
  • 创建一个 WCF 服务，该服务公开用于查询和保存实体的操作。
  • 创建使用服务的客户端应用程序（控制台和 WPF）。

我们将在本演练中使用 Database First，但相同的技术同样适用于 Model First。

先决条件Pre-Requisites

若要完成本演练，你将需要最新版本的 Visual Studio。

创建数据库Create a Database

随 Visual Studio 一起安装的数据库服务器因安装的 Visual Studio 版本而异：

  • 如果使用的是 Visual Studio 2012，则将创建一个 LocalDB 数据库。
  • 如果使用的是 Visual Studio 2010，则将创建 SQL Express 数据库。

接下来，生成数据库。

  • 打开 Visual Studio
  • 视图-> 服务器资源管理器
  • 右键单击 “数据连接-> 添加连接 … “
  • 如果尚未从服务器资源管理器连接到数据库，则需要选择Microsoft SQL Server作为数据源
  • 连接到 LocalDB 或 SQL Express，具体取决于你安装的是哪个
  • 输入STESample作为数据库名称
  • 选择 “确定” ，系统会询问您是否要创建新数据库，请选择 “是”
  • 新数据库现在将出现在服务器资源管理器
  • 如果使用的是 Visual Studio 2012
    • 在服务器资源管理器中右键单击该数据库，然后选择 “新建查询“
    • 将以下 SQL 复制到新的查询中，然后右键单击该查询，然后选择 “执行“
  • 如果使用的是 Visual Studio 2010
    • 选择数据> Transact-sql 编辑器-> 新建查询连接 …
    • 输入 。\SQLEXPRESS作为服务器名称，然后单击 “确定”
    • 从 “查询编辑器” 顶部的下拉菜单中选择 “ STESample “ 数据库
    • 将以下 SQL 复制到新的查询中，然后右键单击该查询，然后选择 “执行 SQL “。
  1.     CREATE TABLE [dbo].[Blogs] (
  2.         [BlogId] INT IDENTITY (1, 1) NOT NULL,
  3.         [Name] NVARCHAR (200) NULL,
  4.         [Url]  NVARCHAR (200) NULL,
  5.         CONSTRAINT [PK_dbo.Blogs] PRIMARY KEY CLUSTERED ([BlogId] ASC)
  6.     );
  8.     CREATE TABLE [dbo].[Posts] (
  9.         [PostId] INT IDENTITY (1, 1) NOT NULL,
  10.         [Title] NVARCHAR (200) NULL,
  11.         [Content] NTEXT NULL,
  12.         [BlogId] INT NOT NULL,
  13.         CONSTRAINT [PK_dbo.Posts] PRIMARY KEY CLUSTERED ([PostId] ASC),
  14.         CONSTRAINT [FK_dbo.Posts_dbo.Blogs_BlogId] FOREIGN KEY ([BlogId]) REFERENCES [dbo].[Blogs] ([BlogId]) ON DELETE CASCADE
  15.     );
  17.     SET IDENTITY_INSERT [dbo].[Blogs] ON
  18.     INSERT INTO [dbo].[Blogs] ([BlogId], [Name], [Url]) VALUES (1, N'ADO.NET Blog', N'blogs.msdn.com/adonet')
  19.     SET IDENTITY_INSERT [dbo].[Blogs] OFF
  20.     INSERT INTO [dbo].[Posts] ([Title], [Content], [BlogId]) VALUES (N'Intro to EF', N'Interesting stuff...', 1)
  21.     INSERT INTO [dbo].[Posts] ([Title], [Content], [BlogId]) VALUES (N'What is New', N'More interesting stuff...', 1)

创建模型Create the Model

首先，我们需要一个项目来放置模型。

  • 文件->> 项目 .。。
  • 从左窗格中选择 “ Visual C# ，然后选择” 类库 “
  • 输入STESample作为名称，然后单击 “确定”

现在，我们将在 EF 设计器中创建一个简单的模型来访问数据库：

  • 项目-> “添加新项 …”
  • 从左窗格中选择 “数据“，然后ADO.NET 实体数据模型
  • 输入BloggingModel作为名称，然后单击 “确定”
  • 选择 “从数据库生成“，然后单击 “下一步“
  • 输入在上一部分中创建的数据库的连接信息
  • 输入 “bloggingcontext” 作为连接字符串的名称，然后单击 “下一步“
  • 选中 “表“ 旁边的框，然后单击 “完成“

交换到粘贴代码生成Swap to STE Code Generation

现在，我们需要禁用默认代码生成并交换到自跟踪实体。

如果使用的是 Visual Studio 2012If you are using Visual Studio 2012

  • 展开解决方案资源管理器中的BloggingModel ，删除BloggingModel.tt和BloggingModel.Context.tt 这将禁用默认代码生成
  • 右键单击 EF 设计器图面上的空白区域，然后选择 “添加代码生成项 … “
  • 从左窗格中选择 “联机“，然后搜索粘贴生成器
  • 选择粘贴生成器 For C# 模板，输入STETemplate作为名称，然后单击 “添加“
  • STETemplate.tt和STETemplate.Context.tt文件添加到了 BloggingModel 文件下

如果使用的是 Visual Studio 2010If you are using Visual Studio 2010

  • 右键单击 EF 设计器图面上的空白区域，然后选择 “添加代码生成项 … “
  • 从左窗格中选择 “代码“，然后ADO.NET 自跟踪实体生成器
  • 输入STETemplate作为名称，然后单击 “添加“
  • STETemplate.tt和STETemplate.Context.tt文件会直接添加到你的项目

将实体类型移到单独的项目中Move Entity Types into Separate Project

若要使用自跟踪实体，客户端应用程序需要访问模型中生成的实体类。 由于我们不想将整个模型公开给客户端应用程序，因此我们要将实体类移到单独的项目中。

第一步是停止生成现有项目中的实体类：

  • 在解决方案资源管理器中右键单击 “ STETemplate.tt “，然后选择 “属性“
  • 在 “属性“ 窗口中，清除 “ CustomTool “ 属性中的TextTemplatingFileGenerator
  • 在解决方案资源管理器中展开 “ STETemplate.tt “，并删除其下嵌套的所有文件

接下来，我们将添加一个新项目，并在其中生成实体类

  • 文件-> 添加> 项目 .。。

  • 从左窗格中选择 “ Visual C# ，然后选择” 类库 “

  • 输入STESample作为名称，然后单击 “确定”

  • 项目-> 添加现有项 .。。

  • 导航到STESample项目文件夹

  • 选择查看所有文件（**）

  • 选择STETemplate.tt文件

  • 单击 “添加“ 按钮旁边的下拉箭头，然后选择 “添加为链接“。

    添加链接模板

我们还将确保在上下文相同的命名空间中生成实体类。 这只是减少了我们需要在应用程序中添加的 using 语句的数量。

  • 在解决方案资源管理器中右键单击链接的STETemplate.tt ，然后选择 “属性“
  • 在 “属性“ 窗口中，将自定义工具命名空间设置为STESample

粘贴模板生成的代码将需要引用 system.exception才能进行编译。 在可序列化实体类型上使用的 WCF DataContract和DataMember特性需要此库。

  • 右键单击解决方案资源管理器中的STESample项目，然后选择 “添加引用 … “
    • 在 Visual Studio 2012 中，选中 “ system.web “ 旁边的框，然后单击 “确定”
    • 在 Visual Studio 2010 中，选择 “ System.web “ 并单击 “确定”

最后，具有中的上下文的项目将需要对实体类型的引用。

  • 在解决方案资源管理器中右键单击 “ STESample “ 项目，然后选择 “添加引用 … “
    • 在 Visual Studio 2012 中，从左窗格中选择 “解决方案“，选中 “ STESample “ 旁边的框，然后单击 “确定”
    • 在 Visual Studio 2010 中，选择 “项目“ 选项卡，选择 “ STESample “，然后单击 “确定”

备注

将实体类型移动到单独的项目的另一种方法是移动模板文件，而不是将其链接到其默认位置。 如果执行此操作，则需要更新模板中的inputFile变量，以提供 edmx 文件的相对路径（在本示例中，为 ..\BloggingModel）。

创建 WCF 服务Create a WCF Service

现在是时候添加 WCF 服务来公开数据，接下来我们将创建该项目。

  • 文件-> 添加> 项目 .。。
  • 从左窗格中选择 “ Visual C# ，然后选择” WCF 服务应用程序“
  • 输入STESample作为名称，然后单击 “确定”
  • 添加对system.web程序集的引用
  • 添加对STESample和STESample项目的引用

需要将 EF 连接字符串复制到此项目中，以便在运行时找到它。

  • 打开 STESample 项目的app.config文件并复制connectionStrings元素
  • 在STESample项目中，将connectionStrings元素粘贴为web.config文件的configuration元素的子元素

现在是时候实现实际服务了。

  • 打开IService1.cs并将内容替换为以下代码
  1.     using System.Collections.Generic;
  2.     using System.ServiceModel;
  4.     namespace STESample.Service
  5.     {
  6.         [ServiceContract]
  7.         public interface IService1
  8.         {
  9.             [OperationContract]
  10.             List<Blog> GetBlogs();
  12.             [OperationContract]
  13.             void UpdateBlog(Blog blog);
  14.         }
  15.     }
  • 打开Service1并将内容替换为以下代码
  1.     using System;
  2.     using System.Collections.Generic;
  3.     using System.Data;
  4.     using System.Linq;
  6.     namespace STESample.Service
  7.     {
  8.         public class Service1 : IService1
  9.         {
  10.             /// <summary>
  11.             /// Gets all the Blogs and related Posts.
  12.             /// </summary>
  13.             public List<Blog> GetBlogs()
  14.             {
  15.                 using (BloggingContext context = new BloggingContext())
  16.                 {
  17.                     return context.Blogs.Include("Posts").ToList();
  18.                 }
  19.             }
  21.             /// <summary>
  22.             /// Updates Blog and its related Posts.
  23.             /// </summary>
  24.             public void UpdateBlog(Blog blog)
  25.             {
  26.                 using (BloggingContext context = new BloggingContext())
  27.                 {
  28.                     try
  29.                     {
  30.                         // TODO: Perform validation on the updated order before applying the changes.
  32.                         // The ApplyChanges method examines the change tracking information
  33.                         // contained in the graph of self-tracking entities to infer the set of operations
  34.                         // that need to be performed to reflect the changes in the database.
  35.                         context.Blogs.ApplyChanges(blog);
  36.                         context.SaveChanges();
  38.                     }
  39.                     catch (UpdateException)
  40.                     {
  41.                         // To avoid propagating exception messages that contain sensitive data to the client tier
  42.                         // calls to ApplyChanges and SaveChanges should be wrapped in exception handling code.
  43.                         throw new InvalidOperationException("Failed to update. Try your request again.");
  44.                     }
  45.                 }
  46.             }        
  47.         }
  48.     }

从控制台应用程序使用服务Consume the Service from a Console Application

让我们创建一个使用我们的服务的控制台应用程序。

  • 文件->> 项目 .。。
  • 从左窗格中选择 “ Visual C# ，然后选择”控制台应用程序“
  • 输入STESample作为名称，然后单击 “确定”
  • 添加对STESample项目的引用

我们需要对 WCF 服务的服务引用

  • 在解决方案资源管理器中右键单击 “ ConsoleTest “ 项目，然后选择 “添加服务引用 …
  • 单击发现
  • 输入BloggingService作为命名空间，然后单击 “确定”

现在，我们可以编写一些代码来使用该服务。

  • 打开Program.cs并将内容替换为以下代码。
  1.     using STESample.ConsoleTest.BloggingService;
  2.     using System;
  3.     using System.Linq;
  5.     namespace STESample.ConsoleTest
  6.     {
  7.         class Program
  8.         {
  9.             static void Main(string[] args)
  10.             {
  11.                 // Print out the data before we change anything
  12.                 Console.WriteLine("Initial Data:");
  13.                 DisplayBlogsAndPosts();
  15.                 // Add a new Blog and some Posts
  16.                 AddBlogAndPost();
  17.                 Console.WriteLine("After Adding:");
  18.                 DisplayBlogsAndPosts();
  20.                 // Modify the Blog and one of its Posts
  21.                 UpdateBlogAndPost();
  22.                 Console.WriteLine("After Update:");
  23.                 DisplayBlogsAndPosts();
  25.                 // Delete the Blog and its Posts
  26.                 DeleteBlogAndPost();
  27.                 Console.WriteLine("After Delete:");
  28.                 DisplayBlogsAndPosts();
  30.                 Console.WriteLine("Press any key to exit...");
  31.                 Console.ReadKey();
  32.             }
  34.             static void DisplayBlogsAndPosts()
  35.             {
  36.                 using (var service = new Service1Client())
  37.                 {
  38.                     // Get all Blogs (and Posts) from the service
  39.                     // and print them to the console
  40.                     var blogs = service.GetBlogs();
  41.                     foreach (var blog in blogs)
  42.                     {
  43.                         Console.WriteLine(blog.Name);
  44.                         foreach (var post in blog.Posts)
  45.                         {
  46.                             Console.WriteLine(" - {0}", post.Title);
  47.                         }
  48.                     }
  49.                 }
  51.                 Console.WriteLine();
  52.                 Console.WriteLine();
  53.             }
  55.             static void AddBlogAndPost()
  56.             {
  57.                 using (var service = new Service1Client())
  58.                 {
  59.                     // Create a new Blog with a couple of Posts
  60.                     var newBlog = new Blog
  61.                     {
  62.                         Name = "The New Blog",
  63.                         Posts =
  64.                         {
  65.                             new Post { Title = "Welcome to the new blog"},
  66.                             new Post { Title = "What's new on the new blog"}
  67.                         }
  68.                     };
  70.                     // Save the changes using the service
  71.                     service.UpdateBlog(newBlog);
  72.                 }
  73.             }
  75.             static void UpdateBlogAndPost()
  76.             {
  77.                 using (var service = new Service1Client())
  78.                 {
  79.                     // Get all the Blogs
  80.                     var blogs = service.GetBlogs();
  82.                     // Use LINQ to Objects to find The New Blog
  83.                     var blog = blogs.First(b => b.Name == "The New Blog");
  85.                     // Update the Blogs name
  86.                     blog.Name = "The Not-So-New Blog";
  88.                     // Update one of the related posts
  89.                     blog.Posts.First().Content = "Some interesting content...";
  91.                     // Save the changes using the service
  92.                     service.UpdateBlog(blog);
  93.                 }
  94.             }
  96.             static void DeleteBlogAndPost()
  97.             {
  98.                 using (var service = new Service1Client())
  99.                 {
  100.                     // Get all the Blogs
  101.                     var blogs = service.GetBlogs();
  103.                     // Use LINQ to Objects to find The Not-So-New Blog
  104.                     var blog = blogs.First(b => b.Name == "The Not-So-New Blog");
  106.                     // Mark all related Posts for deletion
  107.                     // We need to call ToList because each Post will be removed from the
  108.                     // Posts collection when we call MarkAsDeleted
  109.                     foreach (var post in blog.Posts.ToList())
  110.                     {
  111.                         post.MarkAsDeleted();
  112.                     }
  114.                     // Mark the Blog for deletion
  115.                     blog.MarkAsDeleted();
  117.                     // Save the changes using the service
  118.                     service.UpdateBlog(blog);
  119.                 }
  120.             }
  121.         }
  122.     }

现在可以运行应用程序来查看其实际运行情况。

  • 在解决方案资源管理器中右键单击 “ ConsoleTest “ 项目，然后选择 “调试-> 启动新实例“

当应用程序执行时，将看到以下输出。

  1. Initial Data:
  2. ADO.NET Blog
  3. - Intro to EF
  4. - What is New
  6. After Adding:
  7. ADO.NET Blog
  8. - Intro to EF
  9. - What is New
  10. The New Blog
  11. - Welcome to the new blog
  12. - What's new on the new blog
  14. After Update:
  15. ADO.NET Blog
  16. - Intro to EF
  17. - What is New
  18. The Not-So-New Blog
  19. - Welcome to the new blog
  20. - What's new on the new blog
  22. After Delete:
  23. ADO.NET Blog
  24. - Intro to EF
  25. - What is New
  27. Press any key to exit...

从 WPF 应用程序使用服务Consume the Service from a WPF Application

让我们创建一个使用我们的服务的 WPF 应用程序。

  • 文件->> 项目 .。。
  • 从左窗格中选择 “ Visual C# ，然后选择” WPF 应用程序“
  • 输入STESample作为名称，然后单击 “确定”
  • 添加对STESample项目的引用

我们需要对 WCF 服务的服务引用

  • 在解决方案资源管理器中右键单击 “ WPFTest “ 项目，然后选择 “添加服务引用 …
  • 单击发现
  • 输入BloggingService作为命名空间，然后单击 “确定”

现在，我们可以编写一些代码来使用该服务。

  • 打开mainwindow.xaml并将内容替换为以下代码。
  1.     <Window
  2.         xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
  3.         xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
  4.         xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
  5.         xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
  6.         xmlns:STESample="clr-namespace:STESample;assembly=STESample.Entities"
  7.         mc:Ignorable="d" x:Class="STESample.WPFTest.MainWindow"
  8.         Title="MainWindow" Height="350" Width="525" Loaded="Window_Loaded">
  10.         <Window.Resources>
  11.             <CollectionViewSource
  12.                 x:Key="blogViewSource"
  13.                 d:DesignSource="{d:DesignInstance {x:Type STESample:Blog}, CreateList=True}"/>
  14.             <CollectionViewSource
  15.                 x:Key="blogPostsViewSource"
  16.                 Source="{Binding Posts, Source={StaticResource blogViewSource}}"/>
  17.         </Window.Resources>
  19.         <Grid DataContext="{StaticResource blogViewSource}">
  20.             <DataGrid AutoGenerateColumns="False" EnableRowVirtualization="True"
  21.                       ItemsSource="{Binding}" Margin="10,10,10,179">
  22.                 <DataGrid.Columns>
  23.                     <DataGridTextColumn Binding="{Binding BlogId}" Header="Id" Width="Auto" IsReadOnly="True" />
  24.                     <DataGridTextColumn Binding="{Binding Name}" Header="Name" Width="Auto"/>
  25.                     <DataGridTextColumn Binding="{Binding Url}" Header="Url" Width="Auto"/>
  26.                 </DataGrid.Columns>
  27.             </DataGrid>
  28.             <DataGrid AutoGenerateColumns="False" EnableRowVirtualization="True"
  29.                       ItemsSource="{Binding Source={StaticResource blogPostsViewSource}}" Margin="10,145,10,38">
  30.                 <DataGrid.Columns>
  31.                     <DataGridTextColumn Binding="{Binding PostId}" Header="Id" Width="Auto"  IsReadOnly="True"/>
  32.                     <DataGridTextColumn Binding="{Binding Title}" Header="Title" Width="Auto"/>
  33.                     <DataGridTextColumn Binding="{Binding Content}" Header="Content" Width="Auto"/>
  34.                 </DataGrid.Columns>
  35.             </DataGrid>
  36.             <Button Width="68" Height="23" HorizontalAlignment="Right" VerticalAlignment="Bottom"
  37.                     Margin="0,0,10,10" Click="buttonSave_Click">Save</Button>
  38.         </Grid>
  39.     </Window>
  • 打开 Mainwindow.xaml （MainWindow.xaml.cs）的隐藏代码，并将内容替换为以下代码
  1.     using STESample.WPFTest.BloggingService;
  2.     using System.Collections.Generic;
  3.     using System.Linq;
  4.     using System.Windows;
  5.     using System.Windows.Data;
  7.     namespace STESample.WPFTest
  8.     {
  9.         public partial class MainWindow : Window
  10.         {
  11.             public MainWindow()
  12.             {
  13.                 InitializeComponent();
  14.             }
  16.             private void Window_Loaded(object sender, RoutedEventArgs e)
  17.             {
  18.                 using (var service = new Service1Client())
  19.                 {
  20.                     // Find the view source for Blogs and populate it with all Blogs (and related Posts)
  21.                     // from the Service. The default editing functionality of WPF will allow the objects
  22.                     // to be manipulated on the screen.
  23.                     var blogsViewSource = (CollectionViewSource)this.FindResource("blogViewSource");
  24.                     blogsViewSource.Source = service.GetBlogs().ToList();
  25.                 }
  26.             }
  28.             private void buttonSave_Click(object sender, RoutedEventArgs e)
  29.             {
  30.                 using (var service = new Service1Client())
  31.                 {
  32.                     // Get the blogs that are bound to the screen
  33.                     var blogsViewSource = (CollectionViewSource)this.FindResource("blogViewSource");
  34.                     var blogs = (List<Blog>)blogsViewSource.Source;
  36.                     // Save all Blogs and related Posts
  37.                     foreach (var blog in blogs)
  38.                     {
  39.                         service.UpdateBlog(blog);
  40.                     }
  42.                     // Re-query for data to get database-generated keys etc.
  43.                     blogsViewSource.Source = service.GetBlogs().ToList();
  44.                 }
  45.             }
  46.         }
  47.     }

现在可以运行应用程序来查看其实际运行情况。

  • 在解决方案资源管理器中右键单击 “ WPFTest “ 项目，然后选择 “调试-> 启动新实例“
  • 你可以使用屏幕操作数据，并使用 “保存“ 按钮通过服务保存数据

WPF 主窗口