M10265 Developing Data Access Solutions with Microsoft Visual Studio 2010
Starting dates and places
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…
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
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.