M10265 Developing Data Access Solutions with Microsoft Visual Studio 2010

Level

M10265 Developing Data Access Solutions with Microsoft Visual Studio 2010

Focus on Training
Logo Focus on Training

Need more information? Get more details on the site of the provider.

Starting dates and places

There are no known starting dates for this product.

Focus on Training offers this product as a default in the following regions: N/A

Description

This course is for professional .NET software developers who use Microsoft Visual Studio in a team-based, medium-sized to large development environment. You will have experience implementing data access and data binding within their Web and/or Windows Client applications and are interested in learning to optimize data access (CRUD) within their applications using the Entity Framework, LINQ, and ADO.NET. You will be an experienced user of Microsoft Visual Studio 2008 SP1 or newer releases of the Visual Studio product. The will have some experience using Visual Studio 2010 for either Windows Client or Web application development
Typically, you will have the following knowledge/experience:

Exper…

Read the complete description

Frequently asked questions

There are no frequently asked questions yet. If you have any more questions or need help, contact our customer service.

This course is for professional .NET software developers who use Microsoft Visual Studio in a team-based, medium-sized to large development environment. You will have experience implementing data access and data binding within their Web and/or Windows Client applications and are interested in learning to optimize data access (CRUD) within their applications using the Entity Framework, LINQ, and ADO.NET. You will be an experienced user of Microsoft Visual Studio 2008 SP1 or newer releases of the Visual Studio product. The will have some experience using Visual Studio 2010 for either Windows Client or Web application development
Typically, you will have the following knowledge/experience:

Experience developing n-tier applications that access various data sources
Experience implementing data binding within their applications
Some experience using LINQ and ADO.NET
A conceptual understanding of the Entity Framework

In this course, experienced developers who know the basics of data access (CRUD) in Windows client and Web application environments will learn to optimize their designs and develop better performing data access code by using the ADO.NET Entity Framework, LINQ, WCF Data Services, the Sync Framework, and ADO.NET.

In this course, experienced developers who know the basics of data access (CRUD) in Windows client and Web application environments will learn to optimize their designs and develop better performing data access code by using the ADO.NET Entity Framework, LINQ, WCF Data Services, the Sync Framework, and ADO.NET.

Typical Course Outline

Module 1 – Architecture and Data Access Technologies
Module Goal: The goal of this module is to enable students to evaluate a variety of business cases, and then select an appropriate combination of data access technologies and tools most appropriate to each case. Students will learn about the roles of Entity Framework, Data Services, and ADO.NET for building and maintaining applications. They will also learn about the use of LINQ on top of these technologies to improve their productivity and the quality of their applications.

Lesson 1: Data Access Technologies

Describe the key data access technologies available to .NET Framework developers.
Overview of the Entity Framework, including EDMs, Object Services, and Entity SQL
Overview of LINQ
Overview of Synchronization Framework.
Overview of ADO.NET Data Services
Overview of ADO.NET

Lesson 2: Data Access Scenarios

Assign appropriate data access technologies to common data access scenarios.
Corporate applications
Externally accessible corporate applications
Partner-accessible applications.
Legacy applications.

Module 2 – Building Entity Data Models
Module Goal: The goal of this module is to enable students to use the tools provided with the Entity Framework to map the conceptual model used by the business logic of an application to the logical data model provided by a database.

Lesson 1: Entity Data Models

Describe and create an Entity Data Model.
Introduction to data models.
Model design strategies.
Introduction to the Entity Designer.
Mapping a model to a database.
The XML behind the model.
Model deployment considerations.

Lesson 2: Modifying the Entity Data Model

Modify an entity data model by using the Entity Designer.
Adding entities to a model.
Adding associations between entities.
Generating Transact-SQL scripts from a model.

Lesson 3: Customizing the Entity Data Model

Customize a model to meet your business requirements.
Using entity splitting.
Implementing an inheritance hierarchy.
Adding a stored procedure to a model.
Using complex types.

Module 3 – Querying Entity Data
Module Goal: The goal of this module is to enable students to query an entity data model by using common methods such as LINQ to Entities, Entity SQL, and the classes in the EntityClient namespace.

Lesson 1: Retrieving Data using LINQ to Entities

Describe how to retrieve data from an EDM by using LINQ to Entities.
Explain how the Entity Framework executes a query and materializes an object.
Key Content Areas:
Describe how to connect to the EDM.
Describe how to specify connection configuration options (using a configuration file, and encrypting connection information)
Describe the role of the ObjectQuery class.
Show how to query an entity using LINQ to entities.
Declaring a new type to represent data in a business object.
Show how to wrap retrieve data in a business object.
Describe how objects are identified by their EntityKey.
Explain what causes an entity to materialize an object and when.

Lesson 2: Retrieving Data using Entity SQL

Describe how to retrieve data from an EDM by using Entity SQL.
Show how to construct an Entity SQL query that includes parameters.
Show how to query an entity using Entity SQL.
Declaring a new type to represent data in a business object.
Show how to wrap retrieved data in a business object.

Lesson 3: Retrieving Data using Entity Client

Describe how to retrieve data from an EDM by using Entity Client
Describe how to connect to the EDM using Entity Client.
Show how to construct an Entity Client query, that includes parameters by using Entity SQL.
Describe how to run the Entity Client query.
Declaring a new type to represent data in a business object.
Show how to wrap retrieved data in a business object.

Lesson 4: Retrieving Data using Stored Procedures

Describe how to retrieve data from an EDM by using a stored procedure.
Adding a function import to the model.
Show how to programmatically invoke a stored procedure in the model.

Lesson 5: Unit Testing Data Access

Show how to write unit tests to test DAL methods.
Setting up dummy test data, making use of business object types.
Writing TestMethods to test the query methods in the DAL.

Module 4 – Creating, Updating, and Deleting Entity Data
Module Goal: The goal of this module is to enable students to perform data modification (CUD) tasks through an entity data model by using LINQ to Entities, Entity SQL, and the classes in the EntityClient namespace.

Lesson 1: Understanding Change Tracking in the Entity Framework

Describe the role of the ObjectContext and ObjectStateManager classes in the data modification process.
Describe the differences between detached and attached entity objects.
Describe how the ObjectStateManager tracks changes to entity objects.
Describe the ObjectStateManager property of the ObjectContext class and the ObjectStateEntity type
Describe Detached and Attached Objects.
Describe how change tracking works in the EF.

Lesson 2: Creating Data in an Entity Data Model

Create a new entity object and persist the entity to the database..
Use a stored procedure to insert a new entity into the database.
Show how to add data to an entity, from a business object.
Describe how to add data to an entity, using a parameterized stored procedure.
Handling UpdateExceptions.
Writing unit tests.

Lesson 3: Updating Data in an Entity Data Model

Describe how to update data by using an Entity Data Model
Use a stored procedure to update an entity in the database
Show how to update data in an entity.
Describe how to update data in an entity, using a parameterized stored procedure.
Handling UpdateExceptions.
Writing unit tests.

Module 5 – Handling Multi-User Scenarios by Using Object Services
Module Goal: The goal of this module is to provide students with a deeper understanding of the object model implemented by EF, and the support provided by the Object Services API for addressing the issues faced by enterprise applications that have handle multiple concurrent users accessing the same data simultaneously.

Lesson 1: Handling Concurrency

Describe how to manage concurrent access to the database.
Describe the different approaches available for dealing with concurrency violations
Describe how the SaveChanges method of the ObjectContext class behaves when a concurrency exception occurs
Setting the ConcurrencyMode property.
Describe different strategies for handling concurrency violations.
Handling OptimisticConcurrencyExceptions.
Refreshing the ObjectContext – StoreWins vs. ClientWins.
Writing unit tests.

Lesson 2: Transactional Support

Describe how to perform transactions by using the Entity Framework.
Describe how the Entity Framework implements transactions when saving changes
Describe how and when to implement a Transaction using TransactionScope (modifications spanning multiple models and resources).
Describe different strategies for handling failed transactions.
Writing unit tests.

Module 6 – Building Optimized Solutions by Using Object Services
Module Goal: The goal of this module is to describe best practices for designing and building a scalable, optimized data access layer by using Object Services.

Lesson 1: The Stages of Query Execution

Explain what happens when the Entity Framework executes a query.
Describe where performance enhancements can be made.
Loading Metadata
Opening Database connections
Generating views
Preparing Queries
Executing Queries
Loading and validating types
Tracking
Materializing objects
Use of ToTraceString

Lesson 2: Tracking and Object Materializatio

Explain the lifetime of entities in the ObjectContext.
Explain when objects are materialized.
Describe the impact of change tracking on performance.
Key Content Areas:
Use of different merge options and their effect on the object cache.
How objects are identified by their EntityKey.
What causes the EF to materialize an object and when.

Lesson 3: Using Compiled Queries

Describe the benefits of using compiled queries.
Explain how to compile a query
What happens when a LINQ query is prepared.
Benefits of pre-compilation.
Syntax for defining a compiled LINQ query.

Lesson 4: Using Design-Time generated views

Describe the benefits and drawbacks of Design-Time generated views.
Explain how to create Design-Time generated views.
Pros and cons of Design-Time generated views.
Process for pre-generating views.
Changes in connection-strings in app.config.

Lesson 5: Monitoring Performance

Describe how to monitor performance and collect performance data.
Logging the SQL statements generated by LINQ to Entitites (ToTraceString method of ObjectQuery class)
Describe key Perfmon counters for monitoring the performance of data access operations and queries.

Lesson 6: Performing Asynchronous Data Modifications

Explain the benefits of performing asynchronous modifications.
A pattern for asynchronous modifications using a BackgroundWorker component.
Error handling in DoWork.
Reporting results to a client.
Implications for client.

Module 7 – Customizing Entities and Building Custom Entity Classes
Module Goal: The goal of this module is to enable students to customize and extend entities with their own business logic, and to use advanced mappings and other techniques in the Designer and XML to shape the data model to their business and application requirements (rather than an EDM that closely reflects the database).

Lesson 1: Overriding Generated Classes

Use partial classes and methods to add business logic to generated code.
Using partial classes
Using partial methods
InContextCreated method
OnChanged and OnChanging methods
SavingChanges event
PropertyChanging and PropertyChanged events
AssociationChanged event

Lesson 2: Creating T4 Templates for Customized Code

Modify a T4 template to customize generated code.
Adding Code Generation Items to a Model
Code Generation Templates
Defining custom interfaces in a template
Configure a model to use a template

Lesson 3: Using T4 Templates

Use a T4 template to access custom business logic from an application.
View template methods in a model
Implement a template interface in a model
Call an implementation of a template interface from client code

Lesson 4: Creating and Using Custom Entity Classes

Modify existing business classes to take advantage of entity functionality.
Defining a custom entity – EntityObject vs. implementing IEntityWithKey, IEntityWithChangeTracker, and IEntityWithRelationships
Inheriting from EntityObject
Using the EdmEntityTypeAttribute attribute
Using the EdmScalarProperty attribute
Using the EdmRelationshipNavigationPropertyAttribute attribute
Using a custom entity class

Module 8 – Using Persistence-Ignorant Classes with the Entity Framework
Module Goal: The goal of this module is to enable students to reuse existing POCO business classes in a data access layer built by using the Entity Framework.

Lesson 1: Requirements for Persistence-Ignorant Objects

Define the requirements that a POCO class must meet for the EF to able to generate proxy classes that support lazy loading and change tracking.
Define the minimum requirements that a POCO class must meet so that it can be loaded by the EF.
Key Content Areas:
This lesson will set out what features a custom entity class must have in order for it to be used by an entity model (without automatic support for lazy loading and change tracking).

Lesson 2: Persistence-Ignorant Objects and Lazy Loading

Describe how to create a custom ObjectContext class that can load your custom entity classes.
Description of behavior of generated proxy classes.
This lesson will show how a custom ObjectContext class works and how it can support lazy loading if the entity classes meet the requirements.
If the entity classes don't support lazy loading, show how to explicitly load related objects.

Lesson 3: Persistence-Ignorant Objects and Change Tracking

Describe how custom entity objects can support automatic change tracking.
Describe how to manually implement change tracking for custom objects if they don't support automatic change tracking.
Understand how changes are tracked in the ObjectContext by the ObjectStateManager.
What is the effect of calling DetectChanges().
SaveChanges() calls DetectChanges() by default.

Lesson 4: Interfaces and Inheritance for Custom Entity Objects

List the Interfaces implemented by standard entity classes and by the proxy classes generated from the custom entity classes (IEntityWithChangeTracker, IEntityWithKey, IEntityWithRelationships).
Understand the role of the IEntityWithChangeTracker.
Understand what these three interfaces define.
Understand why you don't need to implement them in your custom entity classes.
NOTE: These interfaces are not directly used in the Lab exercises.

Module 9 – Building an N-Tier Solution by Using the Entity Framework
Module Goal: The goal of this module is to enable students to address the architectural issues that can arise when building an N-Tier enterprise application by using the Entity Framework.

Lesson 1: Designing an N-Tier Solution

Describe the issues that an architect must consider when designing an N-Tier solution for a data access layer
Describe strategies for defining and implementing the functional interface exposed by the DAL
This lesson is a roadmap of all the issues an architect must consider when building an N-Tier DAL (details are covered in subsequent
lessons in this module and module 10)
a. What operations will client applications require?
b. How to partition operations – which clients can perform which operations?
c. What data will client applications need?
d. How to partition data – which clients can access which data?
e. How to minimize the network overhead (avoiding chattiness)?
f. What are the options for transporting data from the DAL to the client (serialization)?
g. How to protect data as it is being transported over the network.
h. What technology to use to host the DAL?
i. How to maximize scalability in the DAL
Defining operations – keep them business focused rather than data-centric (ie RetrieveOrders, PlaceOrder, CancelOrder rather than GetData/PutData style operations)
Patterns for transporting data:
a. Change Set (DataSet style functionality – functional, but bulky and non-portable),
b. Simple Entities (POCO copy of entire data retrieved from the database for each entity, serialized, but need to implement mechanism for tracking changes),
c. DTOs (POCO copy of data for each entity, but containing only the specific data required to perform a particular operation – if the client does not need to see a particular field, it does not get it. Attach/detach from ObjectContext for tracking changes)
d. Self-Tracking Entities (entities with change-tracking built-in – easy to program against, but contains all data for an entity – cannot be easily selective – and possibly bulkier than SE and DTO),
Options for hosting a service to support operations (WCF most likely, probably exposing an HTTP interface if interop is important)
Anti-patterns to avoid (tight coupling, assuming static requirements, statefulness, don't let a request retrieve too much or too little data – chattiness (lots of little requests) vs swamping (fetching most of the database in a single request))

Lesson 2: Defining Operations and Implementing Data Transport Structures for an N-Tier Solution

Describe how to build a DAL by using WCF and self-tracking entities
Show how to use the STE template to build the entity library for a DAL
Walk through the code generated for an entity class and show how to customize the entity classes (partial classes, as per module 7).
Show the built-in change-tracking mechanism for an entity.
Contrast the code for an STE with that for a simple entity (no tracking) and a DTO (more selective on data transported) – show typical examples (SE and DTO will have to be hand-crafted code)
Show how to define DAL operations by using a WCF service and contract, and how to transport entity data
Summarize/recap how to handle exceptions and propagate them as faults to client applications (throwing exceptions puts the service instance into the Faulted state (fatal), whereas throwing faults does not require closing the service instance and reopening it)
Scalability (WCF-specific – use PerCall and don't maintain state between calls)
Show how to define and implement a simple (single entity) and more complex (parent/child) query operation (WCF contract and implementation)
Explain how STE manages parent/child relationships in code generated for entities (possible impact of lazy loading by LINQ – child rows might not be transported unless fetched eagerly by underlying LINQ queries)Consuming operations in a client application – assembly structure for reducing/eliminating client dependencies on the Entity Framework (place entity classes in a separate assembly from the EF-specific code in the DAL, and distribute this entity assembly to client apps)
Walk-through a complete (simple) example – WCF service hosting a DAL, client app consuming the DAL – how to structure the service, how to organize the assemblies, how the client invokes the DAL, etc.

Lesson 3: Protecting Data and Operations

Describe how to build security into an N-Tier DAL solution
Key security considerations – restricting access to operations to specific clients (e.g. not all clients can perform the GetAllOrders operation to retrieve orders for customers other than themselves). NOTE: If following best practices for defining DAL contracts, restricting access to operations automatically limits the data that a client can see

Show examples of authn and authz in a DAL implemented by using a WCF service
Protecting data as it traverses the network – encryption – when to use message level vs when to use transport level security (possible requirements and tradeoffs for client-initiated transactions, reliable messaging, etc)
Protecting the service against common attacks – e.g. DoS

Module 10 – Handling Updates in an N-Tier Solution by Using the Entity Framework
Module Goal: The goal of this module is to enable students to build extensible solutions that can update data in an N-Tier enterprise application by using the Entity Framework.

Lesson 1: Tracking Entities and Propagating Changes

Describe strategies for recording and tracking changes made to entities by a client application, and how to propagate these changes through the Entity Framework to the database.
Contrast the 2-Tier scenario and N-Tier – in 2-Tier (described in earlier modules), change-tracking is performed by the object context. In N-Tier, entity objects are detached when passed over the network. When they are returned, code in the DAL has to reattach them and work out what has changed.
Describe the detach/serialize to client/receive from client/reattach/update state sequence when object context (ObjectStateManager) maintains object state information (mention that when an object is reattached it is treated as a new object rather than an updated one by default, hence the need to inform the ObjectStateManager of the real state). Recap the methods of the ObjectStateEntry class, and the relevant methods of the ObjectContext class for attaching, detaching objects.
Describe how the EF maintains consistency of state in a graph of objects (if you attach an object that contains a graph, the object is "new" as are all the objects in the graph – need to walk the graph and set the state of each object appropriately(
Walk through a simple example showing how to use a DTO in an N-Tier solution
Describe differences in the DAL when using STEs – the ApplyChanges extension method of STE object sets, and the MarkAsDeleted, MarkAsAdded, MarkAsModified, and MarkAsUnchanged extension methods of STEs.
Describe how EF handles graphs when using STEs (no need to manually walk a complex graph and set the state appropriately)
Walk through a simple example contrasting the code for using an STE with that for using an DTO

Lesson 2: Managing Exceptions in an N-Tier Solution

Describe how to trap and manage update and concurrency issues in an N-Tier solution.
Recap the purpose of UpdateException and OptimisticConcurrencyException, and possible strategies for recovering from a concurrency exception.
Describe how to handle and report concurrency exceptions in an N-Tier solution – wrap in a fault together with information that a client application can use to decide how to resolve the conflict. Enable the client to abort (StoreWins) or retry (ClientWins) the operation.
Walk through a complete example.

Module 11 – Building Occasionally-Connected Solutions
Module Goal: The goal of this module is to enable students to access offline data, or data that that has limited availability in client applications.

Lesson 1: Offline Caching Data using XML

Describe how to cache data in local XML files by using LINQ to XML.
Describe how to retrieve data from a cache of XML files by using LINQ to XML.
Describe the structure and purpose of LINQ to XML and the datatypes XDocument, XElement, etc.
Provide detail on how to detect the availability of a Web service.
Describe how to persist data from the Web service to local XML files, by using LINQ to XML.
Describe how to load data from local XML files, by using LINQ to XML, when the Web service is unavailable.
Describe how to encrypt XML files.

Lesson 2: Using the Sync Framework

Use the Sync Framework to implement an occasionally-connected application.
Motivation and scenarios driving OCAs
Overview and architecture of the Sync Framework (including how providers and orchestrators work)
Sync Framework vs. RDA and replication
Architecture of Sync Framework applications
Configuring a local database cache
Securing a local database cache
SQL Scripts
Initializing a local database
Synchronization settings
Change tracking
Synchronizing data
Handling conflicts
Using the Configure Data Synchronization dialog box
Programmatically controlling the synchronization process
Customizing the synchronization process

Module 12 – Querying Data by Using WCF Data Services
Module Goal: The goal of this module is to enable students to design, develop, and consume a simple data service.

Lesson 1: Introducing WCF Data Services

Describe the purpose and features of WCF Data Services
Recap the REST model
Summarize the role of the Open Data Protocol (OData)
Describe how WCF Data Services exposes data by using the REST model (see http://msdn.microsoft.com/enus/data/aa937697.aspx
and http://msdn.microsoft.com/en-gb/library/cc956153.aspx)
Describe options for hosting a WCF Data Service (IIS, WCF service host app – see http://msdn.microsoft.com/engb/library/cc668805(VS.100).aspx)

Lesson 2: Creating a WCF Data Service

Describe how to build a WCF Data Service
Walk through the process of building a WCF Data Service that exposes data from an entity model (see http://msdn.microsoft.com/en-gb/library/cc907912.aspx)
Show how to access the data exposed through a WCF Data Service from a Web browser
Describe operators that users can use to filter, select, and navigate through data ($select, $top, $expand, $orderby, $skip, $filter [including expressions] see http://msdn.microsoft.com/en-us/library/cc668784(VS.100).aspx
Show how to page through data exposed througha WCF Data Service
Show how to use the DataServiceConfiguration object to limit the number of rows returned, set page sizes, enable/disable projections, etc
Describe how to handle exceptions raised in a WCF Data Service by overriding the HandleExceptions method (provide some details on the DataService class)
Describe how to define an operation in a WCF Data Service (call a stored procedure, perform some non-relational business logic, etc), and how to use the CurrentDataSource property to access the data source behind the WCF Data Service
Describe how to publish a WCF Data Service from Visual Studio by using One Click publishing

Lesson 3: Consuming a WCF Data Service

Describe how to build a client application that can consume a WCF Data Service
Show how to consume a WCF Data Service from a client application (add service reference, and access the service through the generated Data Service Client Library – see http://msdn.microsoft.com/en-us/data/cc974504.aspx).
Describe how to use the DataSvcUtil utility to generate the client library from the command line
Describe how WCF Data Services handles associations between entities, contrast the options available for delay-loading related entities by using the Load() method with retrieving related data immediately (by using the $expand operator with a URL) – see http://msdn.microsoft.com/en-gb/library/ee358709(VS.100).aspx
Show how to use LINQ to WCF Data Services in a client application
Describe how to use the generic DataServiceCollection (concentrate on non-tracked collections for this module) and DataServiceQuery types in a client application, and how to page through a DataServiceCollection.
Describe how to trap exceptions in a client application by using the DataServiceClientException and DataServiceQueryException exception types
Describe how to access an operation in a WCF Data Service
Describe how to invoke WCF Data Service operations asynchronously
Describe how to materialize data into a local, hand-crafted type in a client application (see http://msdn.microsoft.com/enus/data/cc974504.aspx)

Lesson 4: Protecting Data and Operations in a WCF Data Service

Describe how to grant and restrict access to resources exposed by a WCF Data Service
Describe how to configure and protect the endpoint exposed by a WCF Data Service (WCF configuration?)
Provide detail on setting entity and operation rights
Describe how to hide columns that should not be visible to a user
Describe how to use a query interceptor to restrict access to rows that should not be visible to a user
Describe how to restrict access to operations

Module 13 – Updating Data by Using WCF Data Services
Module Goal: The goal of this module is to enable students to use WCF Data Services to update and delete data and handle multi-user concerns.

Lesson 1: Creating, Updating, and Deleting Data in a WCF Data Service

Describe how to create, update, and delete entities by using a WCF Data Service
Describe how CUD operations map to HTTP POST, MERGE, and DELETE operations
Describe how WCF Data Services support merge-based and replace-based semantics for performing updates
Describe how WCF Data Services supports deep insert operations that can insert a graph of objects
Describe how to use the WCF Data Services client library (generated by adding a service reference) to retrieve data and create a tracked collection of entities.
Describe how to use the DataServiceContext object to programmatically insert, update, and delete data in a client application, and how these commands are mapped to HTTP requests (see http://msdn.microsoft.com/en-gb/library/dd756361(VS.100).aspx and http://msdn.microsoft.com/en-gb/library/cc907912.aspx for details)
Describe the SaveChanges method of the DataServiceContext, and how and when changes are transmitted to the WCF Data Service
Describe the DataServiceRequestException that can be thrown when sending a request (as opposed to a query) to a WCF Data Service
Describe how to attach new entities to a tracked collection in a DataServiceContext object
Describe how to create and modify relationship links (see http://msdn.microsoft.com/en-gb/library/dd756361(VS.100).aspx)
Describe how WCF Data Services handles concurrency issues when updating and deleting data.

Lesson 2: Preventing Unauthorized Updates and Improving Performance

Describe how to protect data from unauthorized changes, and improve the performance when modifying data
Show how to use a change interceptor to restrict the users that can modify data, the data that they can modify, and the operations that they can perform, and also to validate data sent to a WCF Data Service
Describe how to batch multiple modifications together into a single HTTP request to reduce network roundtrips and improve performance (see http://msdn.microsoft.com/en-gb/library/dd744839(VS.100).aspx)

Lesson 3: Using WCF Data Services to Access and Update Non-Relational Data

Describe how to build custom classes and expose collections of these classes through WCF Data Services
Walk through a simple example (see http://msdn.microsoft.com/en-us/data/cc745968.aspx)
Describe the Reflection provider and the role of the IQueryable, IExpandProvider and IExpandedResult interfaces with WCF Data Services
Describe and how to implement the IUpdatable interface to enable a client application to non-relational update objects through WCF Data Services (see http://msdn.microsoft.com/en-gb/library/dd723653(VS.100).aspx)
Describe how to implement a service that supports streaming of binary and BLOB data by implementing the IDataServiceStreamProvider in a data service and using the GetReadStream and SetSaveStream methods of the DataServiceContext class- see http://msdn.microsoft.com/en-gb/library/ee358709(VS.100).aspx and http://msdn.microsoft.com/en-gb/library/ee358709(VS.100).aspx (last section on this page)

Module 14 – Using ADO.NET
Module Goal: The goal of this module is to enable students to develop high performance, scalable ADO.NET applications that can query and update data.

Lesson 1: Retrieving and Modifying Data by Using ADO.NET Commands

Describe how access and update data by using ADO.NET commands and stored procedures
Describe how to connect to a data source and specify connection configuration options
Describe the different Data Providers available
Describe how to retrieve data, and how to use a DataReader for forward-only, read-only operations can improve application performance
Describe how to query BLOB data.
Describe how to use the SqlFileStream type to read filestream data
Show how to use the DbCommand class to implement CUD operations
Show how to use parameterized stored procedures to perform query and update operations

Lesson 2: Retrieving and Modifying Data by Using DataSets

Describe how access and update data by using DataSets
Show how to use DataSets, DataTables and DataViews to query data
Describe when to use a DataReader over a DataSet: Caching data locally in a client, Interacting with data dynamically such as when binding to a Windows Forms or WPF control or when combining and relating data from multiple sources, Performing extensive processing on data without requiring an open connection to the data source (freeing the connection for other clients)
Describe how to modify data by using a DataSet
Describe how to define and implement a strongly typed DataSet

Lesson 3: Managing Transactions and Concurrency in Multi User Scenarios

Describe how to implement transactions
Describe how to handle optimistic concurrency exceptions
Describe how to use the TransactionScope class to implement transactions
Describe how to perform a distributed transaction
Show how to test for concurrency violations
Describe the different approaches available for dealing with concurrency violations

Module 15 – Using LINQ to SQL
Module Goal: The goal of this module is to show students how LINQ to SQL enables them to develop against a logical model which abstracts the low-level details of querying ADO.NET tables and result sets.

Lesson 1: Designing a Logical Data Model by Using LINQ to SQL

Describe how to use the O/R Designer to build a logical model for LINQ to SQL
Describe the classes and types used by LINQ to SQL
Describe the LINQ to SQL object model
Show how to use the OR Designer to build a LINQ to SQL model
Walk through the code generated for the entity classes.
Show how to using Deferred loading can improve performance
Customizing Insert, Update and Delete Operations using Stored Procedures
Show how to customize entity classes and map database relationships using the EntitySet and EntityRef classes
Describe how to build a custom Entity class

Lesson 2: Querying and Managing Data, and Handling Concurrency

Describe how to query and manage data by using LINQ to SQLDescribe how to handle concurrency issues with LINQ to SQL
Show how to query the database by using LINQ to SQL (include coverage of sorting, filtering, joining, etc)
Show how to make and submit changes to the database by using LINQ to SQL.
Describe how to use the DataContext.Log property to trace the SQL statements generated and executed by a LINQ to SQL data model
Show how retrieving information as read-only can improve performance.
Describe how to control how much data is retrieved using LoadWith and AssociateWith
Describe how to manage change conflicts: Detecting and resolving conflicting submissions, Show how to specify which members are tested for concurrency conflicts, describe how to retrieve conflict information
Show how to resolve conflicts (Retain / overwrite and merge

There are no reviews yet.

Share your review

Do you have experience with this course? Submit your review and help other people make the right choice. As a thank you for your effort we will donate £1.- to Stichting Edukans.

There are no frequently asked questions yet. If you have any more questions or need help, contact our customer service.