About Alex van Beek

I'm always keen to keep up with all the new and fancy technologies and I enjoy teaching those technologies to other people. I'm currently specialized in .Net, Flex, (enterprise) Silverlight and mobile development: Android and Windows Phone

Silverlight: Navigation Framework tip: using the XAML escape sequence

Posted on 26 October 2011 by Alex van Beek

With all the Windows 8/Metro/WinRT hype on the internet today, I decided it was time for a quick tip concerning the XAML escape sequence and the good old navigation framework present in Silverlight 4 and Silverlight 5. I only learned about the XAML escape sequence until recently and I can image that there quite a number of people out there that are still unfamiliar with it. The nice thing is that you can also use the XAML escape sequence in WPF, Windows Phone and WinRT, if you like to do so. Continue reading →

The C# using statement and suppressed exceptions compared to Java 7 try…with

Posted on 29 July 2011 by Alex van Beek

Yesterday Java SE 7 was released. Last night I had the opportunity to play with some of it’s new features, including Java 7’s new “resource management” syntax. Of course, we have had this feature in C# for quite some time, but I was actually curious to see whether the Java people learned from the C# implementation and thus implemented it in a better way. Much to my surprise , they did. Let me elaborate……

The example

Take a look at the following C# class:

    class MyResource : IDisposable
   {
  
       public void DoWork()
       {
           Console.WriteLine("Working!!!!!!!!");
           throw new ArgumentException("A");
       }
  
  
       public void Dispose()
       {
           throw new ArgumentException("B");
       }
   }

It’s a class that implements IDisposable (in Java 7 it’s called AutoClosable) so it can be used with C#’s using statement. Now imagine that we create a method “CallDoWork”, which wraps a call to DoWork in a using block. This “CallDoWork” method is called by an external caller. Can you guess what happens when the CallDoWork method is called? Will the caller get the “A” exception from the DoWork method or the “B” exception from the call to the Dispose method? Take a look at the following program:

   class Program
  {
      static void Main(string[] args)
      {
  
          try
          {
              CallDoWork();
          }
          catch (Exception ex)
          {
              Console.WriteLine(ex.Message);
          }
          Console.ReadKey();
      }
  
  
      private static void CallDoWork()
      {
          using (MyResource r = new MyResource())
          {
              r.DoWork();
          }
      }
  }

So the question actually is, “What will be the output of this program? A or B?” Well here it is:

This means that that exception A has just disappeared, which could be a problem, since most exceptions should be logged somewhere. Let’s change the CallDoWorkMethod in a way that an exception from the DoWork method is logged and an exception from the Dispose method is also logged:

        private static void CallDoWork()
       {
           try
           {
               using (MyResource r = new MyResource())
               {
                   try
                   {
                       r.DoWork();
                   }
                   catch (Exception ex)
                   {
                       Console.WriteLine(ex.Message);
                   }
               }
           }
           catch (Exception ex)
           {
               Console.WriteLine(ex.Message);
           }
        }

So how does the using block look now? Not quite as small right? Don’t worry, the alternative without a using statement is still worse:

          MyResource r = null;
         try
         {
             r = new MyResource();
             r.DoWork();
         }
         catch (Exception ex)
         {
             Console.WriteLine(ex.Message);
         }
         finally
         {
             if (r != null)
             {
                 try
                 {
                     r.Dispose();
                 }
                 catch (Exception ex)
                 {
                     Console.WriteLine(ex.Message);
                 }
             }
         }

Note that I haven’t even added code to wrap the exceptions and rethrow them. Also note that this isn’t a problem that’s purely theoretical. Take a look at the following code snippet:

class Program
{
    static void Main(string[] args)
    {
        try
        {
            CallService();
            Console.WriteLine("Service call succeeded!");
        }
        catch (Exception ex)
        {
            Console.WriteLine("Unexpected error occured: " + ex.Message);
        }
        Console.ReadKey();
    }
  
  
    private static void CallService()
    {
        using (HelloServiceClient client = new HelloServiceClient())
        {
            client.DoWork();
        }
    }
}

The code in the main method calls CallService defined on line 18. This methods wraps a call to a WCF Service in a using block. This WCF Service uses a wsHttpBinding. Now take a look at the output if the service is down:

This is NOT the error message from the call to the proxy, but it’s an error message from an exception that get’s thrown because the Dispose method was called while the channel was in the “Faulted” state. Now I know that in WCF you should check before you dispose and that you shouldn’t use proxies in a using statement, but I wanted you to show that there are framework Dispose methods that actually throw exceptions. Next to that, you might never know for certain whether a third party component throws an exception in a Dispose method. In a real life application you’ll probably don’t sprinkle exception handling code like the above throughout your application, you’ll probable create some generic solution or handle exceptions in a certain layer of your application. I just want to make you aware that a using statement can suppress an exception and that this exception might never reach your exception handling solution or your exception handling layer.

The Java way and the new Try…With syntax

As I previously stated, the guys at Oracle have learned from the using statement in C# and implemented a nice solution:

public class TryWithRes 
{    
    public static void main(String[] args) 
    {        
        try(NewResource res = new NewResource("Res1 closing"))
        {
            res.doWork();
        } 
        catch(Exception e)
        {
            System.out.println("Exception thrown by doWork()" + e);
            if(e.getSuppressed() != null)
            {                
                for(Throwable t : e.getSuppressed())
                {                    
                    System.out.println("Exception thrown by close(): " + t);                
                }            
            }        
        }     
    }
}

I have formatted the code in a C# way so all you C# guys can follow along . Instead of the “using” keyword, Java 7 uses the try keyword on line 5. I’ve seen some people on the internet complaining about the “try” on line 5 instead of a new keyword, but because of the try keyword, the catch on line 9 feels very natural to me. Java 7 also shows different behavior, the exception that get’s caught on line 9 isn’t the exception that get’s thrown by the close() method of NewResource, like it would be the case when you surrounded a using block in C# with try..catch, but it’s the exception from doWork(). Next to that, the Exception class was expanded with a new “getSuppressed()” method (shown on lines 12 and 14), which you can use to get the exception from the close method. Technically, I didn’t need a foreach loop on line 14, this would be needed if I nested multiple try…with statements, but I just wanted to show that getSuppressed() returns a collection.

You don’t have to provide a catch when using the new try…with syntax, so now you can create a generic exception handling solution or layer and you can log all the exceptions thanks to the new getSuppressed() method, without losing any of them and while still using automatic resource management. If you want to know more about the new Java 7 try…with syntax, you can find an excellent article on the Oracle website here.

Conclusion

I have to say, I really like the new try…with syntax and also how suppressed exceptions are dealt with. The big difference between “using” and “try…with” is obviously that “using” in C# generates a “try…finally” in IL, while “try…with” in Java generates a “try…catch…finally” in bytecode. The “catch” stores the primary exception and when the “finally” executes and an exception is thrown, this exception is added to the primary stored exception using the new “addSuppressed()” method. After this, the stored primary exception which holds the suppressed exception, is thrown from the finally block.

I think this a perfect example of how .Net and Java drive each other to get better and I can only congratulate Oracle and the Java community on a great Java 7 SE release!

Windows Phone 7.1: WCF Data Services and tomb stoning

Posted on 1 June 2011 by Alex van Beek

In Windows Phone 7 there was support for using WCF Data Services, but this support was somewhat limited. For example, using the LINQ syntax wasn’t supported, so we had to create our uri’s ourselves. Next to that, we had to generate our classes manually, using the command line and DataSvcUtil.exe. In Windows Phone 7.1 things have changed. We can now use LINQ syntax to create our uri’s and we have support for”Add service reference” in Visual Studio 2010. This article will show how to get started with WCF Data Services and Windows Phone 7.1, which is important as it will be the primary way to access your data from a Windows Phone application.

The Server

In order to get started with WCF Data Services and Windows Phone 7.1, we’ll need to create a WCF Data Service. Here is an overview of my web project, which is hosted in the same solution as my Windows Phone 7.1 application:

This isn’t that exciting. I started out with an empty ASP.NET web project and added an entity data model to it (the .edmx file). I only selected the Product table from the Adventureworks database. After adding the .edmx file, I added a new WCF Data Service to it. Here is the code in the .svc file:

using System.Data.Services;
using System.Data.Services.Common;
  
namespace ProductServiceHost
{
    public class ProductService : DataService<AdventureWorks2008Entities>
    {
        public static void InitializeService(DataServiceConfiguration config)
        {
            config.SetEntitySetAccessRule("Product", EntitySetRights.All);
            config.DataServiceBehavior.MaxProtocolVersion = DataServiceProtocolVersion.V2;
        }
    }
}

As you can see, it’s a normal WCF Data Service which uses my AdventureWorks2008Entities ObjectContext. I won’t go into detail about WCF Data Services at the server, since there isn’t any difference at the server for a Windows Phone client. Just a remark on the side, you have to love the little amount of effort it takes to create a WCF Data Service!

The Windows Phone client

Let’s first take a look at the client application:

As you can see, the client simply shows the products in a listbox. Beneath the listbox there are buttons to perform CUD functionality. If the user selects a product and presses “View”, the UI changes and a few properties can be edited:

When the user presses the save button in the top screen, all the changes (inserts, deletes and updates) will be submitted to the WCF Data Service shown earlier.

Loading data

The first thing to do is to use the new “Add Service reference feature” in Visual Studio 2010:

This will generate our client classes. Now you might think that if you’ve already used the OData client library in the full .Net framework you know what’s coming. This is partially true. The OData client library for Windows Phone uses a somewhat easier programming model. Let’s take a look at where the data is loaded:

// Constructor
    public MainPage()
    {
        InitializeComponent();
        _context = new AdventureWorks2008Entities(new Uri("http://localhost:49753/ProductService.svc/", UriKind.Absolute));
        _products = new DataServiceCollection<Product>(_context);
        _context.SaveChangesDefaultOptions = SaveChangesOptions.Batch;
        _newInstance = true;
    }
  
    protected override void OnNavigatedTo(System.Windows.Navigation.NavigationEventArgs e)
    {
        base.OnNavigatedTo(e);
  
        if (_newInstance)
        {
            if (State.ContainsKey("productService"))
            {
                // need to restore the state.....
                string stateString = (string)State["productService"];
                DataServiceState state = DataServiceState.Deserialize(stateString);
                _context = (AdventureWorks2008Entities)state.Context;
                _products = (DataServiceCollection<Product>)state.RootCollections["products"];
                _lbxProducts.ItemsSource = _products;
            }
            else
            {
                //A new instance with no state saved, load new data....
                DataServiceQuery<Product> products = (DataServiceQuery<Product>)
                    from p in _context.Product
                    where p.ListPrice < 500
                    select p;
                Debug.WriteLine("Products uri: " + products.RequestUri);
                _products.LoadCompleted += new EventHandler<LoadCompletedEventArgs>(HandleProductsLoaded);
                _products.LoadAsync(products);
            }
        }
        _newInstance = false;
    }
  
    protected override void OnNavigatedFrom(System.Windows.Navigation.NavigationEventArgs e)
    {
        base.OnNavigatedFrom(e);
        if (e.NavigationMode != NavigationMode.Back)
        {
            Dictionary<string, object> collections = new Dictionary<string, object>(1);
            collections["products"] = _products;
            try
            {
                string state = DataServiceState.Serialize(_context, collections);
                State["productService"] = state;
            }
            catch (SerializationException ex)
            {
                Debug.WriteLine("Serialization exception: " + ex.Message);
            }
        }
    }

Don’t worry to much about the if statements and the restoring state parts. Let’s start at 5- 7. At line 5 I create a new DataServiceContext class, which was generated when I added the service reference. This class is the so called spider in the web when you use the WCF Data Service client library. It’s comparable to the ObjectContext class if you’re familiar with the Entity Framework. It contains a DataServiceQuery<Product> object, comparable to an EntitySet of the Entity Framework. You can use this to query the products. Next to query objects for all the EntitySets you expose at the server, the DataServiceContext also contains methods to add, remove and update objects.

Now you might think that you would use the add, remove and update methods on the DataServiceContext to perform modifications and this is possible, but it’s more common the use a DataServiceCollection<> to perform modifications. This DataServiceCollection is instantiated on line 6, and the DataServiceContext is passed in, in it’s constructor.

Let’s skip a few lines to lines 29-35. Line 29 is very interesting. You can see that I use a LINQ query on the Product property of the DataServiceContext. You can always cast this result back to a DataServiceQuery object, which is very useful for debugging. Line 29 is a huge win for Windows Phone 7.1. Constructing a LINQ query that was not executed, but parsed into an expression tree and translated to something else, wasn’t possible in Windows Phone 7. As you might know, this LINQ query is translated to an uri to which a GET request is sent by the DataServiceContext. Because all the information of my query is contained in the uri, this means that the query is handed to my WCF Data Service, which reconstructs it and sends it to the Entity Framework. This means that my data is filtered in the database, while I create a simple LINQ query on the client. This still amazes me .

You can see the Debug.WriteLine statement on line 33, this is it’s output:

Products uri: http://localhost:49753/ProductService.svc/Product()?$filter=ListPrice lt 500M

After constructing the LINQ query, the DataServiceCollection comes into play. The idea is that you supply a query to it’s LoadAsync() method. The collection executes the query and fires the LoadCompleted event when finished. All of this is happening on lines 34-35. The entities that are the result of the query are added to the collection. This collection implements INotifyCollectionChanged, so it can be used for data binding. Using this collection has a couple of advantages over using the DataServiceContext directly:

Change Tracking for updates: The DataServiceContext doesn’t do any change tracking and you have to use the UpdateObject() method to indicate that an object is modified. If you use the DataServiceCollection, the collection is responsible for tracking all the objects that it contains. Because the collection also has a reference to the DataServiceContext, it notifies the DataServiceContext of all changes to the collection and the entities in the collection. This means that you can just add,remove and update objects in the collection and when you want to persist the changes you call SaveChanges() on the DataServiceContext.
UI Thread marshalling. The DataServiceContext doesn’t do any UI Thread marshalling. The DataServiceCollection does, this means that the LoadCompleted event fires on the UI thread and I can just assign the collection to the ItemsSource property of my listbox.
Easier handling for paging: If you’ve worked with the OData Client library in the full .Net framework you know that when a query is paged on the server, it’s a bit of a pain to get all the pages. This becomes easy with the DataServiceCollection class in Windows Phone thanks to it’s LoadNextPartialSetAsync() method, which adds the next page of entities to the collection.

CUD

As you might have guessed, CUD functionality becomes very simple thanks to the DataServiceCollection, as I can just work with it like with any normal collection. This the handler for the add button:

private void HandleAddProduct(object sender, RoutedEventArgs e)
      {
          Product p = new Product()
          {
              Name = "Change this!" + new Random().Next(),
              ProductNumber = new Random().Next().ToString(),
              ModifiedDate = DateTime.Now,
              SellEndDate = DateTime.Now,
              SellStartDate = DateTime.Now,
              ReorderPoint = 1,
              SafetyStockLevel = 1,
              rowguid = Guid.NewGuid()
          };
  
          _products.Add(p);
          _lbxProducts.SelectedItem = p;
      }

I just set some default values because they are mandatory in the Adventureworks database. On line 15 I add the new product to the DataServiceCollection.

This is the handler for the Delete button:

private void HandleRemoveProduct(object sender, RoutedEventArgs e)
      {
          _products.Remove((Product)_lbxProducts.SelectedItem);
      }

This doesn’t need a lot of explanation. Finally the handler for the save button:

private void HandleSaveProduct(object sender, RoutedEventArgs e)
    {
        _context.BeginSaveChanges(HandleSaveChanges, null);
    }
  
    private void HandleSaveChanges(IAsyncResult result)
    {
        Dispatcher.BeginInvoke(() =>
        HandleSaveChangesForUiThread(result));
  
  
    }
  
    private void HandleSaveChangesForUiThread(IAsyncResult result)
    {
        try
        {
            _context.EndSaveChanges(result);
            MessageBox.Show("Save completed!");
  
        }
        catch (DataServiceRequestException ex)
        {
            DataServiceResponse response = ex.Response;
            ChangeOperationResponse singleResponse = (ChangeOperationResponse)response.SingleOrDefault((co) => co.Error != null);
            if (singleResponse != null)
            {
                MessageBox.Show("Error: " + singleResponse.Error.Message + ", for product: " + ((Product)((EntityDescriptor)singleResponse.Descriptor).Entity).Name + ", all changes were rolled back at the server");
            }
            else
            {
                MessageBox.Show("Unknown error: " + ex.Message);
            }
        }
    }

Line 1 is the actual handler for the save button. In this method I call the BeginSaveChanges() method of the DataServiceContext and pass a callback to it. This callback is defined on line 6. These methods follow the normal ASync pattern of the .Net framework. There is one catch… As you’ll probably know, I should call the EndSaveChanges() method in the callback. But the call to EndSaveChanges() and the code after it should run on the UI thread. This is important because if EndSaveChanges() isn’t called on the UI thread you’ll get an exception. This is because the DataServiceContext receives generated values from the server when EndSaveChanges is called (like a generated id) and set’s them on the Product entity that was saved. This will fire the INotifyPropertyChanged event of an entity which will in turn update the UI, which should of course happen on the UI thread. An entity which is generated by the OData client library doesn’t fire INotifyPopertyChanged on the UI Thread! That’s why I call the Dispatcher.BeginInvoke() method on line 8. The method that’s passed in is defined on lines 14-34. I call the EndSaveChanges() on line 18. The rest of the method is pretty much standard WCF DataServices error handling.

Tombstoning

Of course it would be a pity if the user of our nifty application added all those new cool products, changed the price of a couple of others, then the user takes an incoming phone call and our application can be tomstoned, which would delete all the changes the user has made. Luckily, the OData Client Library for Windows Phone has a special api to handle tombstoning. This api can save all our state, including loaded entities and pending changes. This means that the user can just continue with his work when the call has ended. Let’s take a look at the overridden OnNavigatedFrom method, which is also called when the application is tombstoned:

protected override void OnNavigatedFrom(System.Windows.Navigation.NavigationEventArgs e)
       {
           base.OnNavigatedFrom(e);
           if (e.NavigationMode != NavigationMode.Back)
           {
               Dictionary<string, object> collections = new Dictionary<string, object>(1);
               collections["products"] = _products;
               try
               {
                   string state = DataServiceState.Serialize(_context, collections);
                   State["productService"] = state;
               }
               catch (SerializationException ex)
               {
                   Debug.WriteLine("Serialization exception: " + ex.Message);
               }
           }
       }

At line 5 I check with the new Windows Phone 7.1 api whether it’s a backwards navigation. If it is, I don’t have to save any state, since this means that either the page is closed and removed from the backstack or the entire application is closed. Either way, the user will expect new fresh data when this page is visited again. If it isn’t, I must prepare for tombstoning. This is what’s happening:

Line 6: I Instantiate a dictionary, which holds all the DataServiceCollection objects I want to preserve. I add my DataServiceCollection to this on line 7.
Line8: I use the static Serialize method of the DataServiceState class to turn all the tracking information in the context and all the loaded entities in my collection into a string.
Line 10: I add this string with all the needed information to the State dictionary of the current page. This means that this string is preserved when the application is tombstoned.
Line 13: I needed this catch because of a bug in this beta. It turns out that if BeginSaveChanges() caused an exception (example: Network is not available), that even when this exception is correctly handled, the DataServiceContext can’t be serialized anymore. I do hope that this bug get’s fixed in the final release.

Next up is the OnNavigatedTo method, which is also called when my application is restored after tombstoning. Here it is:

protected override void OnNavigatedTo(System.Windows.Navigation.NavigationEventArgs e)
      {
          base.OnNavigatedTo(e);
  
          if (_newInstance)
          {
              if (State.ContainsKey("productService"))
              {
                  // need to restore the state.....
                  string stateString = (string)State["productService"];
                  DataServiceState state = DataServiceState.Deserialize(stateString);
                  _context = (AdventureWorks2008Entities)state.Context;
                  _products = (DataServiceCollection<Product>)state.RootCollections["products"];
                  _lbxProducts.ItemsSource = _products;
              }
              else
              {
                  //A new instance with no state saved, load new data....
                  DataServiceQuery<Product> products = (DataServiceQuery<Product>)
                      from p in _context.Product
                      where p.ListPrice < 500
                      select p;
                  Debug.WriteLine("Products uri: " + products.RequestUri);
                  _products.LoadCompleted += new EventHandler<LoadCompletedEventArgs>(HandleProductsLoaded);
                  _products.LoadAsync(products);
              }
          }
          _newInstance = false;
      }

On line 5 I check whether the constructor is called. This is necesary because an application doesn’t always become tombstoned after it has been deactivated. It can remain in memory the same as it was left behind if the resources of the device allow it. This is called “Fast App Switching”. If this happens, the OnNavigatedTo fires if the user returns to the application, but the constructor doesn’t fire. So if fast app switching took place, you don’t have to restore your state. By the way, fast app switching is the default in the windows phone emulator when you press it’s Windows button. You can change this on the project properties if you want to test tombstoning:

On line 7 I check if the state was previously saved. This is necesary because OnNavigatedTo of course also fires when the application starts normally. If the state exists I retrieve the string on line 10 from the State dictionary. On line 11 I turn this string into a DataServiceState object by using the static DataServiceState.DeSerialize() method. This DataServiceState object has two properties:

Context, which contains the DataServiceContext with all the tracking information I serialized earlier.
RootCollections, this is the dictionary which holds all the DataServiceCollection objects I serialized earlier. I retrieve my “products” DataServiceCollection on line 13.

On line 14 I assign the restored DataServiceCollection to the ItemsSource property of my listbox and with this all state has been restored.

Conclusion

In my opinion the OData Client Library for Windows Phone and WCF Data Services will be the primary way of interacting with your data from your Windows Phone application. This will be the case because the library is the only client technology which supports change tracking in a Windows Phone application and strongly typed LINQ queries which are actually executed on the server. This will be the case at least until WCF RIA Services is supported.

While the api is a little rough around the edges:

INotifyPropertyChanged isn’t fired on the UI Thread (which isn’t necessarily a bad thing).
SerializationException occurs when saving state after an exception has been handled.

I’m sure these issues will be solved before the final release. The library is very stable and I encourage you to dig in, because it’s definitely the easiest and fastest way to create CRUD functionality for your Windows Phone 7.1 applications. You can find the example project here.

Multi tasking in Windows Phone 7.1

Posted on 26 May 2011 by Alex van Beek

One of the coolest features in Windows Phone 7.1 is the new multi tasking feature (next to the new LINQ to SQL support of course). In this article I’ll show you how this works.

Background

It is important to understand how multi tasking in Windows Phone 7.1 is implemented. I first thought that I could have some kind of background service running, comparable to a background service in Windows. Well, this isn’t the case. Multi tasking in Windows Phone 7.1 is so called “Scheduled Multi Tasking”. This means that I can define a piece of code (we’ll get to this later) and the operating system is then responsible for scheduling this piece of code. How often and when this piece of code is run is dependant on multiple factors:

The kind of code to run.
The state of the device.
Available resources.
And so on.

Depending on the factors outlined above, Windows Phone 7.1 will run your piece of code or not. This means for certain pieces of code, that they may never be run. Windows Phone 7.1 supports two kinds of code that you can schedule to run in the background, these two kinds of code are represented by the following classes:

PeriodicTask
ResourceIntensiveTask

Depending on the type of task you choose, the schedule and the constraints that the tasks must adhere to, differ. These are the constraints for a PeriodicTask:

MemoryCap: 5MB.
Scheduled Interval: 30 minutes, but the execution time can drift by 10 minutes.
Scheduled Duration: 15 seconds.
Battery Save Mode can prevent execution.
There is a limit per device how many PeriodicTasks can be scheduled. This can be as low as six.

These are the constraints for a so called ResourceIntensiveTask:

MemoryCap: 5MB.
Scheduled Interval: Uncertain: A ResourceIntensiveTask will run when the phone meets the following conditions:
- It’s connected to an external power source.
- The battery is charged over 90%.
- It has a WIFI connection or it’s connected through a PC.
- The device screen is locked.
- There is no active phone call.
Scheduled Duration: 10 minutes (If a RecourseInsensiveTask is run and the conditions of the devices change in a way that the ResourceIntensiveTask shouldn’t have been run, it’s terminated immediately).

You can see by looking at the constraints above that there is no guarantee that a ResourceIntensiveTask will be run at all. The idea is that you use the PeriodicTask to do small updates, refresh an RSS feed for example. A typical scenario for a ResourceIntensiveTask would be an occasionally connected application, which stores data locally (perhaps in the new local database feature). If all the above conditions are met, the data could be synchronized with the server.

Next to the constraints above, there are a couple of common constraints:

Each scheduled task will stop being scheduled after two weeks from the time it was first scheduled by using the Add() (later) method. Every time your main application is run, it can change this date to two weeks from the current time.
Scheduled tasks can’t use the API’s listed on the following page: http://msdn.microsoft.com/en-us/library/hh202962(v=VS.92).aspx.
Each application can schedule at most one PeriodicTask AND one ResourceIntensiveTask.
Tasks can only be scheduled the first time after a user initiated action from your main application. So you can’t make an application which schedules a background task as soon as it is installed.

Scheduling a task

Let’s take a look at the code needed to schedule a background task. The sample application contains one button. When this button is clicked it will schedule or prolong the already scheduled task. Here is the code behind:

using System;
using System.IO.IsolatedStorage;
using System.Windows;
using Microsoft.Phone.Controls;
using Microsoft.Phone.Scheduler;
  
namespace MainApplication
{
    public partial class MainPage : PhoneApplicationPage
    {
        public MainPage()
        {
            InitializeComponent();
        }
  
        protected override void OnNavigatedTo(System.Windows.Navigation.NavigationEventArgs e)
        {
            base.OnNavigatedTo(e);
            string minutes;
            if (NavigationContext.QueryString.TryGetValue("minutes", out minutes))
            {
                MessageBox.Show("The application was started by clicking a toast: " + minutes);
            }
        }
  
        private void HandleButtonClick(object sender, RoutedEventArgs e)
        {
            PeriodicTask myFirstTask;
            myFirstTask = (PeriodicTask)ScheduledActionService.Find("MyFirstTask");
            if (myFirstTask == null)
            {
                //The first time this application is run....
                myFirstTask = new PeriodicTask("MyFirstTask");
                myFirstTask.Description = "Updates the tile with the current minutes and shows a toast";
            }
            else
            {
                if (!myFirstTask.IsScheduled)
                {
                    string lastResult;
                    if (IsolatedStorageSettings.ApplicationSettings.TryGetValue<string>("taskResult", out lastResult))
                    {
                        if (lastResult == "Succes")
                        {
                            //User must have disabled it.
                            MessageBox.Show("Please enable the background task in the settings menu and run this app again");
                            ScheduledActionService.Remove(myFirstTask.Name);
                            return;
                        }
                        else if (lastResult == "Faillure")
                        {
                            //Inspect isolated storage for more information and take appropriate action
                        }
                    }
                }
                ScheduledActionService.Remove(myFirstTask.Name);
            }
  
            //Prolong the task or schedule a new one:
            myFirstTask.ExpirationTime = DateTime.Now.AddDays(14);
            try
            {
                ScheduledActionService.Add(myFirstTask);
            }
            catch (InvalidOperationException)
            {
                MessageBox.Show("Maximum amount of background tasks for your device might have been reached." +
                    " Disable some tasks or enable this task on the settings menu and run this app again.");
            }
            catch (SchedulerServiceException)
            {
                MessageBox.Show("Something really bad happened. an unexpected error has occurred.");
            }
  
        }
    }
  
}

The most interesting part begins on line 29. When the button is clicked I first check whether the task already is scheduled. This is necessary because an application can only schedule one PeriodicTask. On line 33, if the task doesn’t exist, I create it. Setting the description on line 34 is mandatory for a PeriodicTask. This is the description the user sees when he views all the scheduled background tasks through the settings menu. If it does exist, I check whether the task is still being scheduled on line 38. A scheduled task can become unscheduled because of two reasons:

The task called the Abort() method, to indicate something went wrong.
The user disabled the background task through the settings menu. If this is the case, the user can only allow the application to restart it’s tasks when the application is launched. The user can’t enable a disabled background task from the settings menu.

As we’ll see later, the only way you can find out what has happened is through IsolatedStorage. My task writes a result to IsolatedStorage (“Success” or “Faillure”). If the last result is “Success”” and the task isn’t scheduled, it must mean that the user has disabled it. If this is the case, I notify the user and remove the task on line 47 so that it can be restarted. I would really have liked a property on the PeriodicTask class, which I can use to determine the reason a task isn’t scheduled anymore. Next to that, a way to find out if the task has been enabled again by the user, is also very welcome.

If the last result is “Faillure” or the task is still scheduled, I remove the task on line 56 (more about why I remove the task while it’s still scheduled in a moment). You can of course log error details to IsolatedStorage from your task and inspect them here. After the inspection has been done, I let the method continue. The code from line 60 will be executed whether a new task has been created or an existing task has been found (which has or hasn’t been aborted). On line 60 I set the ExpirationTime to two weeks from now, this is the maximum. This also means that an existing task is prolonged. You can’t just change the ExpirationTime for an already scheduled task, this is why I removed it on 56. Finally, on line 63 I submit my task to the ScheduledActionService through the add method. This will make sure that the task is scheduled. You have to catch the InvalidOperationException on line 65. This will occur when the maximum amount of background tasks has been reached for a device or when the user disabled the background task for this application. The SchedulerServiceException on line 70 must also be caught, as this means a serious internal error.

Note that to create a ResourceIntensiveTask, I only have to replace “PeriodicTask” in the code above with “ResourceIntensiveTask”. The configuration of the task is completely the same.

The SchedulerAgent

By now you, the well respected reader must have noticed something obvious…… I still haven’t shown you the code that actually get’s executed when the task is run by the operating system. This is because that code is is contained in a whole different Visual Studio project. You add this project by using the new “Windows Phone Task Scheduler Agent” project template:

You should add this project to the same solution as the main project and immediately add a reference from the main project to this project. After you created this project, it already contains one class. This class will contain the code that will be run by the operating system:

using System;
using System.IO.IsolatedStorage;
using System.Linq;
using Microsoft.Phone.Scheduler;
using Microsoft.Phone.Shell;
  
namespace MyFirstAgent
{
    public class TaskScheduler : ScheduledTaskAgent
    {
  
        /// <summary>
        /// Agent that runs a scheduled task
        /// </summary>
        /// <param name="task">
        /// The invoked task
        /// </param>
        /// <remarks>
        /// This method is called when a periodic or resource intensive task is invoked
        /// </remarks>
        protected override void OnInvoke(ScheduledTask task)
        {
  
            try
            {
                ShellTile mainTile = ShellTile.ActiveTiles.First();
                //Tile has been pinned. First tile is always the main tile
                StandardTileData data = new StandardTileData();
                data.Count = DateTime.Now.Minute;
                data.Title = "Periodic";
                data.BackTitle = "Periodic back";
                mainTile.Update(data);
  
                ShellToast toast = new ShellToast();
                toast.Title = "Info";
                toast.Content = "Tile was modified! Tap here to open the app.";
                toast.NavigationUri = new Uri("/MainPage.xaml?minutes=" + data.Count, UriKind.Relative);
                toast.Show();
  
                IsolatedStorageSettings.ApplicationSettings["taskResult"] = "Succes";
                NotifyComplete();
            }
            catch (Exception)
            {
                //Unschedule this task....
                Abort();
                IsolatedStorageSettings.ApplicationSettings["taskResult"] = "Faillure";
            }
            finally
            {
                IsolatedStorageSettings.ApplicationSettings.Save();
            }
        }
  
        /// <summary>
        /// Called when the agent request is getting cancelled
        /// </summary>
        protected override void OnCancel()
        {
            base.OnCancel();
  
  
        }
    }
}

The most interesting method is the one on line 21. It’s the OnInvoke method. This method is called by the OS every time your task is run. The only argument is a ScheduledTask. This argument contains the PeriodicTask object I scheduled in the main application. You really only need this argument if your application schedules both a PeriodicTask and a ResourceIntensiveTask, since then you’ll need an “if(task is PeriodicTask)” statement to determine what code should be executed. In this method I use a couple of new API’s in Windows Phone 7.1:

Line 26: I retrieve the main application tile. The first one is always the main tile, even if the application is not pinned, you can still update it and the user will see the update as soon as he pins the application.
Line 28: I update the BackTitle. This also new in Windows Phone 7.1. Tiles have a back, and as soon as you update it, Windows Phone will flip the tile in the home screen periodically to show the back.
On line 32: I update the tile with new information.
Line 34: I create a toast object. This is a notification that is shown to the user.
Line 37: A toast can have an Uri. When the user taps the toast, your application is started and your application navigates to this Uri, including the query string parameters. This way you can open your application in the correct state. You can see on line 16 of the main application that I do actually use this information in the OnNavigatedTo method. This is hard in the emulator to test, since the background task is run as soon as it’s added to the ScheduledActionService. When it’s run, my main application is still active and toast’s won’t be shown. So you’ll have to close the application and wait for 30 minutes. After 30 minutes the PeriodicTask will be run again.
Line 43: I’ve wrapped all code in a try..catch block. If an Exception occurs I call the Abort method. This let’s Windows Phone know that the task should not be run again until I reschedule it from my main application. If everything went well, I call the NotifyComplete method on line 41. This let’s Windows Phone know that the task can be safely run again.

Conclusion

Wow! Multi tasking in Windows Phone is a real cool feature to have. The ones explained above aren’t the only ways to do some kind of multi tasking. In Windows Phone 7.1 there are also:

Scheduled Tile Updates.
Background Transfers.
Alarms.
Reminders.

And they all are really not that difficult to understand and program. Working in the emulator to test a PeriodicTask is a bit of a pain. As soon as I use the Add method to schedule a task, Visual Studio loses the debug connection, because the debugger attaches itself to the background task. Next to that, the scheduled task is invoked immediately while my application is still active, so you won’t see any toasts. To see toasts, you’ll have to wait thirty minutes for the PeriodicTask to be run again. It would be nice for the future that we can configure the interval in which PeriodicTasks are run in the emulator. This would simplify testing. Just for completeness, here is a screenshot which shows the background task in the settings menu, under “Applications” in Windows Phone 7.1:

You can see the description coming from my code in the last sentence in the screenshot above. The coming weeks I will be experimenting a lot more with Windows Phone 7.1, so if you find this interesting, keep an eye on this blog! You can find a working example here.

Sharing validation code between a WPF client, a WCF Service and Entity Framework 4.1 using data annotations

Posted on 24 May 2011 by Alex van Beek

Recently Entity Framework 4.1 was released. While most people were very enthusiastic about the code first stuff, code first was the part that impressed me the least. This is because in my line of business we deal with stored procedures a lot and it turns out that mapping to stored procedures isn’t supported with code first in the 4.1 release. What did catch my eye is the new DBContext api. As you’ll probably know, the new DBContext class is largely a wrapper around the ObjectContext class with a simplified API. Now you might think as I did: “But if I’m comfortable with the ObjectContext class and I don’t use code first, why in the world would I need a DbContext?”. The answer is pretty simple. The DbContext has a feature which simply isn’t supported by the ObjectContext: data validation with the attributes from the System.ComponentModel.DataAnnotations namespace. In this article I’ll show you how to decorate your classes with validation attributes and how these classes can be reused by both the client and the server. The client will be a WPF application. If you don’t like WPF or you just don’t care, feel free the skip to the “WCF Service” paragraph. That’s where the Entity Framework 4.1 part is explained.

The Solution

Let’s first start with the two projects that are responsible for my data access classes, including the entities:

Both DbContextLibrary and EntitiesLibrary are normal class library projects. I started with the DBContextLibrary and used the new “DbContext Generator” T4 template to generate classes. When you use this template you’ll actually get two T4 templates added to your project. The one with “.Context” in it generates your DbContext class, the other one generates POCO entities. I’ve simply moved the one that generates the entities to it’s own class library. If you do this, you’ll have to add a namespace in the T4 template that generates the DbContext, so that DbContext knows the entity classes. In this article I will only have one entity, namely Product. I’ve added some validation to this class using the buddy class mechanism. This code is contained in the Product.Metadata.cs file in the EntitiesLibrary project:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.ComponentModel.DataAnnotations;
  
  
namespace EntitiesLibrary
{
    [MetadataType(typeof(ProductMetadata))]
    public partial class Product 
    {
        private class ProductMetadata
        {
            [Range(0,Double.MaxValue,ErrorMessage="ListPrice can't be smaller than zero!")]
            public decimal ListPrice { get; set; }
        }
    }
}

You can see that I’ve only added validation for the ListPrice property using the Range attribute. Now let’s take a look at the Adventureworks2008.tt T4 template, since it contains some stuff I had to manually edit:

<#@ template language="C#" debug="false" hostspecific="true"#>
<#@ include file="EF.Utility.CS.ttinclude"#><#@
 output extension=".cs"#><#
  
CodeGenerationTools code = new CodeGenerationTools(this);
MetadataLoader loader = new MetadataLoader(this);
CodeRegion region = new CodeRegion(this, 1);
MetadataTools ef = new MetadataTools(this);
  
string inputFile = @"..\DbContextLibrary\Adventureworks2008.edmx";
EdmItemCollection ItemCollection = loader.CreateEdmItemCollection(inputFile);
string namespaceName = code.VsNamespaceSuggestion();
  
EntityFrameworkTemplateFileManager fileManager = EntityFrameworkTemplateFileManager.Create(this);
WriteHeader(fileManager);
  
foreach (var entity in ItemCollection.GetItems<EntityType>().OrderBy(e => e.Name))
{
    fileManager.StartNewFile(entity.Name + ".cs");
    BeginNamespace(namespaceName, code);
#>
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.ComponentModel.DataAnnotations;
using System.Linq;
using System.Reflection;
  
<#=Accessibility.ForType(entity)#> <#=code.SpaceAfter(code.AbstractOption(entity))#>partial class <#=code.Escape(entity)#> : IDataErrorInfo
{
    static <#=code.Escape(entity)#>()
    {
        //We need to hook this up in order to make the buddy class mechanism work in WPF, Console Applications etc.....
        //Or the Validator methods won't make use of the metadata class.
  
        Type currentType = MethodBase.GetCurrentMethod().DeclaringType;
        object[] attributes = currentType.GetCustomAttributes(typeof(MetadataTypeAttribute),false);
        if(attributes.Length > 0)
        {
            //MetadataType attribute found!
            MetadataTypeAttribute metaDataAttribute = (MetadataTypeAttribute)attributes[0];
            TypeDescriptor.AddProviderTransparent(
                new AssociatedMetadataTypeTypeDescriptionProvider(
                    currentType, metaDataAttribute.MetadataClassType),currentType);
        }
           
    }
  
    public string Error
    {
        get 
        {
            ValidationContext vc = new ValidationContext(this, null, null);
            List<ValidationResult> result = new List<ValidationResult>();
            if (!Validator.TryValidateObject(this, vc, result))
            {
                return result.First().ErrorMessage;
            }
            else
            {
                return null;
            }
        }
    }
  
    public string this[string columnName]
    {
        get 
        {
            ValidationContext vc = new ValidationContext(this, null, null);
            List<ValidationResult> result = new List<ValidationResult>();
            vc.MemberName = columnName;
            if (!Validator.TryValidateProperty(GetType().GetProperty(columnName).GetValue(this, null), vc, result))
            {
                return result.First().ErrorMessage;
            }
            else
            {
                return null;
            }
        }
    }
  
<#
    var propertiesWithDefaultValues = entity.Properties.Where(p => p.TypeUsage.EdmType is PrimitiveType && p.DeclaringType == entity && p.DefaultValue != null);
    var collectionNavigationProperties = entity.NavigationProperties.Where(np => np.DeclaringType == entity && np.ToEndMember.RelationshipMultiplicity == RelationshipMultiplicity.Many);
    var complexProperties = entity.Properties.Where(p => p.TypeUsage.EdmType is ComplexType && p.DeclaringType == entity);
  
    if (propertiesWithDefaultValues.Any() || collectionNavigationProperties.Any() || complexProperties.Any())
    {
#>
    public <#=code.Escape(entity)#>()
    {
<#
        foreach (var edmProperty in propertiesWithDefaultValues)
        {
#>
        this.<#=code.Escape(edmProperty)#> = <#=code.CreateLiteral(edmProperty.DefaultValue)#>;
<#
        }
  
        foreach (var navigationProperty in collectionNavigationProperties)
        {
#>
        this.<#=code.Escape(navigationProperty)#> = new HashSet<<#=code.Escape(navigationProperty.ToEndMember.GetEntityType())#>>();
<#
        }
  
        foreach (var complexProperty in complexProperties)
        {
#>
        this.<#=code.Escape(complexProperty)#> = new <#=code.Escape(complexProperty.TypeUsage)#>();
<#
        }
#>
    }
  
<#
    }
  
    var primitiveProperties = entity.Properties.Where(p => p.TypeUsage.EdmType is PrimitiveType && p.DeclaringType == entity);
    if (primitiveProperties.Any())
    {
        foreach (var edmProperty in primitiveProperties)
        {
            WriteProperty(code, edmProperty);
        }
    }
  
    if (complexProperties.Any())
    {
#>
  
<#
        foreach(var complexProperty in complexProperties)
        {
            WriteProperty(code, complexProperty);
        }
    }
  
    var navigationProperties = entity.NavigationProperties.Where(np => np.DeclaringType == entity);
    if (navigationProperties.Any())
    {
#>
  
<#
        foreach (var navigationProperty in navigationProperties)
        {
            WriteNavigationProperty(code, navigationProperty);
        }
    }
#>
}
<#
    EndNamespace(namespaceName);
}
  
foreach (var complex in ItemCollection.GetItems<ComplexType>().OrderBy(e => e.Name))
{
    fileManager.StartNewFile(complex.Name + ".cs");
    BeginNamespace(namespaceName, code);
#>
using System;
  
<#=Accessibility.ForType(complex)#> partial class <#=code.Escape(complex)#>
{
<#
    var complexProperties = complex.Properties.Where(p => p.TypeUsage.EdmType is ComplexType && p.DeclaringType == complex);
    var propertiesWithDefaultValues = complex.Properties.Where(p => p.TypeUsage.EdmType is PrimitiveType && p.DeclaringType == complex && p.DefaultValue != null);
  
    if (propertiesWithDefaultValues.Any() || complexProperties.Any())
    {
#>
    public <#=code.Escape(complex)#>()
    {
<#
        foreach (var edmProperty in propertiesWithDefaultValues)
        {
#>
        this.<#=code.Escape(edmProperty)#> = <#=code.CreateLiteral(edmProperty.DefaultValue)#>;
<#
        }
  
        foreach (var complexProperty in complexProperties)
        {
#>
        this.<#=code.Escape(complexProperty)#> = new <#=code.Escape(complexProperty.TypeUsage)#>();
<#
        }
#>
    }
  
<#
    }
  
    var primitiveProperties = complex.Properties.Where(p => p.TypeUsage.EdmType is PrimitiveType && p.DeclaringType == complex);
    if (primitiveProperties.Any())
    {
        foreach(var edmProperty in primitiveProperties)
        {
            WriteProperty(code, edmProperty);
        }
    }
  
    if (complexProperties.Any())
    {
#>
  
<#
        foreach(var edmProperty in complexProperties)
        {
            WriteProperty(code, edmProperty);
        }
    }
#>
}
<#
    EndNamespace(namespaceName);
}
  
if (!VerifyTypesAreCaseInsensitiveUnique(ItemCollection))
{
    return "";
}
  
fileManager.Process();
  
#>
<#+
string GetResourceString(string resourceName)
{
    if(_resourceManager == null)
    {
        _resourceManager = new System.Resources.ResourceManager("System.Data.Entity.Design", typeof(System.Data.Entity.Design.MetadataItemCollectionFactory).Assembly);
    }
    
    return _resourceManager.GetString(resourceName, null);
}
System.Resources.ResourceManager _resourceManager;
  
void WriteHeader(EntityFrameworkTemplateFileManager fileManager)
{
    fileManager.StartHeader();
#>
//------------------------------------------------------------------------------
// <auto-generated>
// <#=GetResourceString("Template_GeneratedCodeCommentLine1")#>
//
// <#=GetResourceString("Template_GeneratedCodeCommentLine2")#>
// <#=GetResourceString("Template_GeneratedCodeCommentLine3")#>
// </auto-generated>
//------------------------------------------------------------------------------
  
<#+
    fileManager.EndBlock();
}
  
void BeginNamespace(string namespaceName, CodeGenerationTools code)
{
    CodeRegion region = new CodeRegion(this);
    if (!String.IsNullOrEmpty(namespaceName))
    {
#>
namespace <#=code.EscapeNamespace(namespaceName)#>
{
<#+
        PushIndent(CodeRegion.GetIndent(1));
    }
}
  
  
void EndNamespace(string namespaceName)
{
    if (!String.IsNullOrEmpty(namespaceName))
    {
        PopIndent();
#>
}
<#+
    }
}
  
void WriteProperty(CodeGenerationTools code, EdmProperty edmProperty)
{
    WriteProperty(Accessibility.ForProperty(edmProperty),
                  code.Escape(edmProperty.TypeUsage),
                  code.Escape(edmProperty),
                  code.SpaceAfter(Accessibility.ForGetter(edmProperty)),
                  code.SpaceAfter(Accessibility.ForSetter(edmProperty)));
}
  
void WriteNavigationProperty(CodeGenerationTools code, NavigationProperty navigationProperty)
{
    var endType = code.Escape(navigationProperty.ToEndMember.GetEntityType());
    WriteProperty(PropertyVirtualModifier(Accessibility.ForProperty(navigationProperty)),
                  navigationProperty.ToEndMember.RelationshipMultiplicity == RelationshipMultiplicity.Many ? ("ICollection<" + endType + ">") : endType,
                  code.Escape(navigationProperty),
                  code.SpaceAfter(Accessibility.ForGetter(navigationProperty)),
                  code.SpaceAfter(Accessibility.ForSetter(navigationProperty)));
}
  
void WriteProperty(string accessibility, string type, string name, string getterAccessibility, string setterAccessibility)
{
#>
    <#=accessibility#> <#=type#> <#=name#> { <#=getterAccessibility#>get; <#=setterAccessibility#>set; }
<#+
}
  
string PropertyVirtualModifier(string accessibility)
{
    return accessibility + (accessibility != "private" ? " virtual" : "");
}
  
bool VerifyTypesAreCaseInsensitiveUnique(EdmItemCollection itemCollection)
{
    var alreadySeen = new Dictionary<string, bool>(StringComparer.OrdinalIgnoreCase);
    foreach(var type in itemCollection.GetItems<StructuralType>())
    {
        if (!(type is EntityType || type is ComplexType))
        {
            continue;
        }
  
        if (alreadySeen.ContainsKey(type.FullName))
        {
            Error(String.Format(CultureInfo.CurrentCulture, "This template does not support types that differ only by case, the types {0} are not supported", type.FullName));
            return false;
        }
        else
        {
            alreadySeen.Add(type.FullName, true);
        }
    }
  
    return true;
}
#>

In order for entities to support automatic validation in WPF I had to change the following things in this template:

Line 10: The path to the .edmx file. The .edmx is contained in another project and the T4 template by default assumes it’s in the same project as the T4 template, so you’ll need to adjust this.
Lines 24-27: I’ve added these namespaces because they are necessary for the the rest of my code.
Line 29: I’ve changed this line to let my entity implement the IDataErrorInfo interface. You have to understand that in WPF, unlike in Silverlight, the data annotations aren’t automatically read by the components (DataGrid). You’ll have to implement the IDataErrorInfo interface and validate manually using the data annotations.
Line 49-82: These are the members you’ll have to implement because of the IDataErrorInfo interface: Error and an indexer. Normally, in the Error property you’ll write code to validate the whole object and construct a string with an error message. In the indexer you’ll write code that validates a single property. The property name is supplied as an argument and you’ll need to construct a string with an error message. In both members I’ve used the Validator class to validate. Whenever you are in a situation that you’ll need to validate using data annotations and this doesn’t happen automatically, you can use the static Validator class to do the validation for you. This isn’t difficult, it’s just something to keep in mind. To make the validation generic for property validation, you’ll have to supply the member name like on line 72. Next to that, you’ll have to use some reflection to get the property value in a generic way. This reflection code is found on line 73, it’s the first argument of the TryValidatePropertyMethod.
Line 31-47: I’ve intentionally covered lines 49-82 first. Because now it’s clear that I implement the IDataErrorInfo interface in my entity and I use the Validator class to do the validation for me. If you now create a list of Products, add those to a WPF datagrid and use TwoWay binding with validation enabled for the ListPrice, you would think that validation should kick in. This was at least what I thought. Turns out that the whole buddy metadata mechanism isn’t something that’s supported by the static Validator class. It are the frameworks like WCF RIA Services that add support for the buddy mechanism. Luckily with some googling and reflectoring I came to the conclusion that the Validator class uses .Net’s extensible TypeDescriptor mechanism instead of reflection, which can be seen as a mechanism similar to reflection, only the type information can be extended runtime. I had to extend the type information once for each entity that get’s generated, with the information in the buddy metadata class. I can’t do this in the constructor, because then it would happen way to often. A static constructor seemed a good place to me. The declaration of the static constructor is found on line 31. On line 36 I use the MethodBase class to get a reference to the current type. This is needed since I need to extend the type information of the current type. On line 37-39 I check whether the MetadataTypeAttribute is present. If so, I retrieve it on line 41. This attribute has the property “MetadataClassType”. This property contains the type you supply when you place the MetadataType attribute. On line 42 I extend the type information of the current type with the associated metadata. I do this by calling the AddProviderTransparent method on the TypeDescriptor class and supplying an AssociatedMetadataTypeTypeDescriptionProvider. This provider is used for the buddy class mechanism and it’s constructor takes two arguments. First is the type you wish to extend with extra metadata, second is the metadata class.

So know we have a T4 template, that generates entities with support for WPF validation using data annotations and the buddy mechanism. Of course you can use the generated entities for any technology that doesn’t use the data annotations by default.

The WPF Application

The article is getting quite long, so bare with me . Luckily, this paragraph will be short. Here is the XAML:

<Window x:Class="ProductsApp.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="MainWindow" Height="350" Width="525" mc:Ignorable="d" xmlns:d="http://schemas.microsoft.com/expression/blend/2008" xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" xmlns:my="clr-namespace:EntitiesLibrary;assembly=EntitiesLibrary" >
      <Grid >
        <DataGrid AutoGenerateColumns="False" EnableRowVirtualization="True" Name="_dtgProducts" RowDetailsVisibilityMode="VisibleWhenSelected">
            <DataGrid.Columns>
                <DataGridTextColumn x:Name="classColumn" Binding="{Binding Path=Class}" Header="Class" Width="SizeToHeader" />
                <DataGridTextColumn x:Name="colorColumn" Binding="{Binding Path=Color}" Header="Color" Width="SizeToHeader" />
                <DataGridTextColumn x:Name="daysToManufactureColumn" Binding="{Binding Path=DaysToManufacture}" Header="Days To Manufacture" Width="SizeToHeader" />
                <DataGridTemplateColumn x:Name="discontinuedDateColumn" Header="Discontinued Date" Width="SizeToHeader">
                    <DataGridTemplateColumn.CellTemplate>
                        <DataTemplate>
                            <DatePicker SelectedDate="{Binding Path=DiscontinuedDate, Mode=TwoWay, ValidatesOnExceptions=true, NotifyOnValidationError=true}" />
                        </DataTemplate>
                    </DataGridTemplateColumn.CellTemplate>
                </DataGridTemplateColumn>
                <DataGridTextColumn x:Name="errorColumn" Binding="{Binding Path=Error}" Header="Error" IsReadOnly="True" Width="SizeToHeader" />
                <DataGridCheckBoxColumn x:Name="finishedGoodsFlagColumn" Binding="{Binding Path=FinishedGoodsFlag}" Header="Finished Goods Flag" Width="SizeToHeader" />
                <DataGridTextColumn x:Name="listPriceColumn" Binding="{Binding Path=ListPrice,Mode=TwoWay,ValidatesOnDataErrors=True,NotifyOnValidationError=True}" Header="List Price" Width="SizeToHeader" />
                <DataGridCheckBoxColumn x:Name="makeFlagColumn" Binding="{Binding Path=MakeFlag}" Header="Make Flag" Width="SizeToHeader" />
                <DataGridTemplateColumn x:Name="modifiedDateColumn" Header="Modified Date" Width="SizeToHeader">
                    <DataGridTemplateColumn.CellTemplate>
                        <DataTemplate>
                            <DatePicker SelectedDate="{Binding Path=ModifiedDate, Mode=TwoWay, ValidatesOnExceptions=true, NotifyOnValidationError=true}" />
                        </DataTemplate>
                    </DataGridTemplateColumn.CellTemplate>
                </DataGridTemplateColumn>
                <DataGridTextColumn x:Name="nameColumn" Binding="{Binding Path=Name}" Header="Name" Width="SizeToHeader" />
                <DataGridTextColumn x:Name="productIDColumn" Binding="{Binding Path=ProductID}" Header="Product ID" Width="SizeToHeader" />
                <DataGridTextColumn x:Name="productLineColumn" Binding="{Binding Path=ProductLine}" Header="Product Line" Width="SizeToHeader" />
                <DataGridTextColumn x:Name="productModelIDColumn" Binding="{Binding Path=ProductModelID}" Header="Product Model ID" Width="SizeToHeader" />
                <DataGridTextColumn x:Name="productNumberColumn" Binding="{Binding Path=ProductNumber}" Header="Product Number" Width="SizeToHeader" />
                <DataGridTextColumn x:Name="productSubcategoryIDColumn" Binding="{Binding Path=ProductSubcategoryID}" Header="Product Subcategory ID" Width="SizeToHeader" />
                <DataGridTextColumn x:Name="reorderPointColumn" Binding="{Binding Path=ReorderPoint}" Header="Reorder Point" Width="SizeToHeader" />
                <DataGridTextColumn x:Name="rowguidColumn" Binding="{Binding Path=rowguid}" Header="rowguid" Width="SizeToHeader" />
                <DataGridTextColumn x:Name="safetyStockLevelColumn" Binding="{Binding Path=SafetyStockLevel}" Header="Safety Stock Level" Width="SizeToHeader" />
                <DataGridTemplateColumn x:Name="sellEndDateColumn" Header="Sell End Date" Width="SizeToHeader">
                    <DataGridTemplateColumn.CellTemplate>
                        <DataTemplate>
                            <DatePicker SelectedDate="{Binding Path=SellEndDate, Mode=TwoWay, ValidatesOnExceptions=true, NotifyOnValidationError=true}" />
                        </DataTemplate>
                    </DataGridTemplateColumn.CellTemplate>
                </DataGridTemplateColumn>
                <DataGridTemplateColumn x:Name="sellStartDateColumn" Header="Sell Start Date" Width="SizeToHeader">
                    <DataGridTemplateColumn.CellTemplate>
                        <DataTemplate>
                            <DatePicker SelectedDate="{Binding Path=SellStartDate, Mode=TwoWay, ValidatesOnExceptions=true, NotifyOnValidationError=true}" />
                        </DataTemplate>
                    </DataGridTemplateColumn.CellTemplate>
                </DataGridTemplateColumn>
                <DataGridTextColumn x:Name="sizeColumn" Binding="{Binding Path=Size}" Header="Size" Width="SizeToHeader" />
                <DataGridTextColumn x:Name="sizeUnitMeasureCodeColumn" Binding="{Binding Path=SizeUnitMeasureCode}" Header="Size Unit Measure Code" Width="SizeToHeader" />
                <DataGridTextColumn x:Name="standardCostColumn" Binding="{Binding Path=StandardCost}" Header="Standard Cost" Width="SizeToHeader" />
                <DataGridTextColumn x:Name="styleColumn" Binding="{Binding Path=Style}" Header="Style" Width="SizeToHeader" />
                <DataGridTextColumn x:Name="weightColumn" Binding="{Binding Path=Weight}" Header="Weight" Width="SizeToHeader" />
                <DataGridTextColumn x:Name="weightUnitMeasureCodeColumn" Binding="{Binding Path=WeightUnitMeasureCode}" Header="Weight Unit Measure Code" Width="SizeToHeader" />
            </DataGrid.Columns>
        </DataGrid>
    </Grid>
</Window>

The most important part is on line 20. The binding for the ListPrice property is set to TwoWay, ValidatesOnDataErrors is true and NotifyOnValidationError is also true. This will make sure that when the user enters a listprice smaller than zero, validation will kick in:

The WCF Service

Last up is the WCF Service, which uses the new EF 4.1 DbContext api to load from- and update data in the database:

using System;
using System.Linq;
using System.Runtime.Serialization;
using System.ServiceModel;
using System.ServiceModel.Activation;
using EntitiesLibrary;
using DbContextLibrary;
using System.Collections.Generic;
using System.Data.Entity.Validation;
using System.Data;
  
namespace ProductsApp.Web
{
    [ServiceContract(Namespace = "")]
    [AspNetCompatibilityRequirements(RequirementsMode = AspNetCompatibilityRequirementsMode.Allowed)]
    public class ProductService
    {
        [OperationContract]
        public Product[] GetProducts() 
        {
            using (AdventureWorks2008Entities ents = new AdventureWorks2008Entities())
            {
                return ents.Product.AsNoTracking().ToArray();
            }
        }
  
        [OperationContract]
        [FaultContract(typeof(string[]))]
        public void UpdateProduct(Product toUpdate)
        {
            using (AdventureWorks2008Entities ents = new AdventureWorks2008Entities())
            {
                //prevent validating before save because I do this manually
                ents.Configuration.ValidateOnSaveEnabled = false;
  
                //Prevent detecting changes before save....
                ents.Configuration.AutoDetectChangesEnabled = false;
  
                ents.Product.Attach(toUpdate);
                ents.ChangeTracker.Entries<Product>().
                        Single((entry) => entry.Entity == toUpdate).State = EntityState.Modified;
                DbEntityValidationResult error = ents.GetValidationErrors().SingleOrDefault();
                if (error != null)
                {
                    throw new FaultException<string[]>(
                            error.ValidationErrors.Select((er) => er.PropertyName + ": " + er.ErrorMessage).ToArray()
                        );
                }
                else
                {
                    
                    ents.SaveChanges();
                }
            }
        }
    }
}

Line 19-25: This isn’t that exciting, I just load the data with no tracking from the database. In a service, tracking won’t do you any good.
Line 29-55: This is the most interesting part. My web project also references my EntitiesLibrary project, witch contains the Product class with the buddy mechanism and the data annotation on the listprice. The DbContext api will by default automatically validate before saving and will throw an exception if there are errors. I’m disabling this behavior on line 34 since I’m going to validate up front. Because I’m in a service, the DbContext can’t detect any changes since it doesn’t have any original values, so I’m also disabling this behavior on line 37. On line 39 the product is attached. On line 40-41 I’m changing the state of the product to modified. This is necessary, if you forget this, the DbContext won’t validate (even when doing this manually) or save the product. Since I know for certain that the DbContext is only tracking one entity, I retrieve the single DbEntityValidationResult on line 42. If there are no errors, I will get an empty collection and because of the SingleOrDefault method I will get null. Thus, if the error is not null on line 43, I throw a new FaultException and supply it with a string[]. This string[] contains the validation errors for all the properties that caused errors. Of course, this will only be the listprice since it’s the only one with a data annotation. If the validation returned null, I’m saving the changes on line 52.

The Console Application

As you can see above, using the DbContext api means that you don’t have to write validation code on both the client and the server. This problem was already solved for Silverlight by WCF RIA Services, but now we can finally share the data annotations between the server and other client technologies as well. Now let’s test our service with a client that doesn’t do any validation in the UI and tries to submit some illegal values:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using ProductsConsoleApp.Services;
using EntitiesLibrary;
using System.ServiceModel;
using System.ComponentModel;
  
namespace ProductsConsoleApp
{
    class Program
    {
        static void Main(string[] args)
        {
            ProductServiceClient client = new ProductServiceClient();
            Product first = client.GetProducts()[0];
            first.ListPrice = -1;
            try
            {
                client.UpdateProduct(first);
            }
            catch (FaultException<string[]> ex)
            {
                Console.WriteLine("There were validation errors on the server:");
                foreach (string errorMessage in ex.Detail)
                {
                    Console.WriteLine(errorMessage);
                }
            }
            Console.ReadKey();
        }
    }
}

If you’d run the application above you would get the following output:

And we can see that our server is protected against bad input.

Conclusion

One of the most overlooked features of the Entity Framework 4.1 is the new ability to validate the entities according to the buddy class mechanism and data annotations. This means that when we write serverside code, we don’t have to write the validation logic ourselves and that we can share the entities between client and server to use the same validation logic on the client. This also works of course when the client is an ASP.NET MVC Controller for example.

I’ve tried to share code this way between a Silverlight client and a WCF Service but this doesn’t work. This is because the EntitiesLibrary project must be a Silverlight class library before it can be referenced by both Silverlight and the server project. In Silverlight the data annotations are defined in a different assembly with a different version than the data annotations in the full .Net framework. The Entity Framework and the Validator class in the full .Net framework will NOT recognize data annotations from Silverlight. It seems that the best way to share validation code with Silverlight is by using WCF RIA Services. You can find the working example here.