Guy Burstein : .Net RIA Services

.Net RIA Services: Custom Validation

Guy Burstein — Tue, 14 Apr 2009 21:23:54 GMT

.Net RIA Services: Custom Validation

This is another post in a series of posts about building applications with Microsoft .Net RIA Services and Silverlight 3 and ASP.Net.

In my previous post .Net RIA Services Part 3: DataForm and Validation I explained how to add validation metadata to entities and showed how the DataForm control enforces them. I used simple validation metadata attributes such as RegularExpressionAttribute, RequiredAttribute and StringLengthAttribute that help us in basic scenarios.

If you want to write custom validation, you can inherit from System.ComponentModel.DataAnnotations.ValidationAttribute, but a more simple way would be to write a validation method, and share it between the server side and the client side, as I explained in my previous post .Net RIA Services: Sharing Code between the Client and Server.

In CustomerValidation.shared.cs file (in the server side) I wrote the following method, that takes the value of a property and returns an indication whether it is valid or not.

[Shared]
public class CustomerValidation
{
  [Shared]
  public static bool IsEmailEndsWithDotCom(string email)
  {
    if (email.EndsWith(".com"))
      return true;
    return false;
  }
 
}

To apply this validation logic on an entity property, use the CustomValidationAttribute with the about type and method name, and the error message to display.

internal sealed class CustomerMetadata
{
  ...  
 
  [CustomValidation(typeof(CustomerValidation),         
   "IsEmailEndsWithDotCom",
    ErrorMessage = "Customer\'s email address must end with .com")]
  public string Email;
 
  ...
}

At runtime, the framework will invoke this method passing it the property value, and if it returns False, the error message will be shown.

The above sample is also nice for scenarios is which the logic is independent of any other property about the entity that’s being validated. In cases where you need additional information about the entity to perform the validation logic, you can use a more complex signature of the validation method.

[Shared]
public class CustomerValidation
{ 
  [Shared]
  public static bool EnsureBusinessEmailAddress(string email,       
    ValidationContext ctx,       
    out ValidationResult result)
  {
    result = null;
 
    Customer cust = (Customer)ctx.ObjectInstance;
 
    if (cust.IsBusiness)
    {
      if (!cust.Email.EndsWith(".com"))
      {
        result = new ValidationResult("Business Customer's email address must end with .com");
      }
    }
 
    return false;
  }
}

In this approach I receive not only the property value, but also an instance of ValidationContext that provides me with some information about the entity and property being validated and also a reference to the entity instance itself.

Using it is the same, except that here I pass the error message in the out parameter ValidationResult, instead of providing it in the validation attribute.

internalsealedclassCustomerMetadata
{
  ...
  
  [CustomValidation(typeof(CustomerValidation), "EnsureBusinessEmailAddress")]
  public string Email;
 
  ...
}

Enjoy!

.Net RIA Services: Sharing Code between the Client and Server

Guy Burstein — Tue, 14 Apr 2009 20:44:08 GMT

.Net RIA Services: Sharing Code between the Client and Server

This is another post in a series of posts about building applications with Microsoft .Net RIA Services and Silverlight 3 and ASP.Net.

In this I’ll talk about how to share code between the server side and the Silverlight client application.

One of the great things in .Net RIA Services is that code that we wrote in the server side can be resued in the client side. To do that, create a new class in the server side called with .shared.cs or .shared.vb suffix (CustomerValidation.shared.cs in this sample).

In this class, code what you’d live to share with the client side, under the rational limitations. To make the code sections shared between the server and the client, decorate them with System.Web.Ria.Data.SharedAttribute. For example:

[Shared]
public class CustomerValidation
{
  [Shared]
  public static bool IsEmailEndsWithDotCom(string email)
  {
    if (email.EndsWith(".com"))
      return true;
    return false;
  } 
}

After you build the solution, Visual Studio will copy this file to the Silverlight client application:

and now, you can use this code in the client application, as you did in the server side. Here is an example of me using the shared code in the HomePage class in the Silverlight client application.

Enjoy!

.Net RIA Services Part 3: DataForm and Validation

Guy Burstein — Tue, 14 Apr 2009 20:15:56 GMT

.Net RIA Services Part 3: DataForm and Validation

This is the forth part in a series of posts about building applications with Microsoft .Net RIA Services and Silverlight 3. In part 1 of this series I created a new application, created a simple data model and used the Domain Service and Domain Context to retrieve data and bind it to a DataGrid. In part 2 we replaced the manual work needed to get the data from the server with the DomainDataSource that provided some more advanced scenarios such as filtering and sorting. In this post we’ll introduce the DataForm control and talk more about data validation.

Using the DataForm control

Add A DataForm Control and bind it to the current item of the DataGrid. Open Views\HomePage.xaml, and add a DataForm Control right after the DataPager.

<Grid x:Name="LayoutRoot" Background="White">          
          
    ...  
        
    <dataControls:DataPager PageSize="3"
         Source="{Binding Data, ElementName=customersDataSource}" />
 
    <dataControls:DataForm x:Name="customerDataForm"
        Header="Customer Data"
        CurrentItem="{Binding ElementName=dataGrid, Path=SelectedItem}">
    </dataControls:DataForm>          
          
    ...        
       
</Grid>

If you run the application, you should see the DataForm below the DataGrid. Move between the items, and see how the displayed customer’s data is changing as you do that.

To edit an item, click the pencil icon on the DataForm.

When you do that, the controls will be replaced with input controls, and Save and Cancel buttons will show up.

If you change a value of a property in a customer’s data, you’ll get a notification that this data was changed and the customer is not “dirty”.

Notice that changes that are made here are tracked only in memory. This means, that by pressing the Save button, you’ll switch over to Display more, but the data is not saved to the server. To enable submitting changes back to the server, we need to add a submit button below the DataForm.

<Button x:Name="btnSubmit"
      Width="120"
      Click="btnSubmit_Click"
      Content="Submit" />

As the implementation of the submit button, you’ll need to commit the changes of the current item that is being edited (similar to EndCurrentEdit() in Windows Forms), and only then pushing the changes back the server.

private void btnSubmit_Click(object sender, RoutedEventArgs e)
{
  this.customerDataForm.CommitItemEdit();
  this.customersDataSource.SubmitChanges();      
}

Adding Validation Logic using Data Annotations

One of the great things in .Net RIA Services is that code that we wrote in the server side can be resued in the client side. This means that we can reuse the validation annotations that we have for our domain entities.

To annotate entities with validation semantics, open the metadata file for the domain service (BankDomainService.metadata.cs in the sample). In this file, you’ll find partial classes that match your domain classes (class Customer in this sample), decorated with MetadataTypeAttribute pointing to a metadata type the is also generated here as an inner class. The metadata class has fields / properties that match the properties that the original class has, that you can annotate with validation requirements.

[MetadataTypeAttribute(typeof(Customer.CustomerMetadata))]
public partial class Customer
{
  internal sealed class CustomerMetadata
  { 
    public int CustomerID;
 
    public bool IsBusiness;
 
    public string Name;
 
    public string City;
 
    public string Email;
 
    public EntitySet<Account> Accounts;
  }
}

In this examples we’ll use the Regular Expression attribute, the String Length Attribute and the Required Attribute to validate the customer entity, but I encourage you to explore the System.ComponentModel.DataAnnotations namespace more deeply.

internal sealed class CustomerMetadata
{
  public int CustomerID;
 
  public bool IsBusiness;
 
  [Required(ErrorMessage="Please provide a name for the customer")]
  [StringLength(30, 
    ErrorMessage="Customer's name cannot be more than 30 characters")]
  public string Name;
 
  [StringLength(30, 
    ErrorMessage = "Customer's city cannot be more than 15 characters")]
  public string City;
 
  [RegularExpression(@"^[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,4}$",
    ErrorMessage="Please provide a valid email address")]
  public string Email;
 
  public EntitySet<Account> Accounts;
}

Build the project and Visual Studio will regenerate the client side code for the domain context, that will now also contain the metadata.

If you now run the application, and try to update a customer’s entity with values that do not match the validations, you will get a visual notification and the data will not be updated to the server.

In this post I talked about the new DataForm control in .Net RIA Services, showed how to add it to our application and how it works. Then we talked a little bit about annotating the entities with validation requirements and saw how the DataForm enforces them.

Enjoy!

ASP.Net DomainDataSource with Select Parameters

Guy Burstein — Sun, 12 Apr 2009 10:19:40 GMT

ASP.Net DomainDataSource with Select Parameters

Continuing with .Net RIA Services with Silverlight and ASP.Net. In the last port I wrote about Using DomainDataSource in ASP.Net, and showed its basic usage. In this post I’ll show a more advanced scenario in which you want to use a domain service select method that takes parameters, and get the parameter value from a control on the form.

In the previous post, we had a GridView bound to a DomainDataSource that called a Select Method on the DomainService.

<asp:GridView runat="server" ID="GridView" 
  AutoGenerateColumns="true"
  DataSourceID="customersDataSource">
</asp:GridView>
 
<asp:DomainDataSource runat="server" ID="customersDataSource" 
  DomainServiceTypeName="Samples.Bank.Domain.BankDomainService"
  SelectMethod="GetCustomers">
</asp:DomainDataSource>

The output was:

Now we want to filter the output list by the City property. To do that, we first have to add a method in our Domain Service that returns the data filtered by a city parameter.

public class BankDomainService : LinqToSqlDomainService<BankDataContext>
{
  public IQueryable<Customer> GetCustomers()
  {
    return this.Context.Customers;
  }
 
  public IQueryable<Customer> GetCustomersByCity(string city)
  {
    if (city == null)
      return GetCustomers();
 
    return GetCustomers().Where(c => c.City == city);
  }
 
  ...
}

Notice that GetCustomersByCity method uses the GetCustomers method that returns an IQueryable<Customer> and filters the result by city.

To select which city we want to filter by, lets add a ListBox with some items:

<asp:ListBox ID="lstCities" AutoPostBack="true" runat="server">
  <asp:ListItem>Tel Aviv</asp:ListItem>
  <asp:ListItem>Raanana</asp:ListItem>
  <asp:ListItem>Ramat Gan</asp:ListItem>
</asp:ListBox>

Note that I had to specify AutoPostBack=”true” in make any change to the filter, since this is a server control.

Now, in order to filter the data source according to the domain method with the select parameter I have to specify a SelectParameter that takes its value from the ListBox, and change the select method to execute.

<asp:DomainDataSource runat="server" ID="customersDataSource"        
  DomainServiceTypeName="Samples.Bank.Domain.BankDomainService"
  SelectMethod="GetCustomersByCity">         
        
  <SelectParameters>
    <asp:ControlParameter Name="city" ControlID="lstCities"         
         PropertyName="SelectedValue"  Type="String" />
  </SelectParameters>          
        
</asp:DomainDataSource>

Now, If we run the application, we can select items in the ListBox, and the items in the GridView will be filtered by the city value.

Enjoy!

Using DomainDataSource in ASP.Net

Guy Burstein — Sat, 11 Apr 2009 23:16:05 GMT

Using DomainDataSource in ASP.Net

In ASP.Net 2.0 we were introduced to this concept of Data Source controls. We got the ObjectDataSource, XmlDataSource and SqlDataSource that let us bind a GridView or a ListBox to some data without having to write any additional code. In .Net Framework 3.5 we got LinqDataSource and with .Net Framework 3.5 – the EntityDataSource. In the future of ASP.Net, among other significant improvements around data access, we get a new way of accessing our data – DomainDataSource.

The benefits of using the DomainDataSource is that is give us nice separation from the way our Data Model is represented (LINQ to SQL vs EF, POCO and Cloud) and gives us more control over how the data is being retrieved and manipulated.

In this post I’ll introduce the DomainDataSource that is already available as part of .Net RIA Service, and give a quick walkthrough on how to use it in an ASP.Net Web Forms application.

Creating a Data Model and a Domain Service

Create a new ASP.Net Web Application in Visual Studio 2008.

Add a Data Model to your application, whether it is a LINQ to SQL data model, an Entity Framework Data Model, or any other data model. In this sample I am using the Bank Schema with LINQ to SQL.

Make sure to build the project so that Visual Studio will generate the data classes and data context before the next step.

Add a new Domain Service. Add a new Item to the server project, and select the Domain Service template in the Web category.

After you add this item, the New Domain Service Class Dialog is shown. Select the Data Context (BankDataContext in this sample), select the entities you want to expose and whether you want to allow editing and click OK.

This adds the BankDomainService.cs that contains the code that exposes the data to the client, and BankDomainService.metadata.cs that contains additional metadata, mostly for presentation and validation.

This is how the DomainService looks like when working with LINQ to SQL. If you were working with the Entity Framework, the base class would be different. It simply contains CRUD methods for working with the data context.

public class BankDomainService : LinqToSqlDomainService<BankDataContext>
{
  public IQueryable<Customer> GetCustomers()
  {
    return this.Context.Customers;
  }
 
  public void InsertCustomer(Customer customer)
  {
    this.Context.Customers.InsertOnSubmit(customer);
  }
 
  public void UpdateCustomer(Customer currentCustomer, Customer originalCustomer)
  {
    this.Context.Customers.Attach(currentCustomer, originalCustomer);
  }
 
  public void DeleteCustomer(Customer customer)
  {
    this.Context.Customers.Attach(customer, customer);
    this.Context.Customers.DeleteOnSubmit(customer);
  }
}

It also adds some new references to System.ComponentModel.DataAnnotations, System.Web.DomainServices, System.Web.DomainServices.Providers and System.Web.Ria.

In addition to that, a new Http Handler was added to the web.config file.

<httpHandlers>
  ...
  <add path="DataService.axd"
      verb="GET,POST"
      type="System.Web.Ria.DataServiceFactory, System.Web.Ria,          
            Version=2.0.0.0, Culture=neutral,PublicKeyToken=31BF3856AD364E35"
      validate="false" />
</httpHandlers>

Use the DomainDataSource with ASP.Net

In a page of your choice, add a GridView control or any control that can bind to a DataSourceControl.

<asp:GridView runat="server" ID="GridView">
</asp:GridView>

Add a reference to System.Web.DomainServices.WebControls.dll, and in your page, register the prefix for this namespace:

<%@ Register TagPrefix="asp" Namespace="System.Web.DomainServices.WebControls" Assembly="System.Web.DomainServices.WebControls" %>

Add a DomainDataSource and bind it to the Grid. Notice the in the DomainDataSource declaration I referenced the type of the DomainService with its full namespace, and added which method in it should be used to retrieve data.

<asp:GridView runat="server" ID="GridView" 
  AutoGenerateColumns="true"
  DataSourceID="customersDataSource">
</asp:GridView>
 
<asp:DomainDataSource runat="server" ID="customersDataSource" 
  DomainServiceTypeName="Samples.Bank.Domain.BankDomainService"
  SelectMethod="GetCustomers">
</asp:DomainDataSource>

If you now run the application, you’ll see the grid populated with the results.

With DomainDataSource you get more control on how your data is retrieved and manipulated. You can add your logic to the select method, for example – providing a filter by the authenticated user, and add logic in the update methods, such as adding default values before updating the database.

Enjoy!

Build a Simple Application with .Net RIA Services (Silverlight 3) – Part 2

Guy Burstein — Wed, 08 Apr 2009 10:04:02 GMT

Build a Simple Application with .Net RIA Services (Silverlight 3) – Part 2

This is the second post in a series of posts about building applications with Microsoft .Net RIA Services and Silverlight 3. In part 1 of this series I created a new application, created a simple data model and used the Domain Service and Domain Context to retrieve data and bind it to a DataGrid.
In this post we take it from that step, and replace the manual work with the DomainDataSource that provides some more advanced scenarios.

Use a DomainDataSouce to easily connect the data

Remove the code that retrieves the data from the server. Open Views\HomePage.xaml and comment out all the code in the Page_Loaded method.

Instead of loading the data manually, add a DomainDataSource control to the page. To do this, add a reference to System.Windows.Ria.Controls.dll, and add the Xml namespace that relates to its contents:

<navigation:Page x:Class="BankApp.HomePage"
  ...        
  xmlns:ria="clr-namespace:System.Windows.Controls;        
    assembly=System.Windows.Ria.Controls"
  Loaded="Page_Loaded"
  Title="HomePage Page">        
  ...
</navigation:Page>

Add the DomainDataSource to the page

<navigation:Page x:Class="BankApp.HomePage"       
  ...
  <Grid x:Name="LayoutRoot" Background="White">
 
    <ria:DomainDataSource x:Name="customersDataSource"
                          LoadMethodName="GetCustomers"
                          AutoLoad="True"
                          LoadSize="5">
 
    </ria:DomainDataSource>
   ...
  </Grid>
</navigation:Page>

Reminder: After creating the DomainService in the server side, Visual Studio has generated a client side DomainContext that does all the magic of connecting to the server for us.

Assign the DomainContext to the DomainDataSource so it can use it to pull data from the server. To do that, add a local xml namespace:

<navigation:Page x:Class="BankApp.HomePage"
   ...
   xmlns:local="clr-namespace:BankApp.Web"
   Title="HomePage Page">        
   ...
</navigation:Page>

And do the assignment:

<ria:DomainDataSource x:Name="customersDataSource"
                      LoadMethodName="LoadCustomers"
                      AutoLoad="True"
                      LoadSize="5">          
          
  <ria:DomainDataSource.DomainContext>
    <local:BankDomainContext />
  </ria:DomainDataSource.DomainContext>          
          
</ria:DomainDataSource>

The last thing we need to do is to bind the DataGrid to the DomainDataSource.

<data:DataGrid MinHeight="200"
              x:Name="dataGrid"
              ItemsSource="{Binding Data, ElementName=customersDataSource}">
</data:DataGrid>

Run the application, and see how the data is being loaded in chunks according to the LoadSize property of the DomainDataSource.

Add a DataPager Control to enable paging through the data. To do that, add a reference to System.Windows.Controls.Data.DataForm.dll the following xml namespace:

xmlns:dataControls=
"clr-namespace:System.Windows.Controls;assembly=System.Windows.Controls.Data.DataForm”

Add the DataPager control and bind it to the DomainDataSource:

<data:DataGrid MinHeight="200" ...>
</data:DataGrid>
 
<dataControls:DataPager PageSize="3"
              Source="{Binding Data, ElementName=customersDataSource}" />

If you now run the application, you should get a result similar to this:

Data Grouping

Add Grouping support to the DataGrid. Add the following xml namespace:

xmlns:riaData="clr-namespace:System.Windows.Data;assembly=System.Windows.Ria.Controls"

Then, add a group descriptor to group the results by the property City.

<ria:DomainDataSource ...>
 
  <ria:DomainDataSource.GroupDescriptors>
    <riaData:GroupDescriptor PropertyPath="City" />
  </ria:DomainDataSource.GroupDescriptors>
 
</ria:DomainDataSource>

The result should look like this:

Data Sorting

To add sorting support, add a SortDescriptor:

<ria:DomainDataSource ...>
 
  <ria:DomainDataSource.SortDescriptors>
    <riaData:SortDescriptor PropertyPath="CustomerID"
                            Direction="Descending" />
  </ria:DomainDataSource.SortDescriptors>
 
</ria:DomainDataSource>

Rich Data Filtering

Add a dynamic filtering support based on a selected value of a CheckBox. Add a Checkbox above the DataGrid.

<CheckBox x:Name="chkBusiness"
          Content="Business Customer ?" />
 
<data:DataGrid x:Name="dataGrid" ...> </data:DataGrid>

Add a FilterDescriptor that filters data according to the IsBusiness property of each item. Bind the FilterDescriptor to the IsChecked property of the above checkbox.

<ria:DomainDataSource x:Name="customersDataSource" ... >
  ...          
  <ria:DomainDataSource.FilterDescriptors>
    <riaData:FilterDescriptorCollection>
      <riaData:FilterDescriptor PropertyPath="IsBusiness"
                                Operator="IsEqualTo">
        <riaData:ControlParameter ControlName="chkBusiness"
                                  PropertyName="IsChecked"
                                  RefreshEventName="Click" />
      </riaData:FilterDescriptor>
    </riaData:FilterDescriptorCollection>
  </ria:DomainDataSource.FilterDescriptors>
 
</ria:DomainDataSource>

Run the application, check and uncheck the checkbox, and see how the data is refreshed accordingly.

Conclusion

In this post we took on from where we left at Part 1 , and replaced the manual work needed to get the data from the server with the DomainDataSource that provides some more advanced scenarios. In the next post we’ll introduce the DataForm control and talk more about data validation.

Enjoy!

Build a Simple Application with .Net RIA Services (Silverlight 3) – Part 1

Guy Burstein — Sat, 04 Apr 2009 20:28:24 GMT

Build a Simple Application with .Net RIA Services (Silverlight 3) – Part 1

This is the first post in a series of posts about building applications with Microsoft .Net RIA Services and Silverlight 3. In this post I will create a new application, create a simple data model and use the Domain Service and Domain Context to retrieve data and bind it to a DataGrid.

Before you start, make sure you have Silverlight 3 Beta and .NET RIA Services March 2009 Preview installed, and you have already installed and configured SQL Server. In this sample I am using the Bank Schema I’ve used in the past.

Create a Silverlight Navigation Application

Create a new Silverlight Navigation Application.

After you click OK, the New Silverlight Application Dialog is shown. Click OK again to create an ASP.Net project that links to the new Silverlight Application.

A new solution is created. Notice the new assemblies that the Silverlight project is referencing, and notice the new assemblies among them.

Build a Domain Service

Add a new Data Model to your server side project (BankApp.Web). This data model can be a LINQ to SQL model, an Entity Data Model, or you can use any other business object representation.

In this sample I am using a LINQ to SQL data model based on the Bank Schema.

Make sure to build the project so that Visual Studio will generate the data classes and data context before the next step.

Add a new Domain Service. Add a new Item to the server project, and select the Domain Service template in the Web category.

A few references were also added: System.ComponentModel.DataAnnotations, System.Web.DomainServices, System.Web.DomainServices.Providers and System.Web.Ria.

In addition to that, a new Http Handler was added to the web.config file.

<httpHandlers>
  ...
  <add path="DataService.axd"
      verb="GET,POST"
      type="System.Web.Ria.DataServiceFactory, System.Web.Ria, Version=2.0.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35"
      validate="false" />
</httpHandlers>

Build the solution. This executes a build target the generates the client side code that is required in order to consume the Domain Service. If you click the Show All Files button for the client application, you’ll notice the generated code.

Display Domain Data in the Application

Add a DataGrid Control to the client application. To do that, add a reference to System.Windows.Controls.Data.dll that contains the DataGrid Control.

Then, open the Views\AboutPage.xaml and add an xmlns prefix to the CLR namespace of the DatGrid.

<navigation:Page x:Class="BankApp.HomePage"
    ...        
     xmlns:data="clr-namespace:System.Windows.Controls;        
assembly=System.Windows.Controls.Data"       
     ...        
>

Add the Xaml markup for the DataGrid Control:

<Grid x:Name="LayoutRoot" Background="White">
  <StackPanel>
    ...
    <StackPanel Style="{StaticResource ContentTextPanelStyle}">
    ...
    </StackPanel>
 
    <data:DataGrid MinHeight="200" x:Name="dataGrid">
    </data:DataGrid>
  </StackPanel>
</Grid>

Handle the Loaded Event of the Page. First, Add a method to handle the Loaded event of the page.

<navigation:Page x:Class="BankApp.HomePage"
    ...        
    Loaded="Page_Loaded"
    Title="HomePage Page">

In the method that handles the event, use the client Domain Context to retrieve data from the service and bind to the DataGrid.

private void Page_Loaded(object sender, RoutedEventArgs e)
{
  BankDomainContext context = new BankDomainContext();
  this.dataGrid.ItemsSource = context.Customers;
  context.LoadCustomers();
}

Now, run the application and let it go and retreive the data and present it in the DataGrid.

In this post I created a new application, created a simple data model and used the Domain Service and Domain Context to retrieve data and bind it to a DataGrid. In the next post I’ll explore more controls that ship with the .Net RIA Services.

Enjoy!