I had a good question in the comments of Part 2 of my series on WCF RIA Services that I thought I would answer here so more could find the information.

To paraphrase the question: “How can I retrieve a set of entities into my client and process them when the retrieval is complete?

I didn’t go into detail on the latter part of this in the article because of space limitations. But basically the answer is that you can be notified of the completion of any async operation (Load and SubmitChanges primarily) that you call on a RIA Services domain context. There are really two programming models, but I’ll just show one for now as the other is very similar.

When you call DomainContext.Load, RIA services executes the retrieval in the background and the call is non-blocking to the calling thread. But often you need to get those results, do some processing on them, and then move on to make another query or do something else.

An easy way to handle things is to use an overload of Load (and SubmitChanges) that takes a callback delegate that will be called when the async work is complete. This model is slightly different than the two other familiar async patterns in .NET: BeginXXX/EndXXX method pairs and XXXAsync/XXXCompleted method/event.

In the RIA Services async pattern, you can pass an Action<XXX> delegate to the async method you are calling, and that target method will be executed when the async operation is complete. It will pass you results and any error information if applicable.

In the case of a Load call, the code would look something like this:

private void RetrieveAndProcessTasks()
{
    TasksDomainContext context = new TasksDomainContext();
    EntityQuery<Task> query = context.GetTasksQuery();
    Action<LoadOperation<Task>> completeProcessing = delegate(LoadOperation<Task> loadOp)
    {
            if (!loadOp.HasError)
            {
                ProcessTasks(loadOp.Entities);
            }
            else
            {
                LogAndNotify(loadOp.Error);
            }

    };
    LoadOperation<Task> loadOperation = context.Load(query.Where(t=>t.EndDate > DateTime.Now),completeProcessing,null);
}

private void ProcessTasks(IEnumerable<Task> entities)
{
    // Do what you need to do
}
private void LogAndNotify(Exception error)
{
    // Log the error and notify user if appropriate
}

Before calling Load on the domain context, you set up an Action<LoadOperation<T>> delegate to point to a handling method with the signature void TargetMethod(LoadOperation<T> op). In this example I do that with an anonymous method that checks whether there are any errors, and if not hands off to a processing method the entities that were returned. If there is an error, it hands off the Exception to a handling method as well.

Then it is just a matter of calling Load and passing that delegate as a second argument (the first is always the EntityQuery you want to execute), and a final argument that is an arbitrary state object, similar to the Begin/End signatures of the original .NET async pattern.

Unfortunately there is no easy way to shield you entirely from the async nature of service calls in Silverlight if you want to do something other than data bind to the results immediately after the load occurs.

Tuesday, June 29, 2010 8:10:25 PM (GMT Standard Time, UTC+00:00)
Comments [4]  |