WCF RIA Services

Learn how to build data-backed Silverlight 4 applications with WCF RIA Services
Course info
Rating
(48)
Level
Intermediate
Updated
Sep 3, 2010
Duration
4h 55m
Table of contents
WCF RIA Services Overview
Exposing and consuming querying services
Updating data
Business Logic and Validation
Ria Services and Visual Studio
Description
Course info
Rating
(48)
Level
Intermediate
Updated
Sep 3, 2010
Duration
4h 55m
Description

Microsoft WCF RIA Services provides a pattern to write application logic that runs on the mid-tier and controls access to data for queries, changes and custom operations. It also provides end-to-end support for common tasks such as data validation, authentication and roles by integrating with Silverlight components on the client and ASP.NET on the mid-tier.

About the author
About the author

Yacine has been involved in the development of database-driven, n-tier web applications for over 10 years. Over time he has taken on various roles, including development, project management, offshore platform management and technical consulting. He has helped build a few solutions for Microsoft North Africa.

Section Introduction Transcripts
Section Introduction Transcripts

WCF RIA Services Overview
Hi and welcome to the first module of this talk series on WCF RIA Services. RIA Services is a new framework in Microsoft technology stack whose goal is to help developers build N-tier rich Internet applications more easily and in a more productive manner. And as we'll see, it's now been made part of the Windows Communication Foundation product family. This course will take an in-depth look at RIA Services, its architecture, and the way that it can be used to solve specific development problems. We'll focus primarily on Silverlight 4 in the client, so we'll assume that you have a basic understanding of how to create a simple Silverlight application using Visual Studio 2010 and C#. We'll also assume that you're familiar with the basic concepts and terminology of WCF. In this talk, we will take an introductory look at the RIA Services framework. We'll see what RIA Services is, the kinds of problems that it seeks to solve and how it addresses these problems. We'll take a glimpse at the way that the framework is architected on top of the WCF infrastructure and in the design-time pattern that the framework prescribes to achieve its main goal which is making data-driven rich Internet applications easier to implement. And finally, we'll take a quick guided tour of some of the main scenarios that RIA Services facilitates and we'll illustrate these scenarios with some demos along the way. So let's get started.

Exposing and consuming querying services
Hi, this is module two of our WCF RIA Services series. In this talk, we'll take an in depth look at data querying from a Silverlight application using RIA Services. So we'll begin by looking at the simple rules that govern the way that we define our query operations on the server, then we'll examine the client side generated code, and we'll zoom in on the domain context class, which is the chief orchestrator on the client. We'll delve into the asynchronous stated loading API that's exposed through the domain context class, and we'll talk about how data caching is managed on the client and what are the options available to the programmer when reloading data from the server. Then we'll see how we can extend on the clients the server queries that are executed by our server side operations using link and the client side API. We'll also see how to return object trees from our queries through simple declarative techniques. And we'll wrap up this talk with a brief look at the infrastructure behind the scenes and at the types of messages that are exchanged on the wire.

Updating data
This is talk number three of our WCF RIA Services Series. In the previous talk, we introduced the data querying infrastructure and capabilities provided by the framework. In this talk, we'll examine the create updates and delete part of CRUD operations which we may refer to CUD or submit operations. Just like we did for querying, we'll drill into each one of the steps that make up the standard development life cycle that's built right into the framework. So we'll begin by first looking at the framework rules for defining create update and delete operations in our domain service class. And the convention versus configuration options that are available to us. Then we'll jump over to the clients and we'll explore the clients side classes that are involved in data updating. And we'll also dig into the change tracking mechanism that are built into the client for us to use in our applications. We'll also examine the way that Submit operations are sent over the network. And the message formats that are used. And then we'll do a brief zoom on how the domain service processes the changes. We'll look at how to deal errors that commonly occur when something changes such as concurrency conflict errors. And finally, we'll wrap up with a closer look at updating related data in data object models.

Business Logic and Validation
Welcome to module four of our WCF RIA Services talk series. We're going to continue our exploration of the framework by taking an in-depth look at how we define business logic and validation in a RIA Services application. The framework defines a powerful and convenient integrated infrastructure that spans the client and the server, so we'll see what that infrastructure is made of and how we use it to validate our data, both when performing submit operations and also when conducting out of band validation tasks. But before we dive into the validation topic, we'll take a quick look at invoke operations, which we use to define non-CRUD application logic. And we'll see how we define them on the server and how to invoke these operations from Silverlight. Then we'll take an overview of the framework's validation infrastructure and its components, and we'll look at rule propagation mechanisms and at the client-side API, and we'll see how we apply common validation rules to our data using the classes in the system that component model, that data annotations namespace, both on the server and in the clients, and then we'll talk about the way that we define our own custom validation rules in an application and how we can arrange for these rules to be enforced in the client as well as on the server when appropriate. We'll zoom in on entity-level validation, which deserves special attention, and finally we'll look at how we can use invoke domain operations to make out-of-band non-CRUD server calls for performing certain validation tasks in the clients.