RIA Services Validation: Attribute Propagation

Since the beginning of the RIA Services project, a primary tenet was to propagate validation rules defined on the server up to the client, integrating the validation directly into the Silverlight UI.  This came to fruition with RIA Services v1.0 and you can in fact apply an attribute to your model on the server and automatically get instant client-side validation of data entry on even the simplest of Textbox controls.  In fact, some validation rules are inferred from your data model directly.  This is a feat that many other frameworks have attempted to accomplish, but I believe RIA Services has one of the most successful implementations of the concept.  In this post, we’ll examine how attributes declared on your model are propagated to the client.  By understanding what is going on behind-the-scenes, you’ll be able to better leverage validation capabilities.

Code Generation Overview

The entire RIA Services product is centered around its code generation capabilities.  You create DomainService classes on the server and RIA Services generates Entity classes within your Silverlight project that mimic your model on the server.  You might not ever see the generated code, or even recognize that it’s happening, but it is.  Every time you build your solution, RIA Services generates the classes in your Silverlight project that give you the ability to create, read, update, and delete data, and invoke custom operations within your domain services.

I learn best about these types of topics by examining the results—let’s do just that.  I encourage you to walk along with me as we take a brief tour through RIA Service’s generated code.

1. In Visual Studio 2010, create a New Project and select the Silverlight Application template from the Silverlight category.  I will be illustrating C#, but if you primarily use VB, feel free to choose that language for your project.  After entering your project name (“RudeValidation” for me), click OK and you will get the “New Silverlight Application” dialog.
2. In order to utilize WCF RIA Services in your Silverlight application, you’ll need to choose to host the Silverlight application in an ASP.NET Web Application Project, Silverlight 4, and Enable WCF RIA Services.  After setting those options, click OK and two projects will be created in your solution, one with the name you specified and another that is suffixed with .Web.
3. We need to create a model on the server.  This could be done through Entity Framework, Linq to SQL, NHibernate, or any other data access library.  In our case, we will just create a Plain Old CLR Object (POCO) by creating a new class in our project.  Right-click on your Web project and choose Add –> Class. Name the file “Meeting.cs” and click Add.
4. Our class will be quite simple, but it will require a reference to an additional assembly: System.ComponentModel.DataAnnotations.  After adding that reference, we can create our model with the following code:

        using System;
        using System.ComponentModel.DataAnnotations;
 
        namespace RudeValidation.Web
        {
            public class Meeting
            {
                [Key]
                public int MeetingId { get; set; }
                public DateTime Start { get; set; }
                public DateTime End { get; set; }
                public string Title { get; set; }
                public string Details { get; set; }
                public string Location { get; set; }
                public int MinimumAttendees { get; set; }
                public int MaximumAttendees { get; set; }
            }
        }

1. Our next step is to create a Domain Service Class that will expose this Meeting entity to the client, thus triggering code generation to occur. Right-click on the Web project and choose Add –> New Item… again.  This time select “Domain Service Class” from the Web templates.  After naming the class “MeetingService.cs” and clicking Add, you will get the “Add New Domain Service Class” wizard.  We’re creating an empty Domain Service class, so just click OK.
2. By adding a single method to our MeetingService, we can gain access to our Meeting entity in our Silverlight project, and this will allow us to better understand the results of the code generation and continue on to our exploration of validation attribute propagation.  Set your MeetingService.cs file to have the following code, and then build your solution:

        namespace RudeValidation.Web
        {
            using System.Collections.Generic;
            using System.Linq;
            using System.ServiceModel.DomainServices.Hosting;
            using System.ServiceModel.DomainServices.Server;
 
 
            [EnableClientAccess]
            public class MeetingService : DomainService
            {
                public IEnumerable<Meeting> GetMeetings()
                {
                    return Enumerable.Empty<Meeting>();
                }
            }
        }

At this point, we have a new Silverlight project, an entity class defined on the server, a DomainService class that exposes it to the client (thanks to the [EnableClientAccess] attribute), and our solution is building.  It isn’t obvious, but RIA Services is now generating code within the Silverlight project each time you build.  The generated code is not automatically visible within the Silverlight project, but we can navigate to it easily.

1. Select the Silverlight project in the Solution Explorer;
2. Click on the “Show All Files” button, or as Scott Hanselman calls it, the “Don’t Lie To Me” button.
3. You’ll see a .Web.g.cs file in the folder – this is what RIA Services has generated for you.  Let’s crack this bad-boy open and see what we have!

You will notice that the generated code includes a handful of types: WebContext, Meeting, MeetingContext, MeetingContext.IMeetingServiceContract, and MeetingContextEntityContainer.  Our focus will be on the Meeting class that is generated.  There are a few notable details for this class:

        /// <summary>
        /// Gets or sets the 'Title' value.
        /// </summary>
        [DataMember()]
        public string Title
        {
            get
            {
                return this._title;
            }
            set
            {
                if ((this._title != value))
                {
                    this.OnTitleChanging(value);
                    this.RaiseDataMemberChanging("Title");
                    this.ValidateProperty("Title", value);
                    this._title = value;
                    this.RaiseDataMemberChanged("Title");
                    this.OnTitleChanged();
                }
            }
        }

    public class Meeting
    {
        [Key]
        public int MeetingId { get; set; }
 
        [Required]
        public DateTime Start { get; set; }
 
        [Required]
        public DateTime End { get; set; }
 
        [Required]
        [StringLength(80, MinimumLength = 5)]
        public string Title { get; set; }
 
        public string Details { get; set; }
 
        [Required]
        [RegularExpression(@"\d{1,3}/\d{4}",
            ErrorMessage = "{0} must be in the format of 'Building/Room'")]
        public string Location { get; set; }
 
        [Range(2, 100)]
        [Display(Name = "Minimum Attendees")]
        public int MinimumAttendees { get; set; }
 
        [Range(2, 100)]
        [Display(Name = "Maximum Attendees")]
        public int MaximumAttendees { get; set; }
    }

        /// <summary>
        /// Gets or sets the 'Title' value.
        /// </summary>
        [DataMember()]
        [Required()]
        [StringLength(80, MinimumLength=5)]
        public string Title
        {
            get
            {
                return this._title;
            }
            set
            {
                if ((this._title != value))
                {
                    this.OnTitleChanging(value);
                    this.RaiseDataMemberChanging("Title");
                    this.ValidateProperty("Title", value);
                    this._title = value;
                    this.RaiseDataMemberChanged("Title");
                    this.OnTitleChanged();
                }
            }
        }