.Net RIA Services Metadata Programming Model

Welcome Back! I hope you enjoy the content on this site. If you have not done so already, you may want to subscribe to my RSS feed or become a fan of this blog on Facebook. Thanks for visiting!

This is the third part of the a multi post series on .Net RIA Services.

First Part - Getting Started with .Net RIA Services

Second Part - .Net RIA Services – Hello World

In this part I will talk about using the .Net RIA Services Metadata Model for data validation and authorization. Unlike the second part of this series this won’t be a tutorial but more of a theoretical article.

We have all suffered when designing business applications to implement data validation and authorization. It’s a dull and meticulous process that bores the hell out of any developer.

Proper data validation should be implemented at two levels, at the UI with ASP.Net validators for example and at the business tier. What if we could write user input validation and data validation code only once in such a way that it’s used both at the UI level and in the business tier, and lets push it further, what if we could write it such that no matter which client (Presentation Layer) we use it will be taken into consideration. Sounds pretty optimistic? Actually it’s not, this is exactly what .Net RIA Services Metadata programming model can do for you.

We would start by defining our Entity class, the Metadata class and then a DomainService to enable client access from the Silverlight application so we can take a look at how the validation Metadata is translated on the client side.

Defining the Entity and the Metadata Class

Let’s take a look at some code. Say you are writing a inventory system and have a product class defined like this:

public class Product
{
    public string Name { get; set; }

    public string SKU { get; set; }

    public double Price { get; set; }
}

We  surely want to have some validation when the user inputs this values. So we want:

• All three properties to be required
• The SKU to have a length of 8 characters.
• The Price to be greater than zero
• Define a Key for the Entity

We would start by creating a Metadata class for our Product class we will call it ProductMetadata.

Metadata classes provide a convenient way to attach metadata to an entity without actually modifying the corresponding members on the entity itself.

The rules for using a metadata class are:

1. The entity class must be marked with [MetadataType] to name the metadata class
2. The metadata class must contain only members whose name match members in the entity class.
   

The metadata class may omit members it does not want to extend, but it may not contain members not in the entity class. The members are required only to match in name, which explains why Name is a property in the Product class but a field in the metadata class.

Metadata members are not required to be of the same type as their corresponding entity member, but it helps readability if they are.

For every member of the entity class that has a matching member in the metadata class, the custom attributes are combined. The metadata class exists only on the server. When code-generation creates the client proxy class for the entity, the custom attributes are combined into the the generated class.

Bellow is the product class with the Metadata class:

[MetadataType(typeof(ProductMetadata))]
public class Product
{
   public string Name { get; set; }

   public string SKU { get; set; }

   public double Price { get; set; }

   internal sealed class ProductMetadata
   {
      public string Name;

      public string SKU;

      public double Price;
   }

}

Notice the attribute we added to the Product class that sets which class we would use for the Metadata:

[MetadataType(typeof(ProductMetadata))]

Making the Properties Required

To make the properties required all we need to do is add the validation attribute RequiredAttribute available in System.ComponentModel.DataAnnotations. The class should now look like this:

internal sealed class ProductMetadata
{
   [Required]
   public string Name;

   [Required]
   public string SKU;

   [Required]
   public double Price;
}

Setting  the SKU Length

We use the StringLengthAttribute also available in System.ComponentModel.DataAnnotations. This attribute is used to assert a field, parameter or property does not exceed a defined length.

[Required]
[StringLength(8,MinimumLength=8)]
public string SKU;

Validate the price

We use the RangeAttribute also available in System.ComponentModel.DataAnnotations. This attribute is used for specifying a range constraint.

[Required]
[Range(0, double.MaxValue)]
public double Price;

Defining a Key for the Entity

This is pretty simple as well. We can use the SKU as the key for the entity as it should be unique for each product. And for that we use the KeyAttribute which is used to set the unique identifier for an Entity.

[Required]
[StringLength(8,MinimumLength=8)]
[Key]
public string SKU;

Building the Product DataStore

To be able to use our Product class from Silverlight client application we need to create a “fake” DataStore which we would use to retrieve dummy data from.

The store is a simple class which defines a List<T> of products and a getter property to return the list.

public class ProductData
{
    private List<Product> m_products = new List<Product>(new Product[] {
        new Product() { Name="Mouse", SKU="MOU12345", Price=99.00},
        new Product() { Name="Keyboard", SKU="KEY45678", Price=159.00}});

    public IList<Product> Products
    {
        get
        {
            return this.m_products;
        }
    }
}

Creating a DomainService for the Product class

The DomainService class would reference the Product store and have a method that would return the list of products. The goal here as said earlier is not to explain how the domain service works but to create the necessary parts to take a look at how the Metadata attributes are translated in the generated code.

So here is the code for the ProductService:

[EnableClientAccess()]
public class ProductService : DomainService
{
    private ProductData m_productData = new ProductData();

    public IEnumerable<Product> GetProducts()
    {
        return this.m_productData.Products;
    }
}

Now we have all the parts needed  so let’s take a look at the generated code.

The Generated Validation Code

When we open the generated cs file in the Silverlight client application, beside the generated method from the DomainService we also find a translated definition of our Product class:

[DataContract(

Namespace="http://schemas.datacontract.org/2004/07/Demo.HelloWorld.Data_Models")]
    public sealed partial class Product : Entity
    {

        private string _name;

        private double _price;

        private string _sku;

        [DataMember()]
        [Required()]
        public string Name
        {
            get
            {
                return this._name;
            }
            set
            {
                if ((this._name != value))
                {
                    this.ValidateProperty("Name", value);
                    this.RaiseDataMemberChanging("Name");
                    this._name = value;
                    this.RaiseDataMemberChanged("Name");
                }
            }
        }

        [DataMember()]
        [Range(((double)(0)), ((double)(1.7976931348623157E+308)))]
        [Required()]
        public double Price
        {
            get
            {
                return this._price;
            }
            set
            {
                if ((this._price != value))
                {
                    this.ValidateProperty("Price", value);
                    this.RaiseDataMemberChanging("Price");
                    this._price = value;
                    this.RaiseDataMemberChanged("Price");
                }
            }
        }

        [DataMember()]
        [Key()]
        [Required()]
        [StringLength(8, MinimumLength=8)]
        public string SKU
        {
            get
            {
                return this._sku;
            }
            set
            {
                if ((this._sku != value))
                {
                    this.ValidateProperty("SKU", value);
                    this.RaiseDataMemberChanging("SKU");
                    this._sku = value;
                    this.RaiseDataMemberChanged("SKU");
                }
            }
        }

        public override object GetIdentity()
        {
            return this._sku;
        }
    }

We notice that all our validation and Metadata added is also available on the client side as well as the validation method call:

this.ValidateProperty("Name", value);

This call is what makes it work, before the change of the property’s value it’s validated and a validation error is raised if it doesn’t meet the constraints.

I hope that was a helpful description of how get started using the Metadata Model in .Net RIA Services.

Please Subscribe to my RSS Feed to follow this series on the .Net RIA Services.

Oh and if you liked the article please Kick It bellow!