Download - ADO.net Entity Framework HOL Manual

Using the Entity Framework in .NET Framework 4.0 and Visual Studio 2010

Hands-on LabManual

Information in this document, including URL and other Internet Web site references, is subject to change without notice. Unless otherwise noted, the example companies, organizations, products, domain names, e-mail addresses, logos, people, places, and events depicted herein are fictitious, and no association with any real company, organization, product, domain name, e-mail address, logo, person, place, or event is intended or should be inferred. Complying with all applicable copyright laws is the responsibility of the user. Without limiting the rights under copyright, no part of this document may be reproduced, stored in or introduced into a retrieval system, or transmitted in any form or by any means (electronic, mechanical, photocopying, recording, or otherwise), or for any purpose, without the express written permission of Microsoft Corporation.

The names of manufacturers, products, or URLs are provided for informational purposes only and Microsoft makes no representations and warranties, either expressed, implied, or statutory, regarding these manufacturers or the use of the products with any Microsoft technologies. The inclusion of a manufacturer or product does not imply endorsement of Microsoft of the manufacturer or product. Links are provided to third party sites. Such sites are not under the control of Microsoft and Microsoft is not responsible for the contents of any linked site or any link contained in a linked site, or any changes or updates to such sites. Microsoft is not responsible for webcasting or any other form of transmission received from any linked site. Microsoft is providing these links to you only as a convenience, and the inclusion of any link does not imply endorsement of Microsoft of the site or the products contained therein.

Microsoft may have patents, patent applications, trademarks, copyrights, or other intellectual property rights covering subject matter in this document. Except as expressly provided in any written license agreement from Microsoft, the furnishing of this document does not give you any license to these patents, trademarks, copyrights, or other intellectual property.

Copyright © 2007 Microsoft Corporation. All rights reserved.

Microsoft are either registered trademarks or trademarks of Microsoft Corporation in the United States and/or other countries.

The names of actual companies and products mentioned herein may be the trademarks of their respective owners.

Version 1.2

Using the Entity Framework in .NET 4.0 and Visual Studio 2010Microsoft Hands-on Labs

Page of

Table of ContentsLab Introduction..............................................................................................................................................................4

Objectives............................................................................................................4Prerequisites.........................................................................................................4Lab Scenarios.......................................................................................................4Virtual PC Configuration and Setup....................................................................5Copy/Paste of Code Required..............................................................................5

Exercise 1: Model-First Development...................................................................................6

Exercise 2: Using Persistence Ignorant Classes..................................................................16

Exercise 3: Building Multi-tier Services with Entities..........................................................24


of 35

Lab Introduction

Each Exercise in this lab is designed to be completed independently if you do not have time to complete all Exercises in one sitting.

ObjectivesThe goal of these hands-on lab materials is to get an overview of some of the new Entity Framework features in .NET Framework 4.0 and Visual Studio 2010.

After completing these self-paced labs, you will be able to:

Begin development by first creating a model and then generating a database from that model.

Use persistence ignorant classes with the Entity Framework

Write multi-tier services using entities

Prerequisites Experience with Visual Studio

Experience with writing LINQ queries

General experience with building WCF services is helpful but not required

General experience with the Entity Framework is helpful but not required

Lab Scenarios This series of exercises is meant to show you how to get started using the new Entity Framework features in .NET Framework 4.0 and Visual Studio 2010. These exercises demonstrate new patterns that application developers can take advantage of in a variety of scenarios. Exercises can be completed as a sequence or can be completed independently.

Suggested Time for Completion: 60 minutes


of 35

Virtual PC Configuration and SetupThe Virtual PC machine name is DataDevLab10.

The accounts and passwords used in the following exercises are shown in the following table:

Account Name Account Password Account Usage

DataDevLab10 passw0rd Login account for DataDevLab10 Computer

Copy/Paste of Code RequiredYou will be asked to copy/paste code snippets to complete this lab. In order to do this, you need to open a copy of this lab manual inside the Virtual Machine. This specific lab can be found here: C:\HOLs\Entity Framework\.


of 35

Exercise 1: Model-First DevelopmentIn this exercise, you will design a model for a blogging application that contains three entities: Blogs, Posts, and Tags. You will then use that model to generate a database schema.

Tasks Detailed Steps

Create a model for the Blog application.

1. Start Visual Studio.From the Windows task bar, select Start | All Programs | Microsoft Visual Studio 2010 | Microsoft Visual Studio 2010 menu item.

2. When Microsoft Visual Studio 2010 opens, create a new Class Library Project.From the File menu, select New | Project…

3. In the New Project dialog, select Visual C# | Windows | Class LibraryFill in the names and location for the project:

Name BlogModelLocation C:\HOLs\Entity Framework\

Exercise1\Solution Name Blog


of 35

Tasks Detailed Steps4. Click OK to create the project.5. From the Solution Explorer, right-click on the project name BlogModel and select Add

| New Item …This opens the Add New Item dialog.

6. In the Add New Item dialog, select Data under Visual C# Items, and ADO.NET Entity Data Model.Give the item the name “BlogModel.edmx”.Click Add to bring up the Entity Data Model Wizard.

7. Click Add.8. From the Entity Data Model Wizard, select Empty Model and click Finish. This will

add several references to your project as well as the empty BlogModel.edmx file. You are now ready to begin adding entities to your model.

9. From the Solution Explorer, double-click on the BlogModel.edmx file to open the Entity Data Model Designer.

10. Rename your contextRight-click on the designer surface and from the context menu select Properties. From the property list, set the Entity Container Name to BlogContext


of 35


11. You will need to display the Toolbox window to add new entities to the model. Click on the Toolbox link on the designer surface to display the Toolbox window.

12. From the Toolbox window, drag an Entity item to the model designer surface. This will add an entity named Entity1 to your model. Right click the Entity1 shape and select Properties to open the Properties window.

13. From the Properties window, set the following properties:

Name BlogEntity Set Name Blogs

14. From the Entity Data Model Designer, select the Blog entity. Next right click on the Id property and select Properties. From the Properties window rename the Id member to BlogID. Also change the Type property to Int32. BlogID is the key for this entity, so set the Entity Key property to True.

Name Type EntityKey


of 35


BlogID Int32 True

15. Next you will add additional properties to the Blog entity. From the Entity Data Model Designer, select the Blog entity. Next right click in the top portion of the entity and select Add | Scalar Property. This will add a new property. This property will be the Blog’s name so name the property Name.

16. Next you need to set the property’s type. Right click on the Name property and select Properties. From the Properties window, set the Type to String.

Name NameType String

17. Repeat steps 15 and 16 to add another string property named Owner.

Name OwnerType String

18. You have now added an entity to your model. There are two other entities that need to be added to the model, one for a Post and one for a Tag. Repeat steps 12 – 16 to add two additional entities and their properties:

Post Entity

Name PostEntity Set Name Posts

Properties:

Name Type EntityKeyPostID Int32 TrueCreatedDate DateTime FalseModifiedDate DateTime FalsePostContent String FalseTitle String False

Tag Entity

Name TagEntity Set Name Tags

Properties:

Name Type EntityKeyTagID Int32 TrueName String False


of 35


19. Now that you have added the entities to the model you can add relationships between these entities. The first relationship that you will add is between a Blog and a Post. Right click on the Blog entity and select Add | Association… This will open the Add Association dialog.

20. From the Add Association dialog, fill in the association details of the Blog to Post relationship using the information below.


of 35


Notice the new checkbox titled “Add foreign key properties to the ‘Post’ Entity”. This will add the necessary foreign key properties to the model and set up the needed referential constraint. Click OK to add the association.To see the referential constraint that was setup, double-click the association:


of 35


Click OK.

21. Next you will add the relationship between a Post and a Tag. A Post can have many Tags and a Tag can be associated with many Posts so this is a Many to Many relationship. Right click on the Post entity and select Add | Association… This will again open the Add Association dialog.

22. From the Add Association dialog, fill in the association details of the Post to Tag relationship using the information below:


of 35


Click OK to add the association. Your model will know look like this:

23. The model is now complete and you should save the BlogModel.edmx file by selecting the menu File | Save BlogModel.edmx.


of 35


24. You are now ready to create the database from this model.

Generate a database schema from the model

25. To generate a database schema from the model, you will first need to create an empty database to store the schema. For this example you will be using a local SqlExpress database. From the menu bar, select View | Server Explorer to open the Server Explorer window.

26. From the Server Explorer window, right click on the Data Connections node and select Create New SQL Server Database… to open the Create New SQL Server Database dialog.

27. In the Create New SQL Server Database dialog, fill in the dialog box to create a local database EFBlogs with the information below:

Click OK to create the database.

28. You can now create the database schema for the Blogs database. From BlogModel.edmx right-click on the designer surface and choose Generate Database from Model… This will open the Generate Database Wizard.

29. From the Generate Database Wizard, select the connection to the EFBlogs database


of 35


and select the “No, exclude sensitive information from the connection string” option. Click Next to continue to the summary page.

30. From the Summary page you can look over the DDL statements for the database schema. Notice that foreign keys have been added to the Post and Tags tables and that a PostTags table has been included as a link table to support the many-to-many relationship between Posts and Tags. Click Finish to save the .sql file to your project.

31. You will be prompted that this operation will overwrite the msl and ssdl information in your edmx file. Click Yes to continue.

32. With the BlogModel.edmx.sql file open (the DDL script that was just created), right click on the editor and select Execute SQL to run the script and create your database. You will be presented with the Connect to Database Engine dialog.

33. Select the database connection that we just created using Server Explorer, and click OK. You should see a message “The command(s) completed successfully” when your script has finished creating your new database.

Run the BlogClient sample.

34. Before you can continue too much farther you need to add some sample Data to our database. To do so, you’re going to run a pre-written SQL script that will add this sample data.

35. Open the SQL Script to populate the Blog database with data.Right click on the BlogModel project in Solution Explorer, click Add | Existing Item…

36. From the Add Existing Item dialog, open the file: C:\HOLs\Entity Framework\Exercise1\BlogData.sql


of 35


You may need to select to show All Files (*.*)37. Click Add.38. Open BlogData.sql, right click on the editor and select Execute SQL39. Add the BlogClient project to your Blog solution

From the Solution Explorer, right-click on the solution Solution (‘Blog’) and form the context menu select Add | Existing Project …

40. From the Add Existing Project dialog, select the project file at:C:\HOLs\Entity Framework\Exercise1\BlogClient\BlogClient.csproj

41. Set the BlogClient sample as the startup project.

42. Press F5 to run the Blog Application


of 35

Exercise 2: Using Persistence Ignorant ClassesIn this exercise, you will create persistence ignorant classes and use new Entity Framework features such as lazy loading to enable many common development patterns when using classes that are not tightly coupled with a persistence framework (Entity Framework).


Open the project file and setup the database

If you are continuing from Exercise 1, you can skip to step 9. Otherwise follow the steps below to open the Visual Studio solution containing the Blog EDM, entity classes, and WPF client application.


2. Open the project.From the File menu, select File | Open | Project/Solution menu item.

3. From the Open Project dialog, open the solution file at C:\HOLs\Entity Framework\Exercise2\Blog\Blog.sln

If you are not continuing from Exercise 1, you will need to setup the EFBlog database for this exercise.

4. Open the SQL Script.Right click on the Blog Solution in Solution Explorer, click Add | Existing Item…

5. From the Add Existing Item dialog, open the file: C:\HOLs\Entity Framework\Exercise2\BlogAll.sqlYou may need to select to show All Files (*.*)

6. Click Add.7. Open BlogAll.sql, right click on the editor and select Execute SQL


of 35


8. Click Connect

Add persistence ignorant classes

9. Turn off Code Generation

Double click BlogModel.edmx in the BlogModel project to open the Entity Designer. Right click on the design surface to see the properties window. Set the Code Generation Strategy property to “None”.

10. Add a code file for Blog.cs file to the BlogModel project.

From the Solution Explorer, right click on the BlogModel project and from the context menu select Add | New Item | Class….


of 35


11. Now we will create our POCO objects. Type the name Blog.cs for the class name and click Add to add the class to your project.

12. When the file opens, type in or copy and paste the following code into the file to add an implementation for a Blog. This class implementation includes the serialization attributes for DataContract serialization which will be used in Exercise 3.

using System;using System.Collections.Generic;using System.Linq;using System.Text;using System.Runtime.Serialization;

namespace BlogModel{ [DataContract(IsReference = true)] public class Blog { [DataMember] public int BlogID { get; set; }

[DataMember] public string Name { get; set; }

[DataMember] public string Owner { get; set; }

[DataMember] public List<Post> Posts { get { return _posts; } set { _posts = value; } }

List<Post> _posts = new List<Post>(); }}

13. Repeat steps 13 – 15 to add code files for the Tag class and Post class

Tag.csusing System;using System.Collections.Generic;using System.Linq;


of 35

Tasks Detailed Stepsusing System.Text;using System.Runtime.Serialization;

namespace BlogModel{ [DataContract(IsReference = true)] public class Tag { [DataMember] public int TagID { get; set; }

[DataMember] public string Name { get; set; }

[DataMember] public List<Post> Posts { get { return _posts; } set { _posts = value; } }

List<Post> _posts = new List<Post>();

}}

Post.csusing System;using System.Collections.Generic;using System.Linq;using System.Text;using System.Runtime.Serialization;

namespace BlogModel{ [DataContract(IsReference = true)] public class Post { [DataMember] public int PostID { get; set; }

[DataMember] public DateTime CreatedDate { get; set;


of 35

Tasks Detailed Steps }

[DataMember] public DateTime ModifiedDate { get; set; }

[DataMember] public string Title { get; set; }

[DataMember] public string PostContent { get; set; }

[DataMember] public Blog Blog { get; set; }

[DataMember] public int BlogBlogID { get; set; }

[DataMember] public List<Tag> Tags { get { return _tags; } set { _tags = value; } }

private List<Tag> _tags = new List<Tag>();

}}

Add a context class

With code generation turned off we no longer have a BlogContext ObjectContext implementation. In this next step, you will create your own BlogContext.

14. Add a code file for BlogContext to the BlogModel project.

From the Solution Explorer, right-click on the BlogModel project, and from the context menu select Add | New Item | Class….


of 35


15. Type the name BlogContext.cs for the class name and click Add to add the class to your project.

16. When the file opens, type in or copy and paste the following code into the file to define the BlogContext class.

using System;using System.Collections.Generic;using System.Linq;using System.Text;using System.Data.Objects;

namespace BlogModel{ public class BlogContext : ObjectContext { public BlogContext() : base("name=BlogContext", "BlogContext") { }

public ObjectSet<Blog> Blogs { get { if (_Blogs == null) { _Blogs = base.CreateObjectSet<Blog>("Blogs"); } return _Blogs; } }

private ObjectSet<Blog> _Blogs;

public ObjectSet<Post> Posts { get { if (_Posts == null) { _Posts = base.CreateObjectSet<Post>("Posts"); } return _Posts; } }

private ObjectSet<Post> _Posts;

public ObjectSet<Tag> Tags { get { if (_Tags == null) { _Tags = base.CreateObjectSet<Tag>("Tags"); } return _Tags;


of 35

Tasks Detailed Steps } }

private ObjectSet<Tag> _Tags;

}}

17. Run the application by pressing F5 or selecting the menu item Debug | Start Debugging. You will see the BlogClient run and you can browse the blogs and posts as before, but this time you are using persistence ignorant classes.

Update the classes to use lazy loading with POCO classes

The current POCO implementation uses explicit loading. When performing explicit loads is not a concern, it is possible to use lazy loading (also known as deferred loading) to load associated entities whenever a property is accessed for the first time. This is done by making relationship navigation properties (such as Blog.Posts or Post.Tags) virtual. The Entity Framework will create a proxy type at runtime that knows how to perform a load so that no additional code changes are necessary. In the next series of steps you will enable the use of lazy loading.

18. From the Solution Explorer, double-click on the Blog.cs file in the BlogModel project.

19. Change the Posts property definition to be virtual:public virtual List<Post> Posts

20. Enable lazy loadingFrom the Solution Explorer, double-click on the MainWindow.xaml.cs file in the BlogClient project. If this file is not visible, click on the + sign next to MainWindow.xaml.

21. Locate the MainWindow constructor and change the code to turn on deferred loading:public MainWindow(){ InitializeComponent();


of 35

Tasks Detailed Steps _context = new BlogContext(); _context.ContextOptions.LazyLoadingEnabled = true; this.MainGrid.DataContext = _context.Blogs;

}

22. You can now remove contents of the event handler method BlogList_SelectionChanged. Locate this method, select the method and delete it the contents.

23. Run the application by pressing F5 or selecting the menu item Debug | Start Debugging. You will see the BlogClient run and you can browse the blogs and posts as before, but this time you are using persistence ignorant classes that use lazy loading.

24. You are now ready to move to the next exercise.


of 35

Exercise 3: Building Multi-tier Services with EntitiesIn this exercise, you will setup a WCF service that exposes functionality from a BlogRepository, and a client that consumes it. This exercise demonstrates one way to create an N-Tier application using WCF to expose a select set of methods to the client. In many cases when you want to expose CRUD functionality to the client you will want to use ADO.NET Data Services. For more information on using ADO.NET Data Services with the Entity Framework check out the ADO.NET Data Services Hands On Lab. (Note: It is important to move to a multi-tier architecture only when there is a real need to do so. There are several articles online that describe when it is appropriate to implement a multi-tier solution.)


Open the project file and setup the database


2. Open the project.From the File menu, select File | Open | Project/Solution menu item.

3. From the Open Project dialog, open the solution file at C:\HOLs\Entity Framework\Exercise3\Blog\Blog.sln

If you are not continuing from Exercise 2, you will need to setup the EFBlog database for this exercise.

4. Open the SQL Script.Right click on the Blog Solution in Solution Explorer, click Add | Existing Item…

5. From the Add Existing Item dialog, open the file:C:\HOLs\Entity Framework\Exercise3\BlogAll.sqlYou may need to select to show All Files (*.*)

6. Click Add.7. Open BlogAll.sql, right click on the editor and select Execute SQL


of 35


8. Click Connect

Add Repository

It is a common design pattern to implement a repository where domain specific methods are implemented. In this next series of steps, you will implement a repository class for Blogs that takes advantage of the interface implementation you added.

9. From the Solution Explorer, add a new class to the BlogModel project.Right-click on the BlogModel project and from the context menu select Add | New Item | Class

10. From the Add New Item dialog, enter a name for the code file: BlogRepository.csClick Add to add the new class to your project.

11. When the file opens, type in or copy and paste the following code into the file to add the basic repository:

using System;using System.Collections.Generic;using System.Linq;using System.Text;

namespace BlogModel{ public class BlogRepository { BlogContext _context;

public BlogRepository(BlogContext context) { _context = context;


of 35

Tasks Detailed Steps } }}

12. Add a business logic method to return all blogs

public IEnumerable<Blog> Blogs{ get { return _context.Blogs; }}

13. Next add a business logic method to return posts from a Blog. This repository method uses the LoadProperty method on the ObjectContext, which is an explicit call to request the related entities from the database.

public IEnumerable<Post> GetPosts(Blog blog){ _context.Blogs.Attach(blog); _context.LoadProperty(blog, b => b.Posts); return blog.Posts;}

14. Add a business logic method to update a post. For now, this implementation will just call the Validate method.

public string UpdatePost(Post post){ string result = "Updated!"; try { post.Validate(); } catch(Exception e) { result = e.Message; } return result;}

Update Post to include Validate method

15. Double click on Post.cs to open.16. Add Validate() method to the Post class.

public void Validate(){ if (CreatedDate > DateTime.Now) { throw new Exception("Post from the future!"); }}

Update the Blog Client to use your repository

In this next series of steps, you will update your Blog client to use the BlogRepository.

17. From the Solution Explorer double-click on the MainWindow.xaml.cs file that


of 35


contains the presentation logic to display blogs.18. At the top of the MainWindow class where the BlogContext is declared. Change the

type from BlogContext to BlogRepository.

BlogRepository _repository;

19. In the MainWindow constructor where _context is assigned and used. Change this method to create a new BlogRepository and to use the Blogs property by replacing the code in the constructor with the code below:

public MainWindow(){ InitializeComponent();

_repository = new BlogRepository(new BlogContext()); this.MainGrid.DataContext = _repository.Blogs;}

20. Change the UpdateButton_Click method to call the UpdatePost method on the repository by replacing the code in the method with the code below:

private void UpdateButton_Click(object sender, RoutedEventArgs e){ Post post = PostList.SelectedItem as Post; if (post != null) { MessageBox.Show(_repository.UpdatePost(post)); }}

21. Change the BlogList_SelectionChanged method to call the GetPosts method on the repository by replacing the code in the method with the code below:

private void BlogList_SelectionChanged(object sender, SelectionChangedEventArgs e){ Blog blog = BlogList.SelectedItem as Blog; _repository.GetPosts(blog);}

22. Run the solutionFrom the Debug menu select Debug | Start Debugging


of 35


Create a WCF service library

23. Add a WCF Service projectFrom the menu bar, select File | Add | New Project…

24. From the Add New Project dialog select Visual C# | WCF | WCF Service LibraryFill in the names and location for the project:

Name BlogServiceLocation C:\HOLs\Entity Framework\Exercise1\Blog

Note: Set the Location to C:\HOLs\Entity Framework\Exercise3\Blog if you are not continuing from a previous model.

Click OK to add the project to your solution.25. Add a project reference to System.Data.Entity.

From the Solution Explorer, locate the new BlogService project, right click on the BlogService project name, and from the context menu select Add Reference

26. From the Add Reference dialog, click on the .NET tab and select System.Data.Entity. Click OK to add the project reference.

27. Add a project reference to BlogModel.From the Solution Explorer, locate the new BlogService project, right click on the BlogService project name, and from the context menu select Add Reference

28. From the Add Reference dialog, click on the Projects tab and select BlogModel. Click OK to add the project reference.


of 35


29. The service will be making a connection to the database so you will need to add the connection string to the app.config file in the BlogService project. In the Solution Explorer, under the BlogService project, double click on the app.config file to open it.

30. Paste in the connection string tag underneath the configuration tag.

<connectionStrings> <add name="BlogContext" connectionString="metadata=res://*/BlogModel.csdl|res://*/BlogModel.ssdl|res://*/BlogModel.msl;provider=System.Data.SqlClient;provider connection string="Data Source=.\SQLEXPRESS;Initial Catalog=EFBlogs;Integrated Security=True;Pooling=False;MultipleActiveResultSets=True"" providerName="System.Data.EntityClient" /></connectionStrings>

In this exercise you will not be using lazy loading so it is important to remove the virtual Posts property on the Blog class.

31. From the Solution Explorer, double-click on the file Blog.cs in the BlogModel project.

32. Change the Posts property definition to not be virtual:public List<Post> Posts


of 35


Add service methods for your repository

33. Open the IService1.cs fileFrom the Solution Explorer, locate the new BlogService project and double-click on the IService1.cs file.

34. Near the top of the file, add a new using statement for BlogModel.

using BlogModel;

35. Remove the contents of the IService1 ServiceContract that are pre-filled with sample operation methods and replace them with the code below. This will define the set of operations we will use with the repository and context.

[ServiceContract]public interface IService1{ [OperationContract] IEnumerable<Blog> GetBlogs();

[OperationContract] IEnumerable<Post> GetPosts(Blog blog);

[OperationContract] string UpdatePost(Post post);}

36. Open the Service1.cs fileFrom the Solution Explorer, locate the BlogService project and double-click on the Service1.cs file.

37. Near the top of the file, add a new using statement for BlogModel.

using BlogModel;

38. Remove the contents of Service1.cs that are pre-filled with sample operation methods.

39. Implement GetBlogsType in or copy and paste the code below to implement the GetBlogs service method on Service1. This method creates a new BlogContext and BlogRepository and returns all of the Blogs.

public IEnumerable<Blog> GetBlogs(){ using (BlogContext context = new BlogContext()) { BlogRepository repository = new BlogRepository(context); return repository.Blogs.ToArray(); }}

40. Implement GetPostsType in or copy and paste the code below to implement the GetPosts service method on Service1. This method creates a new BlogContext and BlogRepository and calls GetPosts.


of 35

Tasks Detailed Stepspublic IEnumerable<Post> GetPosts(Blog blog){ using (BlogContext context = new BlogContext()) { BlogRepository repository = new BlogRepository(context); return repository.GetPosts(blog).ToArray(); }}

41. Implement UpdatePostType in or copy and paste the code below to implement the UpdatePost service method on Service1. This method creates a new BlogContext and BlogRepository and calls UpdatePost.

public string UpdatePost(Post post){ using (BlogContext context = new BlogContext()) { BlogRepository repository = new BlogRepository(context); return repository.UpdatePost(post); }}

42. Build your solution by selecting from the menu Build | Build Solution.

Update the BlogApplication to use the BlogService

43. Add a service reference to BlogClientFrom the Solution Explorer, locate the BlogClient project. Right-click on the BlogClient project name, and from the context menu select Add Service Reference

44. From the Add Service Reference dialog click on the Discover button.45. Select the service that is found and click OK to add the service reference.


of 35


46. From the Solution Explorer, double-click on the MainWindow.xaml.cs file to open it.

47. Near the top of the file, add this using statement to use the service reference.

using BlogClient.ServiceReference1;

48. MainWindow currently uses the BlogRepository directly. In this step you will replace that with the service you implemented. Replace the BlogRepository declaration at the beginning of MainWindow class with a Service1Client declaration.

Service1Client _client;

49. Next replace the constructor for MainWindow with an implementation that instantiates a new Service1Client and calls the GetBlogs method.

public MainWindow(){ InitializeComponent();

_client = new Service1Client(); this.MainGrid.DataContext = _client.GetBlogs();}

50. Next replace the UpdateButton_Click method for MainWindow with an implementation that uses the service client.


of 35

Tasks Detailed Stepsprivate void UpdateButton_Click(object sender, RoutedEventArgs e){ Post post = PostList.SelectedItem as Post; if (post != null) { post.CreatedDate = post.CreatedDate.AddDays(2); MessageBox.Show(_client.UpdatePost(post)); this.MainGrid.DataContext = _client.GetBlogs(); }}

51. Finally replace the BlogList_SelectionChanged method for MainWindow with an implementation that uses the service client. When performing service operations, it is important to remember that the entities that are returned are new instances so the returned posts must be copied to the blog collection.

private void BlogList_SelectionChanged(object sender, SelectionChangedEventArgs e){ Blog blog = BlogList.SelectedItem as Blog; if (blog.Posts.Count == 0) { foreach (Post post in _client.GetPosts(blog)) { blog.Posts.Add(post); } }}

52. Press F5 to run the BlogClient

Update the repository to perform a save

In this set of steps you will modify the UpdatePosts method on the BlogRepository to save the updated post.

53. From the Solution Explorer, double-click on the BlogRepository.cs file from the BlogModel project to open it.

54. Locate the UpdatePost method on line 30 and replace the method contents with the code below that uses a new Entity Framework method, ChangeObjectState to mark the entity as modified.

public string UpdatePost(Post post){ string result = "Updated!"; try { post.Validate(); _context.Posts.Attach(post); _context.ObjectStateManager.ChangeObjectState(post, System.Data.EntityState.Modified); _context.SaveChanges(); } catch(Exception e) { result = e.Message;


of 35

Tasks Detailed Steps } return result;}

55. Press F5 to run the BlogClient. Click the Update button to see the update take place.

Additional Resources

MSDN Data Platform Developer Center

EF Design Blog

ADO.NET Entity Framework MSDN Documentation

The ADO.NET Entity Framework Overview MSDN Technical Article

ADO.NET Entity Framework and LINQ to Entities MSDN Forum

Entity Framework FAQ

http://blogs.msdn.com/dsimmons/pages/entity-framework-faq.aspx

http://social.msdn.microsoft.com/forums/en-US/adodotnetentityframework/threads/

http://msdn.microsoft.com/en-us/library/aa697427(VS.80).aspx

http://msdn.microsoft.com/en-us/data/aa937723.aspx

http://blogs.msdn.com/efdesign

http://msdn.microsoft.com/data

Download - ADO.net Entity Framework HOL Manual

Top Related