Walkthrough: Editing Data From a Domain Service

[ This document was written for WCF Services Version 1 Service Pack 2 and might not be up to date Please see Release Notes or Changelog for a list of changes since WCF RIA Services ]

In this walkthrough, you learn how to create an interface that enables the user to change the displayed data and to save those changes in the databases.

When you have added update, insert, or delete methods in a domain service, you can create an interface in a Silverlight client that enables users to change the data. All of the changes are tracked in an EntityChangeSet object, and the changes are submitted collectively when you call the SubmitChanges method.

Prerequisites

This and the other walkthroughs presented in the Open Ria Services documentation require several prerequisite programs, such as Visual Studio and the Silverlight Developer Runtime and SDK, be installed and configured properly, in addition to Open Ria Services and the Open Ria Services Toolkit. They also require installing and configuring SQL Server 2008 R2 Express with Advanced Services and installing the AdventureWorks OLTP and LT database.

Detailed instructions for the satisfaction of each of these prerequisites are provided by the topics within the Prerequisites for Open Ria Services node. Follow the instructions provided there before proceeding with this walkthrough to ensure that you encounter as few problems as possible when working through this Open Ria Services walkthroughs.

This walkthrough assumes that you have completed the Walkthrough: Creating a Open Ria Services Solution and continues from the application created with the procedures described there.

To display and edit data from a domain service

1. Open the RIAServicesExample solution from Walkthrough: Creating a Open Ria Services Solution.

2. In MainPage.xaml, change the interface to enable the user to save or reject changes in the DataGrid.

   The following XAML adds a Save Changes button, a Reject Changes button, and a text block.

   <Grid x:Name="LayoutRoot" Background="White">
       <Grid.RowDefinitions>
           <RowDefinition Height="40"></RowDefinition>
           <RowDefinition Height="*"></RowDefinition>
       </Grid.RowDefinitions>
       <StackPanel HorizontalAlignment="Center" Grid.Row="0" Orientation="Horizontal">
           <Button Content="Save Changes" Click="SaveButton_Click" Margin="5" x:Name="SaveButton"></Button>
           <Button Content="Reject Changes" Click="RejectButton_Click" Margin="5" x:Name="RejectButton"></Button>
           <TextBlock x:Name="ChangeText" VerticalAlignment="Center" Width="Auto"></TextBlock>
       </StackPanel>
       <data:DataGrid Grid.Row="1" Name="CustomerGrid" RowEditEnded="CustomerGrid_RowEditEnded"></data:DataGrid>
   </Grid>

3. In the code-behind page for MainPage.xaml, add event handlers for the button click events, an event handler for the RowEditEnded event, a callback method named OnSubmitCompleted, and a method that evaluates the pending changes.

   Private Sub SaveButton_Click(ByVal sender As System.Object, ByVal e As System.Windows.RoutedEventArgs)
       _customerContext.SubmitChanges(AddressOf OnSubmitCompleted, Nothing)
   End Sub
   
   Private Sub RejectButton_Click(ByVal sender As System.Object, ByVal e As System.Windows.RoutedEventArgs)
       _customerContext.RejectChanges()
       CheckChanges()
   End Sub
   
   Private Sub CustomerGrid_RowEditEnded(ByVal sender As System.Object, ByVal e As System.Windows.Controls.DataGridRowEditEndedEventArgs)
       CheckChanges()
   End Sub
   
   Private Sub CheckChanges()
       Dim changeSet = _customerContext.EntityContainer.GetChanges()
       ChangeText.Text = changeSet.ToString()
   
       Dim hasChanges = _customerContext.HasChanges
       SaveButton.IsEnabled = hasChanges
       RejectButton.IsEnabled = hasChanges
   End Sub
   
   Private Sub OnSubmitCompleted(ByVal so As SubmitOperation)
       If (so.HasError) Then
           MessageBox.Show(String.Format("Submit Failed: {0}", so.Error.Message))
           so.MarkErrorAsHandled()
       End If
       CheckChanges()
   End Sub

   private void SaveButton_Click(object sender, RoutedEventArgs e)
   {
       _customerContext.SubmitChanges(OnSubmitCompleted, null);
   }
   
   private void RejectButton_Click(object sender, RoutedEventArgs e)
   {
       _customerContext.RejectChanges();
       CheckChanges();
   }
   
   private void CustomerGrid_RowEditEnded(object sender, DataGridRowEditEndedEventArgs e)
   {
       CheckChanges();
   }
   
   private void CheckChanges()
   {
       EntityChangeSet changeSet = _customerContext.EntityContainer.GetChanges();
       ChangeText.Text = changeSet.ToString();
   
       bool hasChanges = _customerContext.HasChanges;
       SaveButton.IsEnabled = hasChanges;
       RejectButton.IsEnabled = hasChanges;
   }
   
   private void OnSubmitCompleted(SubmitOperation so)
   {
       if (so.HasError)
       {
           MessageBox.Show(string.Format("Submit Failed: {0}", so.Error.Message));
           so.MarkErrorAsHandled();
       }
       CheckChanges();
   }

To set metadata for the entity to update

1. In the server project, open the metadata class named Customer.metadata.cs or Customer.metadata.vb.

   For more information, see How to: Add Metadata Classes.
2. In the metadata class, add the EditableAttribute attribute with the AllowEdit property set to false to the CustomerID and ModifiedDate properties.

   You apply the EditableAttribute attribute to a property to indicate whether the property is intended for editing by a user in a client application. When you set the AllowEdit property to false, the property is read-only in the client application. In this example, you will display the values for the CustomerID and ModifiedDate properties but do not want the user to modify these values.

3. Add the ExcludeAttribute attribute to the rowguid property.

   You apply the ExcludeAttribute attribute to properties that you do not want to include in the generated code for the client project. In this example, there is no reason to expose the rowguid property in the client project.

   The following shows the contents of the metadata class.

   ``` vb

   _ Partial Public Class Customer

   Friend NotInheritable Class CustomerMetadata
   
       'Metadata classes are not meant to be instantiated.
       Private Sub New()
           MyBase.New
       End Sub
   
       <Editable(False)> _
       Public CustomerID As Integer
   
       <Editable(False)> _
       Public ModifiedDate As DateTime
   
       <Exclude()> _
       Public rowguid As Guid

    End Class
End Class
```

``` csharp
[MetadataTypeAttribute(typeof(Customer.CustomerMetadata))]
public partial class Customer
{
    internal sealed class CustomerMetadata
    {

        // Metadata classes are not meant to be instantiated.
        private CustomerMetadata()
        {
        }

        [Editable(false)]
        public int CustomerID;

        [Editable(false)]
        public DateTime ModifiedDate;

        [Exclude]
        public Guid rowguid;

    }
}
```

1. Add the required using or Imports statements for namespaces, such as System.ComponentModel.DataAnnotations and OpenRiaServices.Server.
2. Run (F5) the application.

   Notice that you can edit the values in the DataGrid. When you exit the row you have edited, the ChangeText value is updated with a description of the pending changes. When you click the Save Changes button, the data changes are saved in the database. When you click the Reject Changes button, all pending changes are reverted.