• Save
.NET RIA Services For Silverlight
Upcoming SlideShare
Loading in...5

.NET RIA Services For Silverlight



Ian Blackburn from bbits.co.uk gives the Silverlight UK User Group a talk on the new .NET RIA Services and its implementation within Silverlight applications. ...

Ian Blackburn from bbits.co.uk gives the Silverlight UK User Group a talk on the new .NET RIA Services and its implementation within Silverlight applications.

This presentation was given on 29th September 2009 at the EMC Consulting offices in London.



Total Views
Views on SlideShare
Embed Views



3 Embeds 73

http://www.slideshare.net 57
http://consultingblogs.emc.com 13
http://u_style.bg046.com 3



Upload Details

Uploaded via as Microsoft PowerPoint

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
Post Comment
Edit your comment

.NET RIA Services For Silverlight .NET RIA Services For Silverlight Presentation Transcript

  • .Net Ria Services for Silverlight
    Ian Blackburn
    Download RIA Services and documentation from http://www.microsoft.com/downloads/details.aspx?FamilyID=76bb3a07-3846-4564-b0c3-27972bcaabce&displaylang=en
    This presentation is a summary of the ~200 page document from there (plus some examples ;-)
  • Overview
  • Where do RIA Services Exist?
  • Presentation Technologies and DALs
    The current preview illustrates the pattern primarily through the end-to-end experience with Silverlight and EF or Linq to Sql
    but RIA Services are designed to work other Presentation and DALS as well
  • Getting Started
  • The DomainService Class
    This is the main class for authoring operations
    Such as CRUD behaviours
    It can be generated code in the first instance.
    You add your custom application logic to this class
    The [EnableClientAccess] attribute causes the tools to generate the corresponding client-tier classes when the project is built
  • The DomainContext Class
    A client side DomainContext class is generated for each DomainService
    This provides basic services such as invocation of operations, accumulation of results, object identity and change tracking
  • Sharing Code Between Client and Server
    Code that is written in the server side can be reused in the client side.
    To do this
    create a new class in the server side with a .shared.cs or .shared.vb suffix
    Mark the class and methods you want to share with the [Shared] attribute
    After you build the solution, Visual Studio will copy this file to the Silverlight client application:
  • Creating Query Methods in the Service
    Define Query Methods in your Domain Service
    These must:
    return a single instance T, or an IEnumerable<T> or IQueryable<T> where T is a valid Entity type
    takes 0 or more parameters
    Optionally be adorned with the QueryAttribute
  • Using Generated Query Methods in Silverlight
    When a query method is defined in the domain service, the code generator automatically creates
    A query factory method named [NameOfQueryMethod]Query
    The entity Type of the query method
    You use it by:
    createinganEntityQuery instance
    Applying LINQ query operators to it as needed
    Passing the query instance into DomainContext.Load
  • Example
    Note that the “orderby” is still happening on the server, and the Load is asynchronous
  • Support Query Operators in Silverlight
    EntityQuery exposes only a subset of LINQ query operators.
    These are:
    OrderBy / ThenBy
    Skip / Take
  • Metadata classes
    To add some validation rules that are applied on both tiers, you create a metadata class for the Domain Service
    affectionately called the “buddy class”
    This can be generated when you create the domain service by checking the box shown
    Or you can just add the MetadataType attribute manually to an entity class
  • Using Include on MetaData
    You need to mark the Suppliers metadata with an equivalent Include attribute so the correct code is generated on the client
  • Adding Validation rules to the Metadata class
    This is achieved through attributes on the properties of the class on the server
    This causes the generated entity class in the client to have the same validation applied
  • Modifying Data
    If you use the DomainService class wizard to generate DomainService class, then the generated service class has Create/Read/Update/Delete (CRUD) operations already
  • EntityContainer, EntityList and Change Tracking
    Entities loaded into a DomainContext are stored and change tracked by its EntityContainer
    This is the Entities collection on the context object
    An EntityContainer manages a set of EntityLists
    there is a 1:1 mapping between EntityLists and the entity Types exposed by your service
    You can get a list of entities for a particular type using GetEntityList<T>
    You can inspect the Entity.EntityState of an entity to determine the state of the entity
    Unmodified, Modified, New, Deleted
  • Change Sets (Unit of Work)
    A change set is a set of one or more entity operations to be processed as a single unit of work and can contain
    Entity Insert/Update/Delete operations
    Custom domain operations
    When SubmitChanges is called on the context the changes are all sent to the service all together
    You can get the current ChangeSet using the GetChanges method of the EntityContainer
    You can discard all pending changes, by calling RejectChanges on the context.
  • Server Side Change Set Processing
  • Error Handling
    You can throw validation exceptions in the Domain Service and then handle them in the client SubmitOperation completed event
  • Other Supported Features
    Concurrency Handling
    Concurrency errors are reported from the DomainService to the client
    You can handle them in the SubmitOperation completed event
    You can also create a Resolve method on your service to deal with resolution
    Transactions Support
    No built in support from the client, but you can of course wrap your domain methods in transactions
    Identity Management
    The Key attribute on entities is used to keep track of local entities
    Whenever an entity is loaded if there is a cached instance locally with the same identity or key value(s) the local instance will be retained, and the newly read instance is discarded
    You can change this behaviour with the MergeOption in the context Load method
  • Custom Methods and Service Operations
    Using Custom Methods
    You can create custom server methods in addition to basic create/update/delete operations
    These also support tracking on entities and deferred execution (e.g. When SubmitChanges is called)
    Mark them with the [Custom] attribute
    Call from the context or the entity itself in the client
    Service Operations
    More closely related to traditional web service
    Use the [ServiceOperation] attribute
    Don’t support tracking of deferred execution
  • Other features
    Silverlight DomainDataSource
    Use declarative code to define the interactions between your UI and the data
    Supports filtering, sorting, grouping, editing...
    Restrict Access to DomainService Operations
    You can authenticate using the membership system in asp.net
    Then configure access against operations roles and users
    Code Generated Hook Points
    Partial methods are supported in the generated code to give extensibility points
    E.g. OnCreated, OnPropertyNameChanged
  • Other Features
    .NET RIA Services Class Libraries
    permits packaging business logic into N-tier class library components rather than the Silverlight client and Web Site
    Ado.Net Data Services
    Stated goal is to align the two technologies such that Microsoft .NET RIA Services uses the same protocol as ADO.NET Data Services
    Business Applications Templates
    VS templates that builds on the Silverlight Navigation Application and using .NET RIA Services and provides support for Authentication and User Registration
  • Questions?
  • Concurrency Error
  • Naming Conventions
    “Insert”, “Add”, “Create” prefixes
    Method signature : void InsertX(T entity), where T is an entity Type
    “Update”, “Change”, “Modify” prefixes
    Method signature : void UpdateX(T current), where T is an entity Type
    “Delete”, “Remove” prefixes
    Method signature : void DeleteX(T entity), where T is an entity Type
    Method signature returning a singleton, IEnumerable<T> , IQueryable<T> where T is an entity Type, and taking zero or more parameters
    “Resolve” prefix
    Method signature : boolResolveX(T curr, T original, T store, boolisDelete) where T is an entity type