With Great Power comes Great Response.write("Ability") : Documentation

ADO.NET Data Services : Efficient Error Handling across Application Tiers

PhaniRajuYN — Sat, 14 Nov 2009 04:43:00 GMT

While developing an application that spans multiple tiers , it is important that you be able to flow error information through the tiers without losing
any context or details in the tiers. With ADO.NET Data Services , we have an error contract which guarantees that all errors thrown from the Data Service ,
wrapped inside a DataServiceException , will be represented in a standard way on the wire when we send the error down to the client.

For example , consider the Query Interceptor shown below .

[QueryInterceptor("Customers")]
public Expression<Func<Customers, bool>> OnQueryCustomers()
{
        string loggedInUser = HttpContext.Current.User.Identity.Name;
        if (UserHasAccessToSet("Customers", loggedInUser))
        {
            //Filter Expression goes here
            return entity => true;
        }
        else //User does not have access to '/Customers' , throw AccessViolationException
        {
            throw new DataServiceException(403,
                "Forbidden",
                String.Format("User '{0}' cannot request data from '{1}' table", loggedInUser, "Customers"),
                "en-US");
        }
}

When the Astoria server runtime throws the above exception , the 403 value specified above gets turned into the response status code of the request
which caused this exception.

and the error message is serialized out to be in this format :

<?xml version="1.0" encoding="utf-8" standalone="yes" ?> 
<error xmlns="http://schemas.microsoft.com/ado/2007/08/dataservices/metadata">
  <code>Forbidden</code> 
  <message xml:lang="en-US">User 'NoPermissions' cannot request data from 'Customers' table</message> 
</error>

At this point , the service has not lost any information that the service author intended to convey to a service consumer.

Now , lets consider the client library and how it handles this case.
Lets consider a query for the “Customers” set to which the currently logged-in user doesn't have permissions.

foreach (Customers customerEntity in northwindContext.CreateQuery<Customers>("Customers") ) {
 //Do something with the customerEntity here
}

In this case, running the above code would result in a DataServiceQueryException being thrown.

System.Data.Services.Client.DataServiceQueryException: 
  An error occurred while processing this request. --->        
     System.Data.Services.Client.DataServiceClientException: 
      <?xml version="1.0" encoding="utf-8" standalone="yes"?>
        <error xmlns="http://schemas.microsoft.com/ado/2007/08/dataservices/metadata">
         <code>Forbidden</code>
         <message xml:lang="en-US">User 'NoPermissions' cannot request data from 'Customers' table</message>
      </error>

Note that the DataServiceException thrown by the server is now set to the Message property of the InnerException of the DataServiceQueryException.
We do not de-serialize the DataServiceException into an exception type on the client side.
By default , since the exception is now a string on the client side , you don’t have direct access to the information contained inside the Exception.
The information is all still there , just not easily accessible anymore. Since the error contract is documented and follows a standard pattern ,
we can easily write a visitor that de-serializes an exception object from the “Message” property of the Inner Exception.

One such de-serializer for Error contracts is shown at the bottom of this post
It contains two methods :

TryParse : which takes in an exception caused during Querying or updating via the client library and
returns a DataServiceException that was thrown by the Server
Throw : which takes in an exception caused during Querying or updating via the client library and
re-throws the DataServiceException that was thrown by the Server

Please welcome the JAVA Client for ADO.NET Data Services

PhaniRajuYN — Tue, 29 Sep 2009 06:49:00 GMT

The new Java client joins a growing family of clients for ADO.NET Data Services, which include:

Ajax , Silverlight , .Net FX ,Dynamic Data, PHP .

Here’s some documentation about the Java client http://wiki.restlet.org/docs_2.0/13-restlet/28-restlet/287-restlet.html.

Using the ADO.NET Data Services Silverlight client library in x-domain and out of browser scenarios – II (Forms Authentication)

PhaniRajuYN — Thu, 10 Sep 2009 02:20:00 GMT

Click here to download sample application

Using the ADO.NET Data Services Silverlight client library in x-domain and out of browser scenarios – II (Forms Authentication)
In this blog post, we will talk about using the Silverlight Client Library against a Data Service that is secured with Asp.Net Forms Authentication
In short, the whole process of authenticating against a Forms Authentication protected Data Service looks like this.

Server Setup

Setup Forms Authentication on the Data Service Server
Enable the WCF Authentication Service by following the reference here : How to: Enable the WCF Authentication Service
Exclude the following resources from requiring authentication ,

3.1 The WCF Authentication Service
3.2 The ClientAccessPolicy.xml File
Ex:

<!-- The ClientAccessPolicy.xml file is required for the client to confirm if the server allows X-Domain callers.
       This should be downloadable without authenticating-->
 <location path="clientaccesspolicy.xml">
    <system.web>
      <authorization>
        <allow users="*" />
      </authorization>
    </system.web>
  </location>
 <!--This should be downloadable without authenticating.-->
  <location path="AuthenticationService.svc">
    <system.web>
      <authorization>
        <allow users="*" />
      </authorization>
    </system.web>
  </location>

4. If the DataServiceHost does not have a global.asax file, add one to the project.
5. In the Global.asax file, we need to listen on the AuthenticationService.CreatingCookie event to customize the FormsAuth Cookie that the service creates.

Why do we need to customize the FormsAuth cookie?
The WCF Authentication service by default creates HTTPOnly Cookies.
This means that the cookie isn’t accessible by client-script.
It generally isn’t a problem when the client application is running in the same domain as the Website,
as the browser handles cookie management for us transparently.
When the client is not in the same domain as the Website, and we use the ClientHttpWebRequest networking stack,
we are unable to access any cookies marked as HttpOnly.
To work around this limitation, we recreate the FormsAuth cookie with HttpOnly set to false in the CreatingCookie event handler.
For more details: How to: Customize the Authentication Cookie from the WCF Authentication Service
Example code:

protected void Application_Start(object sender, EventArgs e)
{
//Handle the CreatingCookie event so that we can create a custom cookie with HttpOnly set to false.
//AuthenticationService.CreatingCookie on MSDN :
//http://msdn.microsoft.com/enus/library/system.web.applicationservices.authenticationservice.creatingcookie.aspx
AuthenticationService.CreatingCookie += new EventHandler<CreatingCookieEventArgs>(CreateSilverlightCompatibleHttpCookie);
}

/// <summary>
/// Creates a HttpCookie that can be read by the managed CookieContainer in ClientHttpWebRequest in Silverlight
/// </summary>
/// <param name="sender">The calling context for this event</param>
/// <param name="e">a property bag containing useful information about the HttpCookie to create</param>
void CreateSilverlightCompatibleHttpCookie(object sender, System.Web.ApplicationServices.CreatingCookieEventArgs e)
{
  int cookieVersion = 1;
  //The time at which the cookie was issued by the server
  DateTime cookieIssueDate = DateTime.Now;
  //The relative time from now when the cookie will expire and the client will have to re-authenticate.
  DateTime cookieExpiryDate = DateTime.Now.AddMinutes(30);
  //The Forms Auth ticket which uniquely identifies a user 
  //FormsAuthenticationTicket on MSDN : http://msdn.microsoft.com/en-us/library/system.web.security.formsauthenticationticket.aspx
  FormsAuthenticationTicket ticket = new FormsAuthenticationTicket
                (cookieVersion,
                 e.UserName,
                 cookieIssueDate,
                 cookieExpiryDate,
                 e.IsPersistent, /*Indicates whether the authentication cookie should be retained beyond the current session*/
                 e.CustomCredential,
                 FormsAuthentication.FormsCookiePath);
 //Creates a string containing an encrypted forms-authentication ticket suitable for use in an HTTP cookie.
 //FormsAuthentication.Encrypt on MSDN : http://msdn.microsoft.com/en-us/library/system.web.security.formsauthentication.encrypt.aspx
  string encryptedTicket = FormsAuthentication.Encrypt(ticket);
  HttpCookie cookie = new HttpCookie(FormsAuthentication.FormsCookieName, encryptedTicket);
  //set HttpOnly to false so that the managed CookieContainer can read the FormsAuth cookie from the response.
  cookie.HttpOnly = false;
  cookie.Expires = cookieExpiryDate;
  HttpContext.Current.Response.Cookies.Add(cookie);
  e.CookieIsSet = true;
 }

Silverlight Client Setup

We will follow an adapter pattern which is responsible for logging in the user and injecting the FormsAuth cookie as the client library makes requests.
To start with, add a Service reference to the WCF Authentication service in the Silverlight Client application or use the one in the sample.

The FormsAuthAdapter will use the client side proxy generated for the WCF Authentication service to login the user
and hook into any attached DataServiceContext instance’s SendingRequest event to inject the FormsAuth cookie.
An instance of the FormsAuthenticationAdapter is declared at the application level.

public partial class App : Application
{
/// <summary>
/// FormsAuthenticationAdapter instance to manage authentication against a WCF Authentication Service
/// </summary>
public static FormsAuthenticationAdapter FormsAuthAdapter;

This is initialized when the Application starts.

private void Application_Startup(object sender, StartupEventArgs e)
{
string authServiceUri = String.Empty;
//extract the AuthenticationService Uri from the App.XAML file
if (this.Resources.Contains("AuthenticationServiceUri"))
{
authServiceUri = this.Resources["AuthenticationServiceUri"].ToString();
}
FormsAuthAdapter = new FormsAuthenticationAdapter(new Uri(authServiceUri, UriKind.RelativeOrAbsolute));
//The FormsAuthCookieName  should be the same value as declared in the Web.config of the server
//ex: If your web.config on the server requiring Forms Authentication is :
//<authentication mode="Forms">
//  <forms loginUrl="LoginForm.aspx" name=".ASPXFormsAUTH" protection="All" path="/" />
//</authentication>
    FormsAuthAdapter.FormsAuthCookieName = ".ASPXFormsAUTH";
    this.RootVisual = new MainPage();
    //Uncomment the below 2 lines to show the Loginwindow on application startup
    //LoginWindow login = new LoginWindow();
    //login.Show();
}

This is what our client application looks like:

As you can see, along with the “Install me” button, we now have a “Login” button.

When the page loads, we attach an instance of the DataServiceContext which we want to get the FormsAuth Cookie injected while
making requests to the Data Service.

//Attach the DataServiceContext instance so that we can inject the FormsAuth cookie for each request
App.FormsAuthAdapter.Attach(publicationContext);
Where the Attach Method’s signature is :
/// <summary>
/// Injects the FormsAuth cookie when the contextInstance makes a request to the DataService
/// </summary>
/// <param name="contextInstance">The DataServiceContext instance to observe</param>
public void Attach(DataServiceContext contextInstance)

Clicking the login button on the main page opens up a ChildWindow instance that we created which emulates the Login Screen.

void LoginUser(object sender, RoutedEventArgs e)
{
    LoginWindow login = new LoginWindow();
    login.Show();
    //The LoginWindow only closes if Authentication succeeds
    login.Closing += (s, eArgs) =>
    {
       /*If auth succeeds,hide the button*/
       btnLogin.Visibility = Visibility.Collapsed;
    };
  }

The LoginWindow’s “Login” button uses the application wide FormsAuthenticationAdapter instance, discussed above, to login the user.

private void LoginUser(object sender, RoutedEventArgs e)
{
App.FormsAuthAdapter.LoginAsync(txtUserName.Text, txtPassword.Password,
    (loginEventArgs) =>
    {
      if (loginEventArgs.Result)
       {
         /*Login succeeded*/
         this.DialogResult = true;
       }
       else
      {
         /*Login failed*/
      }
    }
    );
}
The LoginAsync method’s signature is:
  /// <summary>
/// Logs in the User and calls the LoginComplete handler
/// </summary>
/// <param name="userName">UserName to login </param>
/// <param name="passWord">password for the user account</param>
/// <param name="pLoginComplete">Called when the login process is complete</param>
public void LoginAsync(string userName, string passWord, Action<LoginCompletedEventArgs> pLoginComplete)

Once the user types in his/her username and password and hits “Login” , the Login window hits the WCF authentication service
and extracts the FormsAuth cookie from the response.When the client library makes a request to the Data Service , the FormsAuthenticationAdapter
injects the FormsAuth cookie

Common errors:

1. You receive an ArgumentException when trying to set the cookie header in the SendingRequest event.

a. System.ArgumentException occurred
Message="The 'Cookie' header cannot be modified directly.\r\nParameter name: name"
StackTrace:
at System.Net.WebHeaderCollection.ThrowOnRestrictedHeader(String name, String value)
InnerException:

Resolution: The reason you get this is because the client library is using the classic networking stack (based on XmlHttpRequest)
to make the request. In this case, the Cookie header isn’t accessible and the above exception is valid.
This is probably the only case where we would ask you to set the HttpStack property on the Client library.
To fix this:
//Set the HttpStack on the client Context instance to force the client library

//to use the ClientHttpWebRequest stack for network access
publicationContext.HttpStack = HttpStack.ClientHttp;

Additional resources:

How do I authenticate my users against the Active Directory from my Silverlight application?
In ASP.NET Forms Authentication, the Membership provider is responsible for accessing the Credential store and validating the user name and password.
By setting the Membership provider to be the ActiveDirectoryMembershipProvider , you can authenticate the user name and password the user enters
with the credentials stored in Active Directory. For more details , please refer to this MSDN article :

Using the ActiveDirectoryMembershipProvider
References :

About ClientAccessPolicy.xml files
ASP.NET Application Services.
ASP.NET Forms Authentication
Membership Providers

Using the PHP Toolkit with ADO.NET Data Services

PhaniRajuYN — Wed, 09 Sep 2009 01:17:00 GMT

Setup PHP on your windows machine
Setup the PHP Toolkit
Setting up the PHP samples on IIS
Running the sample ADO.NET Data Services
PHP Sample Applications Walkthrough

Setup PHP on your windows machine

The following steps show you how to setup your windows machine to host PHP applications.
We will be talking about hosting the only supported ( by MS Support ) PHP CGI application on IIS .

Using FastCGI to Host PHP Applications on IIS 7.0

If you don’t find the php.ini-recommended file , then rename the php.ini-development file from your PHP folder.
Once you are setup , if you get a HTTP 500 internal server error when browsing to the Php.ini file ,
then you need setup your timezone in the PHP.ini file .
To do this , find the line in the php.ini file “date.timezone” .
If it has a semi-colon before it , remove it .
Set the date.timezone’s value to be a valid value from this list : List of Supported Timezones

In my php.ini , I have set the value to be date.timezone = "America/Los_Angeles"

Setup the PHP Toolkit

Follow the instructions on the codeplex site to setup your machine.
Installation and Configuration

Setting up the PHP samples on IIS

I have copied the phpsamples folder from the downloaded phpdataservices1.0 folder
into the %SystemDrive%\inetpub\wwwroot folder.This is just so that I dont need to configure any permissions
for the IIS accounts.
Open the IIS manager by running “INETMGR” from the “run” prompt on the start menu

Select the PHPSamples folder from the “Default Web Site”

Right-Click the Virtual directory and select “Convert to Application”

Confirm creating the virtual directory by pressing “OK” in the next dialog that turns up

This sets up the PHP applications that access the ADO.NET Data Service,
We still need to setup the actual Data Services that the PHP Samples access.

Running the sample ADO.NET Data Services

Find the ADODotNetDataServices folder in the PHPDataServices1.0 download.
This should be under the “samples” directory.
i.e PHPDataServices1.0\samples\ADODotNetDataServices

Setup the Databases required for the project to run

1) Unzip the zipped database files from the

PHPDataServices1.0\samples\ADODotNetDataServices\data folder.
2) Open up SQL management studio and Connect to your Database server
3) Right–click the databases node and select “Attach…”

4) In the “Attach Database” dialog , press “Add” and select the unzipped “VideoGameStore_Data.mdf” file.
You will notice that once you select the MDF file , the dialog will complain about a missing .ldf file.
5) This is a routine warning , select the ldf file row in the dialog and press “Remove”

For the other database Northwind, you can use the sample database that are available from Download.Microsoft.com
Here’s a link to download the Northwind sample database : Northwind and pubs Sample Databases for SQL Server 2000
Installation should be straight-forward as it comes with an MSI that is supposed to setup the database for you.

Disclaimer : I already had a copy of the Northwind database on my machine and didn’t use the installer above.

Once you have your databases setup , modify the respective connection strings web.config file from the ADODotNetDataServices project.

<connectionStrings>
    <add name="NorthwindEntities" 
         connectionString="metadata=res://*/NorthwindModel.csdl|res://*/NorthwindModel.ssdl|res://*/NorthwindModel.msl;
                           provider=System.Data.SqlClient;
                           provider connection string=&quot;YOURCONNECTIONSTRINGHERE&quot;" 
         providerName="System.Data.EntityClient" />
    <add name="VideoGameStoreEntities" 
         connectionString="metadata=res://*/VideoGameStoreModel.csdl|res://*/VideoGameStoreModel.ssdl|res://*/VideoGameStoreModel.msl;
                           provider=System.Data.SqlClient;
                           provider connection string=&quot;YOURCONNECTIONSTRINGHERE&quot;" 
         providerName="System.Data.EntityClient" />
</connectionStrings>

Once you have the database and the Data Service setup, then configure the project to only run on the URL that the PHP Samples expect to find the Data Service on.
To do this :
In Visual Studio,Go to the properties of the Project.
Click on the “Web” Tab in the left-hand pane.
Under the “Servers” section , Select the “Specific Port” option and enter “8080” for the port number.
Now, run the project in Visual studio and launch the PHP samples by browsing to the Index.php page
in the PHPSamples virtual directory.

PHP Sample Applications Walkthrough

You should see this as the startup page when you run the PHP Samples

Demo tab contents

Select the ADO.NET Data Services Editor Sample to see some pure PHP awesomeness

Here’s an editor page for the Customers Entity Set:

See that little text box over there ?
Yeah , it allows me to enter the Astoria URI operators like top , skip , filter to filter the rows bound to the grid below.
The gird is editable too , Clicking on the “Detail” link in the first column of the grid brings up an editor for the customers
entity that was selected.

So , there you have it , instructions to setup the samples and some tours of the sample applications.
Since I know next to nothing about PHP , I have a few questions for our PHP-Savvy users.

Which application framework(s) do you use to build PHP applications? I know about CAKE and ZEND , any others?
Do you use a specific Validation framework or do you use the one that came with the application framework?

Silverlight toolkit with ADO.NET Data services , Drill-down Charts using Astoria

PhaniRajuYN — Thu, 11 Jun 2009 10:12:51 GMT

Download sample project here :

In part 2 of this series , we will look at using the Astoria client library to create a drill down chart using the chart types available in the Silverlight toolkit.
You can take a look at the complete samples for the Silverlight toolkit here.

This sample builds a UI that looks like this :

The Pie chart represents the distribution of Employees across departments.
Clicking on a specific piece of the pie brings up the list of the employees in that department.

Binding the Pie chart
The Chart control has a Pie series that has the DependentValuePath set to the Count of employees in the department
and the IndependentValuePath set to the name of the department.

Setting the IndependentValuePath is straightforward ,set the IndependentValuePath to the “DepartMentName” property of the Department entity type. The DependentValuePath is a little tricky , as the Department entity doesnt contain aggregation information regarding the employees in the Department . But , it does have the employees as an ObservableCollection of Employee types . So , we can get the count by assigning the DependentValuePath to be the expression “Employees.Count” which gets the Count property of the IList. Unfortunately , this means that the Employees will also have to be downloaded when you bind the Departments. In another post , I will discuss how to lazy load the employees list and still get this aggregation.

XAML for Pie Series in Chart

  <chartingToolkit:Chart x:Name="chEmployeesByDepartment" 
       Title="# Employees/Department" IsEnabled="true" Height="300">
      <chartingToolkit:Chart.Series>
         <chartingToolkit:PieSeries    
                x:Name="lnSeries"
                IndependentValuePath ="DepartMentName"
                DependentValuePath ="Employees.Count"
                SelectionChanged="DepartmentSelected"
                IsSelectionEnabled ="True" >
         </chartingToolkit:PieSeries>
      </chartingToolkit:Chart.Series>
  </chartingToolkit:Chart>

The function to bind the Pie series with the Department information

 private void LoadDepartmentsAndEmployees() {
    DataServiceQuery<Department> deptQueryWithEmployees = context.Departments.Expand("Employees") 
                                 as DataServiceQuery<Department>;
    deptQueryWithEmployees.QueryAndCall(
       (deparmentStatistics) =>  {
          Dispatcher.BeginInvoke(
           () =>  { 
                PieSeries series = chEmployeesByDepartment.Series[0] as PieSeries;
                series.ItemsSource = deparmentStatistics;
               }    
            );       
         }); }

Populating employee information when a department is selected in the Pie Series
We need to setup the Pie Series in the chart control to allow selection of chart points and hook into the
SelectionChanged event of the Pie Series. We do this by:

Setting IsSelectionEnabled to true on the Pie Series
Hooking up to the SelectionChanged event of the Pie Series

        private void DepartmentSelected(object sender, SelectionChangedEventArgs e) {  
            //Get the series that caused this  event to be raised
            PieSeries series = sender as PieSeries;
            //Get the current selected department in the Series
            Department selectedDepartment = series.SelectedItem as Department;
            if (selectedDepartment != null) { 
                //Set the title of the data grid
                lblSelectedDepartment.Text = String.Format(strSelectedDepartmentMessage, selectedDepartment.DepartMentName);
                //Bind the employee grid with the employees for this department
                dgEmployees.ItemsSource = selectedDepartment.Employees;
            }  
        }

Download sample project here :

ADO.NET Data Services Friendly Feeds , Mapping EDM Types - I

PhaniRajuYN — Sun, 29 Mar 2009 00:32:00 GMT

As I mentioned in my last blog post , here are some samples of how to map your entity properties to Atom/custom markup in the atom:entry element.
You can apply Friendly Feed mappings on the EDM entity types by adding attributes to the CSDL of the Entity Data Model .
We will focus on the kinds of mappings and how to achieve them .

Pre-requisites

1. To edit the CSDL , you will need to open the EDM model in Xml view .To do this , right-click the EDM model (.EDMX file ) in Visual Studio
and select “Open with”->”Xml Editor” .
2. Add a reference to this namespace in the <edmx:ConceptualModels> node of the CSDL section in the EDMX file :
ex: xmlns:m2="http://schemas.microsoft.com/ado/2007/08/dataservices/metadata"

1) Mapping to ATOM elements in the atom:entry payload :
The EntityPropertyMapping (EPM) attribute has two constructors , one which binds the property to an Atom element in the feed ,
and another which binds the property to a custom element . We shall discuss the former in this section.

For ATOM Mappings , the EPM markup has the following attributes .

m2:FC_SourcePath: The m2:FC_SourcePath is used when
a) The Property you are mapping exists in a base type and not on the current type .
b) The property you are mapping exists in a complex type and not on the current type .
m2:FC_TargetPath : The atom:entry element to which this property has to be mapped to
m2:FC_ContentKind: The content-type of the mapped atom:entry element
m2:FC_KeepInContent : set this to false if you want the entity’s property value to turn up only in the mapped atom:entry element and not in the <contents> section.

Lets proceed , using the same BlogPost type that we discussed last time .
This is the EDM Markup for the type :

<EntityType Name="BlogPost">
  <Key>
    <PropertyRef Name="BlogPostID" />
  </Key>
  <Property Name="Lat" Type="Edm.Double" Nullable="false"/>
  <Property Name="Long" Type="Edm.Double" Nullable="false"/>
  <Property Name="Published" Type="Edm.DateTime" Nullable="false" />
  <Property Name="BlogPostID" Type="Edm.Int32" Nullable="false" />
  <Property Name="Title" Type="Edm.String" Nullable="true"/>
  <Property Name="Body" Type="Edm.String" Nullable="true" />
  <Property Name="Author" Type="Edm.String" Nullable="true"/>
  <Property Name="PostURI" Type="Edm.String" Nullable="true" />
  <Property Name="ContentSummary" Type="Edm.String" Nullable="true" />
  <Property Name="IconUri" Type="Edm.String" Nullable="true"/>
</EntityType>

1. Map the “Title” property of the BlogPost Entity type to the entry:title element

When decorating EDM types , the markup specifying the mapping goes on the property you are mapping ,
ex:

<Property Name="Title" Type="Edm.String" Nullable="true"
  m2:FC_TargetPath="SyndicationTitle"
  m2:FC_EpmContentKind="Plaintext"
  m2:FC_EpmKeepInContent="true" />

2. Map the “Author” property to entry:author element

This is what the markup would look like :

<Property Name="Author" Type="Edm.String" Nullable="true"
           m2:FC_TargetPath="SyndicationAuthorName"
           m2:FC_ContentKind="Plaintext"
           m2:FC_KeepInContent="true" />

As described in my previous blog post , you can map an Entity’s properties to the following atom:entry elements in the payload :

atom:entry Element	m2:FC_TargetPath
entry:author/email	SyndicationAuthorEmail
entry:author/name	SyndicationAuthorName
entry:author/uri	SyndicationAuthorUri
entry:published	SyndicationPublished
entry:rights	SyndicationRights
entry:summary	SyndicationRights
entry:title	SyndicationTitle

Content-Kind	m2:FC_ContentKind
Plaintext	Plaintext
Html	Html
Xhtml	XHtml
Default if not specified.	PlainText

2) Mapping to non-ATOM/custom elements in the atom:entry payload :

For non-ATOM/custom Mappings , the EPM markup requires the following attributes.

m2:FC_SourcePath : The property of the Entity Type whose value should be mapped
m2:FC_TargetPath : The xml path markup which describes the path to the custom markup this property should be mapped to .
m2:FC_NsPrefix : The xml prefix for the custom element/attribute that this property is mapped to.
m2:FC_NsUri : The xml namespace to which the custom element/attribute that this property is mapped should be under.
m2:FC_KeepInContent : set this to false if you want the entity’s property value to turn up only in the mapped atom:entry element and not in the <contents> section.

The Xml Path syntax for custom mappings.

this syntax is very logical and looks like the following .
Lets say that you wanted to map a property to a custom element in markup that looks like this :

<mycustomRoot xmlns=”http://www.mycustomFormat.org”>
  <customElement>property value goes here</customElement>
</mycustomRoot>

for this example ,
m2:FC_TargetPath would be “mycustomRoot/customElement”
m2:FC_NsPrefix would be an empty string as this markup has no custom prefix.
m2:FC_NsUri would be “http://www.mycustomFormat.org”
m2:FC_KeepInContent is subjective to whether you want to keep the property value in the <content> section or not.

and now , lets say that you wanted to map a property to a custom attribute of an element in markup that looks like this :

<me:mycustomRoot xmlns:me="http://www.georss.org.georss">
  <me:customElement customAttribute="property value goes here"></me:customElement>
</me:mycustomRoot>

for this example ,
m2:FC_TargetPath would be “mycustomRoot/customElement/@customAttribute”
m2:FC_NsPrefix would be “me”.
m2:FC_NsUri would be “http://www.mycustomFormat.org”
m2:FC_KeepContent is subjective to whether you want to keep the property value in the <content> section or not.

A note , the complexity of your custom markup has a direct effect on the performance costs for Serialization/De-Serialization of the entity type .
with this example , lets map the lat & long properties to geoRss markup ,which looks like this :

<geo:lat xmlns:geo="http://www.georss.org/georss">47.684</geo:lat>
<geo:long xmlns:geo="http://www.georss.org/georss">-122.122</geo:long>

Final type definition looks like this :

<EntityType Name="BlogPost">
  <Key>
    <PropertyRef Name="BlogPostID" />
  </Key>
  <!-- map the Lat property to the <geo:lat> element  -->
  <Property Name="Lat" Type="Edm.Double" Nullable="false"
            m2:FC_TargetPath="lat"
            m2:FC_NsUri="http://www.georss.org/georss"
            m2:FC_NsPrefix="geo"
            m2:FC_KeepContent="true" />
  <!-- map the Long property to the <geo:long> element  -->
  <Property Name="Long" Type="Edm.Double" Nullable="false"
            m2:FC_TargetPath="long"
            m2:FC_NsUri="http://www.georss.org/georss"
            m2:FC_NsPrefix="geo"
            m2:FC_KeepContent="true" />
  <!-- Map the “Title” property  of the BlogPost Entity type to the entry:title element -->
  <Property Name="Title" Type="Edm.String" Nullable="true"
            m2:FC_TargetPath="EpmSyndicationTitle"
            m2:FC_ContentKind="EpmPlaintext"
            m2:FC_KeepContent="true" />
  <Property Name="Body" Type="Edm.String" Nullable="true" />
  <!-- Map the “Author” property to entry:author element  -->
  <Property Name="Author" Type="Edm.String" Nullable="true"
            m2:FC_TargetPath="EpmSyndicationAuthorName"
            m2:FC_ContentKind="EpmPlaintext"
            m2:FC_KeepContent="true" />
  <Property Name="BlogPostID" Type="Edm.Int32" Nullable="false" />
  <Property Name="Published" Type="Edm.DateTime" Nullable="false" />
  <Property Name="PostURI" Type="Edm.String" Nullable="true" />
  <Property Name="ContentSummary" Type="Edm.String" Nullable="true" />
  <Property Name="IconUri" Type="Edm.String" Nullable="true"/>
</EntityType>

Special cases

I . Complex type properties

[I’ll leave the type definitions as CLR types so that its easier to visualize the relations.]

Consider the following model ,

public class Address
    {
        public long DoorNumber { get; set; }
        public string Street { get; set; }
        public int ZipCode { get; set; }
    }
    [DataServiceKey("CustomerID")]
    public class Customer
    {
        public int CustomerID { get; set; }
        public Address myAddress { get; set; }
    }

and lets say that you wanted to map the property Street of the complex type Address when accessed through the
entity type “Customer” to the atom:title element ,

this can be achieved via setting the EpmSourcePath property to “Street” .
In this case , the Epm markup would look like this :

<EntityType Name="Customer">
  <!-- Map the Street property of the Address complex type to the entry:title element -->
  <Property Name="myAddress" Type="MyModelNamespace.Address"
            me:EpmSourcePath="Street"
            m2:FC_Atom="true"
            m2:FC_TargetPath="EpmSyndicationTitle"
            m2:FC_ContentKind="EpmPlaintext"
            m2:FC_KeepContent="true"/>
  <!-- other properties removed for brevity-->
</EntityType>

II Mapping properties declared on base type

Consider this data model :

[DataServiceKey("CustomerID")]
public class Customer
{
        public int CustomerID { get; set; }
        public Address myAddress { get; set; }
        public string BaseTypeField { get; set; }
}

public class DerivedCustomer : Customer
{
  public string DerivedTypeField { get; set; }
}

and you want to map a property declared on the Base type “Customer” on the derived type “DerivedCustomer”
The EPM Markup would look like this :

<!-- Map the "BaseTypeField" property of the base type "Customer" to the entry:title element -->
<EntityType Name="DerivedCustomer" BaseType="MyModelNamespace.Customer"
            m2:FC_SourcePath="BaseTypeField"
            m2:FC_TargetPath="EpmSyndicationAuthorName"
            m2:FC_ContentKind="EpmPlaintext"
            m2:FC_KeepContent="true">
  <!-- other properties removed for brevity-->
</EntityType>

Considerations for location of EPM markup in EDM Schema

Use the following guidelines to decide where in the EDM Schema you should add the attribute for either ATOM or custom Mappings,

Where is property defined ?	Where do I apply the EPM attribute?	SourcePath
Simple property on the Entity Type ex: “Title” property of “BlogPost” type above	<Property> node in the <Entitytype> markup	Not required
Simple property on entity’s base type	<EntityType> node	Base type property name
Complex Property on the Entity Type	Complex Types cannot be mapped directly	N/A
Simple property defined on complex type which is a property on an Entity Type	<Property> node in the <EntityType>	Complex type’s simple property name

Hope you enjoyed this post about applying Friendly Feeds mappings to EDMdata models.
The second part of this post will discuss more special cases in EDM Models and troubleshooting failing mappings
and also a sample project for EDM Friendly Feeds Mappings.

Versioning note , writing SL 3.0 applications with Astoria v1.5 Sl 2.0 SDK Library

PhaniRajuYN — Wed, 25 Mar 2009 05:30:00 GMT

As part of the v1.5 install, we also shipped a Silverlight 2.0 SDK library that is capable of talking to a v1.5 Astoria Service.

Did you know that you could use the Silverlight 2.0 client library we shipped as part of our v1.5 CTP1 release in Silverlight 3.0 applications?

From a Silverlight SDK library point of view ,to use Mike Flasko’s words, ”we are nothing but user code”.
We have no dependencies on the Runtime that have changed in SL 3.0 , yet.
So , you can use the Silverlight 2.0 SDK library that we shipped in v1.5 CTP1 , by
replacing the reference to “System.Data.Services.Client.dll” with “Microsoft.Data.Services.Client.dll”

In your Silverlight project ,

1. If you already have a reference to “System.Data.Services.Client.dll” in your SIlverlight application , remove it .

2. If you have the v1.5 CTP1 installed , the Silverlight client binaries are stored in the following location ,
%ProgramFiles%\ADO.NET Data Services V1.5 CTP1\sl_bin

3. Bring up the “Add Reference” window by right clicking the “References” node for the Silverlight 3.0 Project in Visual Studio.

4. Use the “Browse” tab of the “Add Reference” window to browse to this location to add a reference to “Microsoft.Data.Services.Client.dll”.

5. Rebuild and run the app .

What about Code-gen ,
Can I point the Silverlight 3.0 application at a v1.5 CTP1 service and get all the binding & Friendly Feeds mappings generated in the Client types?

No , there is no integration for v1.5 codegeneration tools in Visual Studio for Sl 3.0 Projects .
You will have to use the DataSvcUtil.exe tool from the following directory manually to generate the types with binding information for SL 3.0 projects .

Location for DataSvcUtil.exe : %ProgramFiles%\ADO.NET Data Services V1.5 CTP1\bin

From a runtime perspective , is there any functionality in the v1.5 SL 2.0 library that is not present when the dll is inside a xap built with SL 3.0 tools ?

No , none , everything should just work . If something doesn’t work , please leave a comment on this post or write to me at PhaniRaj At Microsoft Dot Com.

What about Silverlight 3 Out-Of-Browser applications ?

The Astoria Silverlight client library doesn’t yet work with Out of the Browser Silverlight applications.

ADO.NET Data Services Silverlight Project Error : System.IO.FileNotFoundException

PhaniRajuYN — Tue, 24 Mar 2009 05:09:18 GMT

Imagine this , you just downloaded the Astoria V1.5 CTP1 and are happily chugging along and decide to make a Silverlight Project
that uses the latest Silverlight client library to make some cool app.
You open an existing Silverlight app /create a new Silverlight app ,
and generate the client types by running “Add Service Reference” from Visual Studio.
and write some code in the app and hit F5 to run the app .
Now , Instead of seeing the poetic beauty that is a Silverlight app built with Astoria , you see this :

The Exception message is :

System.IO.FileNotFoundException occurred
Message="Could not load file or assembly 'Microsoft.Data.Services.Client, Version=2.0.5.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a' or one of its dependencies.
           The system cannot find the file specified."
StackTrace:
       at SilverlightProject1.Page..ctor()
       at SilverlightProject1.App.Application_Startup(Object sender, StartupEventArgs e)
InnerException:

What just happened ?

When the tools which generate the client code for an Astoria Service for Silverlight applications ran , they added a reference to the new client dll,
Microsoft.Data.Services.Client.dll with “Copy Local” set to false.

If your code looks like this,

public Page(){
InitializeComponent();
nwServiceReference.BlogServiceProvider prov =
                new SilverlightProject1.nwServiceReference.BlogServiceProvider(new Uri("http://ServiceEndPoint"));
}

When the JIT compiler compiles your Page() constructor method, it scans the method, sees that it references a type named BlogServiceProvider , and attempts to load Microsoft.Data.Services.Client.dll so that the reference can be resolved.
Now , Since we set Copy Local to false , the Client DLL is not copied into the XAP file ,and the Silverlight CLR cannot find the file , it throws the above exception.
We can verify by opening the xap file in winrar or some other archiving utility.

Resolution :

In your Silverlight project, for the reference to “'Microsoft.Data.Services.Client.dll” , Set “Copy Local” to “True” and rebuild your Silverlight XAP.

What about “Update Service Reference”?
Same issue , follow same resolution.

When will this be fixed?
We are tracking this issue and will release a fix in a future release of ADO.NET Data Services v1.5

Batching Queries using the ADO.NET Data Services CLient library

PhaniRajuYN — Mon, 16 Mar 2009 00:50:00 GMT

Did you know you could execute batch queries using the Data Services client library ?

The API is ExecuteBatch for Synchronous access and Begin/End ExecuteBatch for asynchronous scenarios.

1) Batching a set of URI Queries .

The ExecuteBatch API accepts an array of DataServiceRequest objects.
Consider this example , you want to batch queries to be sent to the “Products” and “Categories” entity sets of a northwind service.

2) Batching Linq Queries

If you want to use strongly types Linq queries instead of string based URI queries , you can use the linq support to generate the linq query

3) How do I Identify the response if I make duplicate requests with the same ElementType ?

Consider this situation , You make 2 requests both of type DataServiceRequest<Products> , how do you identify
which response is for which request ?

One of the scenarios I can think of , is that the entity set contains multiple types related via inheritance .

ex: Customers entity set contains instances of types HappyCustomers and HappierCustomers inheriting from Customers.

The QueryOperationResponse type contains a Query property which returns the DataServiceRequest that this response corresponds to .

You can pass along the requests you made in the batch as a state to the callback and then compare the Query property of the QueryOperationResponse
to match the response to the request.

ex:

Working with Inheritance in Ado.net Data Services

PhaniRajuYN — Wed, 24 Dec 2008 01:05:18 GMT

I’ve seen this question quite often on the Astoria forums and wanted to write something down so that our users can gain from the discussions that go on in our forums.
We will discuss how one deals with entities ( tables / records / resources ) that participate in an inheritance hierarchy.
We shall take the following Data Model to discuss some key scenarios involving the Client Library.

//Base Class
[DataServiceKey("PersonID")]
public class Person {
        public int PersonID { get; set; }
        public string Name { get; set; }
    }

//Derived Class
public class Employee : Person {
        public int EmployeeID { get; set; }
}

And you expose an IQueryable<Person> from your data source,

public class InheritedProvider {
        static List<Person> _people;
        private static void Initialize()  {
            _people = new List<Person>(){
                new Person  {
                    PersonID =1,
                    Name="Phani"
                },
                new Employee {
                    PersonID =2,
                    EmployeeID =3,
                    Name ="Raj"
                }
            };
        }
        public IQueryable<Person> People {
            get {
                if (_people == null)
                    Initialize();
                return _people.AsQueryable<Person>();
            }
        }
    }

Browsing to the /People endpoint of the service gives you :

<?xml version="1.0" encoding="utf-8" standalone="yes" ?>
<feed …Namespace Declarations… >
<title type="text">People</title>
<id>http://localhost:13975/Inheritance.svc/People</id>
<updated>2008-12-23T20:56:47Z</updated>
<link rel="self" title="People" href="People" />
<entry>
<id>http://localhost:13975/Inheritance.svc/People(1)</id>
<title type="text" />
<updated>2008-12-23T20:56:47Z</updated>
<author>
<name />
</author>
<link rel="edit" title="Person" href="People(1)" />

<category term="Repro.Person" scheme="http://schemas.microsoft.com/ado/2007/08/dataservices/scheme" />

<content type="application/xml">
<m:properties>
<d:PersonID m:type="Edm.Int32">1</d:PersonID>
<d:Name>Phani</d:Name>
</m:properties>
</content>
</entry>
<entry>
<id>http://localhost:13975/Inheritance.svc/People(2)</id>
<title type="text" />
<updated>2008-12-23T20:56:47Z</updated>
<author>
<name />
</author>
<link rel="edit" title="Person" href="People(2)" />

<category term="Repro.Employee" scheme="http://schemas.microsoft.com/ado/2007/08/dataservices/scheme" />

As you can see , the <Category> element of an <entry> element represents the Entity Type that this <entry> represents.

How does this help one with working with against an Entity Set using Inheritance ?

Consider the following snippet of Client Code :

DataServiceContext dsc = new DataServiceContext(new Uri("URI_TO_DATASERVICE"));
Employee newEmployee = new Employee() {Name = "Peter Qian"};
dsc.AddObject("People", newEmployee);
dsc.SaveChanges();

Can you guess what is wrong with this ?

Yep, since the client library sees that you are trying to insert a Person Entity , we put the Entity Type as “Person”
in the payload , i.e , the above operation results in the payload :

<entry xmlns:d=http://schemas.microsoft.com/ado/2007/08/dataservices 
       xmlns:m=http://schemas.microsoft.com/ado/2007/08/dataservices/metadata 
       xmlns="http://www.w3.org/2005/Atom">
<updated>2008-12-23T21:23:38.5935141Z</updated>
<content type="application/xml">
   <m:properties>
     <d:EmployeeID m:type="Edm.Int32">0</d:EmployeeID>
     <d:Name>Peter Qian</d:Name>
     <d:PersonID m:type="Edm.Int32">0</d:PersonID>
   </m:properties>
</content>
</entry>

And this causes the Server to respond with :

<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<error xmlns="http://schemas.microsoft.com/ado/2007/08/dataservices/metadata">
  <code></code>
  <message xml:lang="en-US">Error processing request stream. 
    Type information must be specified for types that take part in inheritance.</message>
</error>

This error is because , as you can see in the request payload , the <category> element which specifies the Entity Type is missing form the Request Payload.
Since the Client library doesn’t resolve the Names/Types of the Entities for you , it provides you hooks to customize the name/type resolution
so that the right entity type is specified in the payloads.

Why can’t the Client library do this automatically ?

Main reason , Since we allow POCO , the type hierarchy of entities on the client can be different compared to the server.

In your client code , set the ResolveName and ResolveType Properties on the DataServiceContext instance to
override the default type resolution behavior.

ex :

DataServiceContext dsc = new DataServiceContext(new Uri("URI_TO_DATASERVICE"));
dsc.ResolveName = delegate(Type entityType) {
     return entityType.FullName.Replace("<ClientNamespace>", "<ServerNamespace>");
};
dsc.ResolveType = delegate(string entitySetName) {
      return Type.GetType(entitySetName);
};
Employee newEmployee = new Employee() {Name = "Peter Qian"};
dsc.AddObject("People", newEmployee);
dsc.SaveChanges();

Since we provide the right Entity Type Name in the ResolveName property , the right Entity Type
is placed in the payload.

<entry xmlns:d="http://schemas.microsoft.com/ado/2007/08/dataservices"            
       xmlns:m=http://schemas.microsoft.com/ado/2007/08/dataservices/metadata
       xmlns="http://www.w3.org/2005/Atom">
<category scheme="http://schemas.microsoft.com/ado/2007/08/dataservices/scheme" term="ServerNamespace.Employee" />
<updated>2008-12-23T21:52:44.8021175Z</updated>
<content type="application/xml">
    <m:properties>
      <d:EmployeeID m:type="Edm.Int32">0</d:EmployeeID>
      <d:Name>Peter Qian</d:Name>
      <d:PersonID m:type="Edm.Int32">0</d:PersonID>
    </m:properties>
  </content>
</entry>

Hope this helps .

Customizing Serialization of Entities in the ADO.NET Data Services Client Library

PhaniRajuYN — Fri, 12 Dec 2008 02:06:00 GMT

This post is inspired by this forum thread :Data services client -- exception on saveChanges

Problem Statement

I have added some custom proeprties to the Entity Types Generated by DataSvcUtil.exe /Add Service Reference / Hand Coded ,
these properties do not exist on the server and should not be sent to the server .
When I try to save an object of a Type which has custom client-Side only properties to the Data Service using AddObject and SaveChanges,
I get the following error :

Error processing request stream. The property name '{PropertyName}' specified for type '{TypeName} is not valid

This error is basically from the server telling the client library that its sending a payload which does not seem to match the definition
of the Entity Type on the server.

We can solve this problem by customizing the Payload that the client generates when it sends the entity to the server.
The DataServiceContext exposes an event called WritingEntity that is fired right before we send the payload over the wire.

Its argumentlist contains ReadingWritingEntityEventArgs which gives you access to the Entity Instance being Serialized ( e.Entity )
and the ATOM Payload (e.Data ) we are about to send to the Server.

Removing a property from the ATOM Payload that is being sent to the server.

void dataContext_WritingEntity(object sender, ReadingWritingEntityEventArgs e) {

    // e.Data gives you the XElement for the Serialization of the Entity 
    //Using XLinq  , you can  add/Remove properties to the element Payload  
    XName xnEntityProperties = XName.Get("properties", e.Data.GetNamespaceOfPrefix("m").NamespaceName);
    XElement xePayload = e.Data.Descendants().Where<XElement>(xe => xe.Name == xnEntityProperties).First<XElement>();
   //The XName of the property we are going to remove from the payload
    XName xnProperty = XName.Get(“{PropertyName}”, e.Data.GetNamespaceOfPrefix("d").NamespaceName);

    //Get the Property of the entity  you don't want sent to the server
    XElement xeRemoveThisProperty = xePayload.Descendants().Where<XElement>(xe => xe.Name == xnProperty).First<XElement>();
    //Remove this property from the Payload sent to the server 
     xeRemoveThisProperty.Remove();

     }
}

Generalizing this further , we want to make it easier to customize the serialization of multiple entity types without having to write
multiple copies of the WritingEntity event handler.
We will add an attribute that specfies that a certain CLR property should not be serialized in the ATOM Payload when the client library
sends the entity to the server.

    /// <summary>
    /// Properties marked with this Attribute are not serialized in the payload when sent to the server
    /// </summary>
    [AttributeUsage(AttributeTargets.Property)]
    public class DoNotSerializeAttribute : Attribute
    {
    }

Now , we change the WritingEntity Event handler to remove any property that has this attribute on it .

        void DataServiceContextEx_WritingEntity(object sender, ReadingWritingEntityEventArgs e)
        {
            // e.Data gives you the XElement for the Serialization of the Entity 
            //Using XLinq  , you can  add/Remove properties to the element Payload  
            XName xnEntityProperties = XName.Get("properties", e.Data.GetNamespaceOfPrefix("m").NamespaceName);
            XElement xePayload = null;
            foreach (PropertyInfo property in e.Entity.GetType().GetProperties())
            {
                object[] doNotSerializeAttributes = property.GetCustomAttributes(typeof(DoNotSerializeAttribute), false);
                if (doNotSerializeAttributes.Length > 0)
                {
                    if (xePayload == null)
                    {
                        xePayload = e.Data.Descendants().Where<XElement>(xe => xe.Name == xnEntityProperties).First<XElement>();
                    }
                    //The XName of the property we are going to remove from the payload
                    XName xnProperty = XName.Get(property.Name, e.Data.GetNamespaceOfPrefix("d").NamespaceName);
                    //Get the Property of the entity  you don't want sent to the server
                    XElement xeRemoveThisProperty = xePayload.Descendants().Where<XElement>(xe => xe.Name == xnProperty).First<XElement>();
                    //Remove this property from the Payload sent to the server 
                    xeRemoveThisProperty.Remove();
                }
            }
        }

We can encapsulate this functionality into its own class and any DataServiceContext type that inherits from this class should be able to
inherit this functionality too .
Complete Source Code :

Using this in your applications :

Create a partial class with the same name as shown above and include it in your application to get this behavior.

Attribute your types with the DoNotSerializeAttribute attribute so that this property is not serialized.

 public class TestType
    {
        public int ID { get; set; }
        /// <summary>
        /// This Property is client-only , should not be sent to the server
        /// </summary>
        [DoNotSerialize]
        public string ClientOnlyProperty { get; set; }
    }

Working with associations in ADO.NET Data Services , Part 2

PhaniRajuYN — Fri, 24 Oct 2008 00:01:46 GMT

In part 2 ,we will talk about how to use the client library to deal with :

1..N Associations

This is the case of entities associated with each other 1..N . An example from Northwind is the relation between Categories and Products Entities.

An instance of the Categories entity type should have associated Products entities, this is another way of saying “ A row in the Products table should have links to a row in the Categories table”.
In case of 1..N relations , the left( child ) ends of the association are expressed as Collection properties on the right ( parent ) end of the relation.
This is shown in the metadata of the service as :

<EntityType Name="Categories">
<!-- Primary Key-->
<Key>
  <PropertyRef Name="CategoryID" /> 
</Key>
 <!--Primitive Properties-->
  <Property Name="CategoryID" Type="Edm.Int32" Nullable="false" /> 
  <Property Name="CategoryName" Type="Edm.String" Nullable="false" /> 
  <Property Name="Description" Type="Edm.String" Nullable="true" /> 
  <Property Name="Picture" Type="Edm.Binary" Nullable="true" /> 
 <!-- Child Entity Set-->
  <NavigationProperty 
        Name="Products" 
        Relationship="northwind.FK_Products_Categories" 
        FromRole="Categories" 
        ToRole="Products" /> 
</EntityType>

This leads the client utility( DataSvcUtil.exe ) to generate a type Individual which has instances of types Customer and Contact as Properties.

The generated class on the client looks like this :

public class Categories {
  public global::System.Collections.ObjectModel.Collection<Products> Products {
            get {
                return this._Products;
            }
            set {
                if ((value != null))
                {
                    this._Products = value;
                }
            }
        }
}

Now that we have set the stage, lets look at how one would use the client library to interact with the related types.

Creating the link between the entities

You have new instances of Individual , Contact and Customer and you want to persist the new entities and their relation to the store.

DataServiceContext dsc = new DataServiceContext(new Uri("http://ServiceEndpoint"));
Categories freeProductsCategory = new Categories()
{
    CategoryName = "Free Products",
    Description = "These products are free",
};
Products freeHeadPhones = Products.CreateProducts(0, "Free Headphones", false);
Products freeZune = Products.CreateProducts(1, "Free Zune", false);

dsc.AddObject("Categories", freeProductsCategory);
dsc.AddObject("Products", freeHeadPhones);
dsc.AddObject("Products", freeZune);

Now what ?

Since the entities are created and added to the store can’t I just set the Customer and Contact Property to the Individual object and that will save the relation ?

freeProductsCategory.Products.Add(freeHeadPhones);
freeProductsCategory.Products.Add(freeZune);
dsc.SaveChanges();

Shouldn’t this be enough ?
Nope , that’s not enough to save the relation to the store.

Why ?

Remember that the client context only gives you POCO access to entities in the store and any new entities that you create.
The Client context does not track any relations unless you explicitly ask it to do so !

Neat , now how do I ask it to do that ?

You use the AddLink method defined on the context.

dsc.AddLink(freeProductsCategory, "Products", freeHeadPhones);
dsc.AddLink(freeProductsCategory, "Products", freeZune);

The signature and the intent of the SetLink method is lucid , it binds 2 entities into a relation , its kinda like a priest at a wedding,
This is what it looks like ..

AddLink ( Parentinstance ,”ChildPropertyName”,ChildInstance)

Deleting the parent entity

Deleting the parent entity means that the relations with the child entities are also removed.
Think of this as the argument of “How do I delete an entity that has 1..1 links with other entities?”

What happens if I delete the parent entity without deleting the links ?

It depends on your store . If your database is configured to do a cascade delete on deletion of the parent entity ,you might get away with deleting the entity without removing the links

The right way to delete the entity is to remove all the links it has with the child entities and then delete the entity itself.
The code would look like this..

DataServiceContext dsc = new DataServiceContext(new Uri("http://ServiceEndpoint"));
//Load an existing parent
Categories freeProductsCategory = dsc
                                  .CreateQuery<Categories>("Categories")
                                  .Where(cat => cat.CategoryName == "Free Products")
                                  .First();
//Load all the related child Entities
dsc.LoadProperty(freeProductsCategory, "Products");

//Delete the links with each of the child entities
foreach (Products freeProduct in freeProductsCategory.Products) {
    dsc.DeleteLink(freeProductsCategory, "Products", freeProduct);
}
//Delete the parent entity
dsc.DeleteObject(freeProductsCategory);
dsc.SaveChanges();

Wait !! what’s with the LoadProperty there ?
Well, if you need to delete the relation , the way to identify the relation or the link is to have both the right and the left end of the relations to be materialized. without the expand , the Contact and the Customer property are null , and we don’t know which relation to delete.In case of 1..1 relations it might be easy to predict based on the relation name ,
but wouldn’t be easy in case of 1..n relations.

Deleting the child entity

//Load an existing parent
Categories freeProductsCategory = dsc
                                   .CreateQuery<Categories>("Categories")
                                   .Where(cat => cat.CategoryName == "Free Products")
                                   .First();
//Load all the related child Entities
dsc.LoadProperty(freeProductsCategory, "Products");

//Delete the links with each of the child entities
foreach (Products freeProduct in freeProductsCategory.Products) {
    dsc.DeleteLink(freeProductsCategory, "Products", freeProduct);
    //Delete the child entity
    dsc.DeleteObject(freeProduct);
}
dsc.SaveChanges();

Special Consideration for Navigation properties that are named differently than the Entity Type

This is a special case because of a bug in the client library at the time of writing this post.
If you have a navigation property which is named differently than the EntityType and try to delete the link between the source
and the navigation property , we produce an invalid URI for the DELETE of the link.

ex:

Entity Type : Customers , EntitySet Name : Customers
Navigation Properties :
EntityType : Orders , Navigation Property Name : CashOrders
EntityType : Orders , Navigation Property Name : CreditCardOrders

Upon calling ,
dataContext.DeleteLink(customerInstance,”CashOrders”,orderInstance);

We generate a DELETE to the URI
/Customers(Key)/$links/Orders(Key)
This is wrong , the DELETE should go to :
/Customers(Key)/$links/CashOrders(Key)

We will address this issue in a future release .In the meantime , use the workaround below ,

public partial class YourDataContextClass {

    public void DeleteLinkManual(object source, string associationName, object target) {
            System.Uri UriOfParent;
            System.Uri UriOfChild;
            this.TryGetUri(source, out UriOfParent);
            this.TryGetUri(target, out UriOfChild);

            //Get the Segment of the URI with the Key 
            string strChildAssociationURI = UriOfChild.Segments.Last();
            strChildAssociationURI = strChildAssociationURI.Substring(strChildAssociationURI.IndexOf('('));

            //ServiceEndPoint/ParentEntitySet/$links/NavigationPropertyName(ChildEntitySetKey)
            string requestUriForLinkDelete = System.String.Format("{0}/{1}/$links/{2}{3}",
                                             this.BaseUri.OriginalString,
                                             UriOfParent.Segments.Last(),
                                             associationName,
                                             strChildAssociationURI);

            System.Net.WebRequest request = System.Net.WebRequest.Create(requestUriForLinkDelete);
            request.Method = "DELETE";
            System.Net.HttpWebResponse response = request.GetResponse() as System.Net.HttpWebResponse;
            if (response.StatusCode != System.Net.HttpStatusCode.NoContent)
            {
                throw (new System.Data.Services.Client.DataServiceClientException("Delete Failed"));
            }
            //Detach this link as the link no longer exists and keep the context consistent
            this.DetachLink(source, associationName, target);
      }
}

and then , in your code ,

YourDataContext dataContext = new YourDataContext(<Uri>);
dataContext.DeleteLinkManual(customerInstance,”CashOrders”,orderInstance);

This will produce the right URI :

ServiceEndPoint/Customers(Key)/$links/CashOrders(Key)

Note that this doesnt work in Silverlight , I will create a separate sample for Silverlight later .

If you have any questions , leave a comment . If you have any issues with code and need help , please post your query on the astoria forums as I can’t promise that I will be able to reply to emails sent to me directly .The whole team is very active on the forums and the more eyes on a problem the better.

Accessing Cross-Domain ADO.NET Data Services from the Silverlight Client Library

PhaniRajuYN — Tue, 21 Oct 2008 05:36:00 GMT

When we built the client library for Silverlight in Silverlight 2.0 , the underlying Network Stack provided by Silverlight core libraries
was very limited in terms of the Status Codes and Request Verbs that it supported.Our options were :
a) Use the System.Net libraries provided by the agClr and give a limited subset of the functionality available on the desktop.
b) Cook up our own Network stack and provide all the functionality provided on the desktop , in Silverlight.

We went with Option (b) and built a network stack that uses the browser’s underlying XmlHttpRequest object.
This means that the cross domain access available in Silverlight networking stack is not available in our networking stack.

Forums user Ben Hayat asked a question about the guidelines for Cross-Domain access using our Silverlight Client Library .

Now , this is not supported out of the box . But ,you can use the same solution as you would for an Ajax application ,
which is building a server-side proxy that talks to the remote service and is completely transparent to the client library.

Below is a sample Server-Side proxy that would help one talk to Data Services hosted on a different domain than the Silverlight application.

There are a couple of issues that a Server-Side proxy needs to solve for an ADO.NET Data Service ,
a) Appear totally transparent
b) Resolve Identities of resources to appear as they would from the Proxy service and not the original Data Service.

Issue a) is easy , Issue b) is a little more involved.

When the client library receives a Payload back as part of a query ,we construct the entity’s identity based on the following rules,
ex: If you browse to http://ServiceEndpoint/Northwind.svc/Customers('ALFKI') ,the response looks like this :

 <entry xml:base="http://ServiceEndpointNorthwind.svc/" 
       xmlns:d="http://schemas.microsoft.com/ado/2007/08/dataservices" 
       xmlns:m="http://schemas.microsoft.com/ado/2007/08/dataservices/metadata" 
       xmlns="http://www.w3.org/2005/Atom">
<link rel="edit" title="Customers" href="Customers('ALFKI')" /> 
<id>http://ServiceEndpointNorthwind.svc/Customers('ALFKI')</id> 
    <content type="application/xml">
    <m:properties>
     Properties go here 
    </m:properties>
    </content>
</entry>

When we get the above payload back as a response , we create a Customer object and its identity is the value of the <id> field in the payload.
When you make any edits to this Customer object, the edits are sent to the URI specified in the <link rel=”edit”> value of the payload.
Which means that the proxy server has to modify the payload it recieves from the real Data Service to make sure that all links , Id and Edit
point to the proxy Data Service and not the real Data Service. The easiest way to do this is to do a String.Replace replacing all occurrences of the
the original Service end point with the Proxy Service end point in the payload.

Without further stalling , here is the Proxy Handler.

A couple of words of caution so that I can keep my job,

This is only a sample implementation of what a proxy could look like.
Do NOT use this in your production applications.
This is NOT an official solution provided by the ADO.NET Data Services team ,
this is just me illustrating how to write a proxy.
If you download this sample , it means that you understand these rules .
For any problems with this sample , leave a comment on my blog ,
the ADO.NET Data Services Forums is NOT the right place for any issues with this proxy.

Running the sample

Download the sources from the link above.
Open the solution in Visual Studio 2008 and hit F5.
You should see the Silverlight application come up and
get the data from the Data Service hosted in a different application.

The Cross Domain Proxy is a generic AShx handler which receives the requests from the Client library and forwards them onto the
original Data Service , gets the response , changes the ID and Edit Links and returns the response to the Silverlight Client .

Client Sends request to Proxy Handler
Proxy Handler sends the request data to the Original Data Service
Data Service responds with response
Proxy handler reads response and changes the ID and EDIT links in the payload
In case of POST , the Proxy Handler changes the response “Location” Header
so that the identity points to the Proxy Handler and not the Data Service.
Proxy handler returns the response data to the client .

How do I use this in my application ?

The source available for download contains “CrossDomainHandlerBase” which is the class that contains the functionality required
for recieving requests from clients and forwarding the requests onto the Data Service.

Setting up the Server-Side Proxy

Add a Generic ASHX Handler to the application that contains the Web page hosting the Silverlight application ,
1. Right-Click on Project
2. Add –> New Item –> Generic Handler

2. This will create a Generic Handler which implements IHttpHandler.

3. Remove the code stubs for IHttpHandler methods and properties .
4. Replace IHttpHandler with “CrossDomainHandlerBase”.

    [WebService(Namespace = "http://tempuri.org/")]
    [WebServiceBinding(ConformsTo = WsiProfiles.BasicProfile1_1)]
    public class CrossDomainHandler : CrossDomainHandlerBase
    {
        public CrossDomainHandler()
            : base()
        {
            this.DataServiceURI = "URI FOR THE DATA SERVICE";
            this.ProxyServiceURI = "URI FOR THE PROXY SERVICE";
        }
     }

4.From this point on , for all purposes , the Proxy Handler service IS the Data Service

Setting up the Silverlight application for Cross-Domain access

Right-Click on “References” in the Project
Select "Add Service Reference"
In the “Address” field , enter the URI for the proxy service ,
In case of the sample solution provided, the Provider is called “DataProvider”, hence
the code-gen produces the code with a type “DataProvider” derived from DataServiceContext.

When you instantiate the Context in the Silverlight application , always specify the Base URI
as the Proxy Handler’s URI,

DataProvider dataProvider = new DataProvider(
                new Uri("RELATIVE URI FOR THE PROXY SERVICE", 
                            UriKind.RelativeOrAbsolute)
                  );

This is the most important step of all , Party on !!

To do in the near future :

Convert the Handler to be an IHttpAsyncHandler so that we dont block on waiting for the response from the Data Service
Provide better mechanisms for Identity Resolution other than String.Replace .
Write a better demo app than something which binds all the parts of my name to a Grid.
Your suggestion goes here .

Viewer Mail , #1

PhaniRajuYN — Thu, 16 Oct 2008 08:55:36 GMT

Disclaimer : These are my thoughts and opinions , although I work on the Astoria team , I am not the voice of the team.The team has its own voice and can be heard here : Project Astoria Team Blog

Hola !

I am interrupting my regularly scheduled blog post to answer some really interesting questions about one of my blog posts , i.e Working with Associations in ADO.NET Data Services. These questions are from the comments on the post and
also the public forums.

Vince says :
”Hi,

I find bad to be forced to use the Addlink to allow us to save relational object in the DB.

We have a pretty full object model but the Addlink method needs string argument. As each entity knows all navigation properties, why to not have something like entity.NavigationObject rather than string SourceProperty. At least, myObject.MyNavigationProperty.Name or ToStringName would be better.

Thanks

Nice blogs

Regards

-Vince”

e
Thank you Vince for the compliment and let me try to explain the reason we built the client this way.

For V1 , we wanted to give you POCO access to the data classes. Although we could infer the relation based on the type of the navigation property , this would break scenarios where we have more than 1 navigation properties of the same type and belonging to the same entity Set.

Consider this entity ,

public class Customer {
public List<Orders> CashPurchases{get;set;}
public List<Orders> CreditCardPurchases{get;set;}
 }

If you do an AddLink with just an instance of Orders, we would have to guess which navigation property we have to add the link to .

Customer newCustomer = new Customer();
Orders cashPurchase = new Orders();
Orders creditCardPurchase = new Orders();
context.AddLink( newCustomer , "??", cashPurchase);

In the above case , trying to guess the name of the association will land us in hot water as we don't know which navigation property you intended .

we cant go the other way around and try to use the instance of Orders to guess the name of the association
as we Orders may have other associations of type Customers and we dont know which one you intended.
If you do not wish to use the string to remember the association name , you can move that to a separate resource file and have all your strings localized in one place.

Consider this ..

public class StoreConstants{
public static string Customers_To_CashPurchases  ="CashPurchases";
public static string Customers_To_CreditCardPurchases  ="CreditCardPurchases";
}

and then in your code ,

Customer newCustomer = new Customer();
Orders cashPurchase = new Orders();
Orders creditCardPurchase = new Orders();
context.AddLink( newCustomer , StoreConstants.Customers_To_CashPurchases , cashPurchase);
context.AddLink( newCustomer , StoreConstants.Customers_To_CreditCardPurchases , creditCardPurchase);

Simon says :

”Hi Phani,

Nice clear exposition of the topic.

However, I would think that, given that we are working with a client-side proxy, the separation of object tracking and association tracking is a bit too abstract for the most common scenarios where this client class may be used, ie with out-of-the-box databinding to UI components etc.

I understand the nice separation of concerns etc, but surely if the Customer or Contact properties are set in code, the user intends them to be set.I guess it is about user intentions and usability. Could you provide an overload such as

Context.AddObject( String property,Object value, Boolean shouldTrackAssociations)

Just a thought/suggestion.

Cheers,
Simon”

Thanks Simon for the compliment and lets explore this further,

I agree that the concept of treating associations as first class resources is somewhat new to the application scenarios where the client library is being used.

At the same time , we dont want to make assumptions on how the relation exists on the server as the client does not have enough information about the server schema.

Sure , we have the CLR types reflect the associations on the server i.e Reference for 1..1 relations and Collection types for 1..N relations.

But we really dont want to make assumptions about this.

Associations are first class resources on the server too , which means that any changes to associations should happen as separate requests or as part of another request. That making the assumption of a given relation causes an additional HTTP Request , which uses bandwidth you will be paying for .

Even if we added some magic to cause

newProduct.Categories.Add(newCategory) ;

to be

Context.AddLink(newProduct,"Categories",newCategory);

then the entity classes Products and Category would have to know about the DataServiceContext ,

newProduct.Context = myDataServiceContext;

and this would just look ugly ,IMHO.

Now , that was just me explaining how things are and why we cant do this today .

Let me share my thoughts of how this should be done and see how this sits with you .
If an entity has only one navigation property of a specify type .
ex: Customers has only one Navigation property of type Address.
Regardless of whether it is a Reference property or a Collection property,
updating the CLR property on the entity should setup the link

ex:
Address newAddress = new Address(){
City=’Bellevue’,
State=’WA’
};

newCustomer.Address = newAddress;

should automatically set this relation up in this way ,

context.SetLink(newCustomer,”Address”,newAddress);

To achieve this , without letting the entities know about the context ,the entities would have to notify the context that they have navigation properties and the context should listen for changes to the navigation properties.
But when should the context hook itself up to the afore-mentioned events ?
when the source entity is modified in some way perhaps ?

ex :

context.AddObject(“Customers”,newCustomer);

//pseudo code for AddObject

public void AddObject(string entitySetName,object entity) {
   ICanHazNavigationProperties navProps = entity as ICanHazNavigationProperties ;
    if( navProps !=null) {
    navProps.RegisterHandler(HandleNavPropChange);
  }
// do something here 
}

private void HandleNavPropChange(object source,string associationName,
               object target,Multiplicity associationMultiplicity,NavPropAction action) 
{
  switch(action)
  {
    case ( NavPropAction.AddLink ) :
                switch(associationMultiplicity) {
                         case Multiplicity.One :
                           this.SetLink(source,associationName,target);
                          break;
               }
    break;      
 //Other cases skipped for brevity  
    }
  }
  
}

Now , if we go with this approach, the entity types themselves cannot be pure POCO objects if you want automatic
link tracking. For auto generated types using DataSvcUtil.exe or “Add Service Reference” this is no big deal.
But what about cases where one has to hand-craft the entity types by hand ?

Well, this was me just thinking out loud. If you agree/disagree , leave a comment and get featured in the next
“Viewer Mail”.

A data geek joke , just like associations are first class resources , comments are first class material for blog posts :)

Astoria & IIS , HTTP 400 Bad Request on Posting Large Payloads to an astoria service

PhaniRajuYN — Mon, 06 Oct 2008 05:35:00 GMT

We’ve seen this in the labs and also reported by our customers on the forums, If you try to post a large amount of data to
an astoria data service , you might receive a response code Http 400 Bad Request even though the response data is valid.

An ADO.NET Data Service sits on top of Windows Communication Foundation , although most of the required plumbing is hidden away from you , you can still see the effects in scenarios such as this .

Why do I get a generic 400 Bad Request in this case ?

When the request size ( including headers ) exceeds 64 K ( 65536 bytes ) , WCF chokes on the request as this request size is greater than the limit on the maximum size of the request the service can recieve and sends out a HTTP 400 Bad Request as the request is invalid.

How do I fix this ?

a)The maximum size of the request which a WCF service can process is controlled by the MaxReceivedMessageSize property on the WCF binding.
The default value is 65536 ,exceeding which you get the 400 response code.

In the web.config of the web site hosting the service , add the following node in the <System.ServiceModel> section.

<system.serviceModel> 
<services> 
  <!-- The name of the service --> 
  <service name="NorthwindService"> 
    <!-- you can leave the address blank or specify your end point URI --> 
    <endpoint address ="YourServiceEndpoint" 
              binding="webHttpBinding" bindingConfiguration="higherMessageSize" 
     contract ="System.Data.Services.IRequestHandler"> 
    </endpoint> 
  </service> 
</services> 
<bindings> 
  <webHttpBinding> 
    <!-- configure the maxReceivedMessageSize  value to suit the max size of 
         the request ( in bytes ) you want the service to recieve--> 
    <binding name="higherMessageSize" maxReceivedMessageSize ="MaxMessageSize"/> 
  </webHttpBinding> 
</bindings> 
<serviceHostingEnvironment aspNetCompatibilityEnabled="true"/> 
</system.serviceModel>

b) If hosted on IIS , the ASP.Net Request Size restriction can also cause a large request to be rejected,
You will need to set the HttpRuntimeSection.MaxRequestLength Property.

<system.web> 
  <httpRuntime MaxRequestLength="ValueInKiloBytes" />
</system.web>

How do I Identify if the reason I am seeing a 400 Bad Request is because of the request size ?

Identify if WCF is throwing an exception under the covers which is not being surfaced to you at the HTTP level.
You can configure WCF tracing on the server-side to log the necessary information from the WCF layer.
Once you have tracing setup and you reproduced the failure , check if the log contains one or both of these exception messages.

System.ServiceModel.ProtocolException
"The maximum message size quota for incoming messages (65536) has been exceeded. 
To increase the quota, use the MaxReceivedMessageSize property on the appropriate binding element."

System.Web.HttpException
"Maximum request length exceeded."

If you see that the log does contain this message , then you can be sure that the failure is because of the message size
and apply this fix accordingly.