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

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

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 , Master-Details with Accordion

PhaniRajuYN — Wed, 10 Jun 2009 10:41:15 GMT

Download the sample Silverlight project here :

About the Silverlight toolkit ,

From their Codeplex page : http://silverlight.codeplex.com/

“The Silverlight Toolkit is a collection of Silverlight controls, components and utilities made available outside the normal Silverlight release cycle”

In the first of a series I am planning , we will talk about how to achieve a Master-Child display using the Accordion control
from the Silverlight Toolkit control.

The data model we will be binding looks like this :

Type Employee has a property called Department of type Department.
Type Department has a collection of type Employee called Employees.

Employee and Department are related 1..1
Department and Employee are related 1..M

We want to bind the Department names to the header of the Accordion and
the employees as a list inside the content of the accordion.
When we are done , the final output should look like this :

Configuring the header to show the DepartmentName

The Header template of the Accordion has a textblock which binds to the DepartMentName property of the
Department entity.

 <layoutToolkit:Accordion.HeaderTemplate >
       <DataTemplate>
            <TextBlock Text="{Binding Path=DepartMentName}"></TextBlock>
       </DataTemplate>
 </layoutToolkit:Accordion.HeaderTemplate>

Configuring the content to show the names of the employees working in the department.

The content of the Accordion pane would be a list box which is bound to the Employees collection of the Department
entity type and shows the EmployeeName as the DisplayMember.

<layoutToolkit:Accordion.ContentTemplate>
      <DataTemplate>
          <ListBox ItemsSource="{Binding Employees}" DisplayMemberPath="EmployeeName">
          </ListBox>
      </DataTemplate>
</layoutToolkit:Accordion.ContentTemplate>

To write the Silverlight client code for this project ,we will need to generate the Client classes with Databinding enabled.
As shown in this article on our team blog .

Once this is done , we have two ways of binding the accordion ,
Eager Loading : Download the employees for a department when you download the departments
Lazy Load : Download the employees for a department when the header of an accordion pane , i.e Department is clicked.

Eager Loading :

DataServiceQuery<Department> deptQueryWithEmployees = context.Departments.Expand("Employees") as DataServiceQuery<Department>;
deptQueryWithEmployees.QueryAndBind(acDepartments);

Since the query part itself isnt interesting in the context of this blog post , I’ve abstracted away the querying into an extension method ( QueryAndBind ) and will be available as part of the download.

Here , as you can see , we are eager loading the Employees for the departments .
I feel that this is wasteful if you have a large number of departments as this not only increases the amount of data on the wire , but it also means that all the data that comes down the wire will be useful .

For example, if you have about 15 departments and a user may click on 5 or less departments , then downloading employees for all the 15 departments seems inefficient.

Xaml for Eager Loading

<layoutToolkit:Accordion x:Name="acDepartments" Width="400">
    <layoutToolkit:Accordion.HeaderTemplate >
        <DataTemplate>
            <TextBlock Text="{Binding Path=DepartMentName}"></TextBlock>
        </DataTemplate>
    </layoutToolkit:Accordion.HeaderTemplate>
    <layoutToolkit:Accordion.ContentTemplate>
        <DataTemplate>
            <ListBox ItemsSource="{Binding Employees}" DisplayMemberPath="EmployeeName">
            </ListBox>
        </DataTemplate>
    </layoutToolkit:Accordion.ContentTemplate>
</layoutToolkit:Accordion>

Lazy Loading :
In this case , we will only bind the Headers and will bind the Employees only if the header is clicked for that department. In the Silverlight Accordion control , the event SelectionChanged is fired when the header of an Accordion Pane is clicked.
By listening to this event , we can find out which department was clicked and load the Employees for that department using BeginLoadProperty .

public DelayLoad() {
           InitializeComponent();
           context = new TreeViewDataProvider(new Uri("TreeViewDataService.svc", UriKind.RelativeOrAbsolute));
           LoadDepartments();
}
private void LoadDepartments(){
    ((DataServiceQuery<Department>)context.Departments).QueryAndBind(acDepartments);
}

We will subscribe to the SelectionChanged event of the Accordion and add “LoadEmployeesForDepartment” as the event handler.

private void LoadEmployeesForDepartment(object sender, SelectionChangedEventArgs e)
        {
            //The sender is the control that raised the event
            Accordion acControl = sender as Accordion;
            //Get the Selected Department
            Department selectedDepartment = acControl.SelectedItem as Department;
            if (
                //If the Selected object is department
                selectedDepartment != null 
                && (
                // If the Employees collection is null or empty
                selectedDepartment.Employees == null || selectedDepartment.Employees.Count == 0)
                )
            {
                //Call load property , which updates the Employees collection of this instance 
                //and the UI automatically updates itself, since Department type implements INotifyPropertyChanged
                context.LoadPropertyAndCall<Employee>(selectedDepartment, "Employees",
                    null);
            }

        }

XAML for Delay Load :

<layoutToolkit:Accordion x:Name="acDepartments" SelectionChanged="LoadEmployeesForDepartment">
    <layoutToolkit:Accordion.HeaderTemplate >
        <DataTemplate>
            <TextBlock Text="{Binding Path=DepartMentName}"></TextBlock>
        </DataTemplate>
    </layoutToolkit:Accordion.HeaderTemplate>
    <layoutToolkit:Accordion.ContentTemplate>
        <DataTemplate>
            <ListBox ItemsSource="{Binding Employees}" DisplayMemberPath="EmployeeName">
            </ListBox>
        </DataTemplate>
    </layoutToolkit:Accordion.ContentTemplate>
</layoutToolkit:Accordion>

Download the sample Silverlight project here :

Running the sample app

Set SLToolkitWithAstoriaWeb as the Start-up project.
Set SLToolkitWithAstoriaTestPage.html as the start-up page.
To run the EagerLoading sample , just hit F5
To run the DelayLoad sample , follow a-c and add the Query string ?delayLoad to the address bar in the browser that comes up.

Set Based Operations in Ado.net Data Services Part II

PhaniRajuYN — Wed, 27 May 2009 08:59:00 GMT

As an extension to the last blog post dealing with Set based filter operations in our client library ,
we will introduce support for the specifying method calls in the filter expression.

What does this achieve ?
Currently , the IsIn operator only supports an equality comparision.
With support for Method Calls , you can now select entities in a set which when passed to a method , evaluate true. ex: You can generate Uris such as this :

/northwind.svc/Customers?$filter = substringof('London',City) or substringof('Berlin',City) or substringof('Prague',City)
/northwind.svc/Customers?$filter = startswith('London',City) or startswith('Berlin',City) or startswith('Prague',City)
/northwind.svc/Customers?$filter = endswith('London',City) or endswith('Berlin',City) or endswith('Prague',City)

Fortunately , not a lot of code change is required to get this support.

We will change the first parameter of the extension method from

Expression<Func<TEntity, object>> propertyExpression

Expression<Func<TEntity, TValue, bool>> comparisionInvokeExpression

which means that where we were initially sending an expression that selects a property of the entity , we now send the Extension method a delegate that accepts the entity and the value being compared against it and returns a boolean value after comparison using a method.

example :

Expression<Func<T, object>> propertyExpression means

customer => customer.City

Expression<Func<TEntity, TValue, bool>> comparisionInvokeExpression means

(cust, cityName) => cust.City.ToLower().StartsWith(cityName)

The second change is in the location where we build the comparision expression for values in the set.
we change the line which does the comparision using Expression.Equal with a method call to the comparision expression passed in .
We will change :

//Build a comparision expression which equats the Id of the ENtity with this value in the IDs list
// ex : e.Id == 1
Expression comparison = Expression.Equal(left, Expression.Constant(id));

to :

//The Left Hand Side of the Filter Expression
MethodCallExpression comaprisionMethod = comparisionInvokeExpression.Body as MethodCallExpression;

//Build a comparision expression which calls the method that does the comparision for us
//ex : c=> c.City.Contains(id)
Expression comparison = Expression.Call(
                        comaprisionMethod.Object,
                        comaprisionMethod.Method,
                        Expression.Constant(id) );

The complete code sample is here :

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 .

DataServiceContext , Detect if there are pending changes

PhaniRajuYN — Fri, 03 Oct 2008 20:20:15 GMT

Hi ,

I ran into this interesting scenario in the forums today .
How does one find out if there are any pending changes in the DataServiceContext that you have to submit to the store ?

This is quite simple actually .
The DataServiceContext has 2 collections called Entities and Links. These collections contain entities and links that are tracked by the context.
Given these collections , how does one know if any of them were changed on the client by the appropriate API ?
Lets look at the collections one by one ,

Entities

DataServiceContext.Entities gives you a List<EntityDescriptor> , each EntityDescriptor instance contains a State property.
If the State is anything other than Unchanged , then the changes made to the entity on the client side are not commited to the server.
This is because we change the states of the entities to Unchanged after you call SaveChanges on the context.

The basic state changes are :

UpdateObject –> Modified   -> SaveChanges –> UnChanged
DeleteObject –> Deleted    -> SaveChanges –> UnChanged
AddObject     –> Added       -> SaveChanges –> UnChanged

So , to find out if there are any entities in the DataServiceContext which have been changed and not saved,
you would write something like this :

bool pendingEntityChanges = dsContext.Entities.Any(ed => ed.State != EntityStates.Unchanged);

Links

DataServiceContext.Links gives you a List<LinkDescriptor> , each LinkDescriptor instance contains a State property ,

Links that point to collection properties

AddLink-> Added –> SaveChanges –> UnChanged
DeleteLink –> Deleted –> SaveChanges –> Detached

Links that point to reference properties

SetLink with Target not Null –> Modified –> SaveChanges –> UnChanged
SetLink with Target Null –> Modified –> SaveChanges –> Detached

To query for links which have not yet been saved , you would write :

bool pendingLinkChanges = dsContext.Links.Any(ld => ld.State != EntityStates.Unchanged);

and finally , the function to check if there are any unsaved changes ( Entities / Links ) in the context :

private bool HasUnsavedChanges(DataServiceContext dataContext){
  //Check if any Entities are unsaved
 return dataContext.Entities.Any(ed => ed.State != EntityStates.Unchanged)
 //Check if any Links are unsaved
 || dataContext.Links.Any(ld => ld.State != EntityStates.Unchanged)
}

Ajax preview 2 : Declarative Instantiation of AjaxControlToolkit Controls

PhaniRajuYN — Fri, 12 Sep 2008 09:56:29 GMT

Today ,we will talk about using the Declarative Syntax to instantiate certain AjaxControlToolkit Behaviors .

Step 0: Figure out which are the script files needed for the Behavior to work and include the appropriate Script references in your page .
For the PopupControlBehavior , the script files would be :

AjaxControlToolkit.ExtenderBase.BaseScripts.js
AjaxControlToolkit.Common.Common.js
AjaxControlToolkit.Compat.Timer.Timer.js
AjaxControlToolkit.Animation.Animations.js
AjaxControlToolkit.Animation.AnimationBehavior.js
AjaxControlToolkit.PopupExtender.PopupBehavior.js
AjaxControlToolkit.PopupControl.PopupControlBehavior.js

Step 1: Declare the behaviors you wish to attach to the templated elements.

<body xmlns:sys="javascript:Sys" xmlns:popup="javascript:AjaxControlToolkit.PopupControlBehavior">

Step 2 : In the template , attach this behavior to the target element using the sys:attach syntax.

<a href="#" sys:attach="popup" .....>Some Text Here</a>

Step 3 : Depending on the behavior you are using , set the appropriate properties .
Since I am using the PopupControlBehavior , we will need to set the PopupControlID and the Position properties of the behavior.

<a popup:popupcontrolid=""  popup:position="4" >...</a>

Declarative template for Master-Details view with popupbehavior :

<div id="listTemplate" style="width: 150px" class="yellow">
  <ul sys:attach="dataview" class="sys-template" dataview:data="{{ localData }}">
     <li>
           <span sys:attach="popup" popup:popupcontrolid="{{'subDiv'+ListID}}" popup:position="4"
      sys:id="{{'master'+ ListID}}">{{ ListTitle }}</span>

       <div id="{{ 'subDiv' + ListID}}" class="grey" style="display: none; width: 300px">

           <ul class="sys-template" sys:attach="dataview" dataview:data="{{ ListElements }}">
                            <li>{{ListElementText}} </li>

           </ul>

          </div>
            </li>
      </ul>
</div>

Complete Sample Code : Click Me

Documentation for the AjaxControlToolkit

PhaniRajuYN — Wed, 27 Aug 2008 07:07:23 GMT

Ready for some documentation for the ATK controls ?
To skip my journey to create this , download the Documentation ( in CHM form) here : AjaxControlToolkit Docs

Step 1 : Using AjaxDoc to generate the Reflection.org file required by Sandcastle

   1.0) Download AjaxDoc here .
   1.1) Download the Latest Source for the AjaxControlToolkit , here .
   1.2) Get the Script Files from the AjaxControlToolkit project .
   1.3) Create the AjaxControlToolkit.project.xml for AjaxDoc which has script references to the ATK Scripts.
   1.4) Run the Default.aspx page

Hurdle 1 : DynamicPopulateBehavior.js just refused to load.
Added this line to ln 150 of ScriptDoc.js file to skip types which throw errors.

 if(member ===null || typeof(member)==="undefined") continue;

1.5) Run the Default.aspx page again

Hurdle 2: “PopupBehavior is undefined”.
1.6) Re-arranged the script references in the Project.xml file to order the script files according to their dependencies.
1.7) Run the Default.aspx page again .

Step 2 : Use SandCastle to produce the CHM File

Follow the Steps 5-12 defined here : Creating a Chm build using Sandcastle
Whichever Transform you use (Vs2005/Prototype) , in step 8, remove these lines in the sandcastle.config file.

<language label="VisualBasic" name="VisualBasic" style="vb" />
<language label="CSharp" name="CSharp" style="cs" />
<language label="ManagedCPlusPlus" name="ManagedCPlusPlus" style="cpp" />
<!--<language label="JSharp" name="JSharp" style="cs" />
<language label="JScript" name="JScript" style="cs" />-->

There you go !

The CHM is not perfect ,

The documentation is missing for the following components
1. AnimationExtender
2. RichTextEditor
3. MultiHandleSlider
The Code Comments are missing from the CHM file
Insert gripe here

I'll probably take a look at this again to see if I can generate a CHM which has the missing parts.
And finally , while Its not everything , its not nothing either :)

Resources:
Bertrand's blog
SandCastle Blog
AjaxDoc on CodePlex
SandCastle on CodePlex

Entities , How many ways do I count thee ?

PhaniRajuYN — Mon, 18 Aug 2008 02:51:30 GMT

Its a common ask that we introduce aggregating mechanisms in Data services so that one can do a Count of
the number of entities present in an EntitySet easily.
In this blog post , I will outline one method of implementing a “Count” method that works for you.

The interface to the count method will be

http://<ServiceEndPoint>/Count?entitySetName='<entitySetName>'

Server-Side

On the server-side , we will write a Service Operation that takes the name of the EntitySet as an input parameter.

[WebGet]
 public long Count(string entitySetName) {
 //Implementation goes here
 }

In your Service Operations / Interceptors , you have access to the CurrentDataSource which represents your data providers.
The entity sets are properties off of the CurrentDataSource. We will get the entityset off of the CurrentDataSource
and get the count of entities by casting it to IListSource.

[WebGet]
public long Count(string entitySetName)  {

long countOfEntities = 0;

//Get the Property off of the CurrentDataSource
PropertyInfo esProperty = this.CurrentDataSource.GetType().GetProperty(entitySetName);

//Get the EntitySet off of the CurrentDataSource
object esValue = esProperty.GetValue(this.CurrentDataSource, null);

//Cast the EntitySet to IListSource
IListSource genericESList = esValue as IListSource;

//Get the count of entities by fetching the list and getting the value of its "Count" Property
countOfEntities = genericESList.GetList().Count;

return countOfEntities;
}

Client-Side

we will make an extension method on the data service context that takes the name of the entityset and returns the count.

DataServiceContext nwContext = new DataServiceContext( new Uri("ServiceRoot") );
long countOfProducts = nwContext.Count("Products");

Extension method on the DataServiceContext to retrieve count of entities in entityset on the server .

public static long Count(this DataServiceContext context, string entitySetName) {
 //Call the ServiceOperation on the server side passing the entitySetNameas a parameter
 var results = context.Execute<long>(new Uri(String.Format("Count?entitySetName='{0}'", entitySetName),
   UriKind.RelativeOrAbsolute));
 //Get the result off of the IEnumerable
 long count = results.First<long>();
 //return the count
 return count;
}

Complete Sample Code :

Put this in your Service Code on the server .

[WebGet]
[SingleResult]
public long Count(string entitySetName) {
long countOfEntities = 0;
if (entitySetName == null) {
  throw new ArgumentNullException("entitySetName");
}
//Get the Property off of the CurrentDataSource
PropertyInfo esProperty = this.CurrentDataSource.GetType().GetProperty(entitySetName);
if (esProperty == null) {
throw new ArgumentException(String.Format("No EntitySet named {0} found on the DataSource", entitySetName));
}
try {
 //Get the EntitySet off of the CurrentDataSource
 object esValue = esProperty.GetValue(this.CurrentDataSource, null);
 //Cast the entitySet to IListSource
 IListSource genericESList = esValue as IListSource;
 //If the cast succeeded
 if (genericESList != null) {
 countOfEntities = genericESList.GetList().Count;
 }
}
catch (Exception exception) {
throw new DataServiceException("'Count' method Failed with , see InnerException -->", exception);
}
return countOfEntities;
}

Put this in your client Code .

public static class ClientExtensions {
/// <summary>
/// This Method returns the count of the number if entities present in an Entityset
/// </summary>
/// <param name="context">The DataServiceContext which contains the entities</param>
/// <param name="entitySetName">The EntitySetName whose entities should be counted</param>
/// <returns>The number of entities in the entityset</returns>
/// <example>
///  long countOfProducts = context.Count("Products");
/// </example> 
public static long Count(this DataServiceContext context, string entitySetName)
{
    //Call the ServiceOperation on the server side passing the entitySetName as a parameter
    var results = context.Execute<long>(
            new Uri(String.Format("Count?entitySetName='{0}'", entitySetName), UriKind.RelativeOrAbsolute)
            );
    //Get the result off of the IEnumerable
    long count = results.First<long>();
    //return the count
    return count;
}
}

In a future post , I will talk about how to off load the counting work to your database , if you have a relational database
as your backend.

Working with Associations in ADO.NET Data Services

PhaniRajuYN — Wed, 02 Jul 2008 08:58:46 GMT

I’ve seen that users are having some question about how to deal with certain types of relations between entities and how to deal with them in the client library.I will outline the a couple of common scenarios of using the client library among a few relationship types. I'll be using the AdventureWorks Database for examples of relations.

1..1 Associations

This is the case of entities associated with each other 1..1 . An example from Adventureworks is the relation between Individual and Contact,Customer Entities.

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

<EntityType Name="Individual">
<Key>
  <PropertyRef Name="CustomerID" /> 
</Key>
<!—Primitive & Complex Properties --> 
  <Property Name="CustomerID" Type="Edm.Int32" Nullable="false" /> 
  <Property Name="Demographics" Type="Edm.String" Nullable="true" MaxLength="Max" Unicode="true" FixedLength="false" /> 
  <Property Name="ModifiedDate" Type="Edm.DateTime" Nullable="false" /> 
<!-- Navigation Properties , Signifying related entities of an association -->
  <NavigationProperty Name="Contact" 
    Relationship="AdventureWorks.FK_Individual_Contact_ContactID" 
   FromRole="Individual" ToRole="Contact" /> 
  <NavigationProperty Name="Customer"    Relationship="AdventureWorks.FK_Individual_Customer_CustomerID" 
   FromRole="Individual" ToRole="Customer" /> 
</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 Individual {
//Other properties removed for brevity 
 public Contact Contact {
            get {
                return this._Contact;
            }
            set {
                this._Contact = value;
            }
        }
public Customer Customer {
            get {
                return this._Customer;
            }
            set {
                this._Customer = value;
            }
        }
}

Trivia : Properties of a type P in an entity type E which signify that the type E has a 1..1 relation with the type P of the property are called as Reference Properties.

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.

Individual individual = new Individual();
//Initialize all its necessary properties
Customer newCustomer = new Customer();
//Initialize all its necessary properties
Contact contact = new Contact();
//Initialize all its necessary properties

//Add the newly created entities to be tracked by the client context

TestContext.AddObject("Individual", individual);
TestContext.AddObject("Customer", newCustomer);  
TestContext.AddObject("Contact", contact);

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 ?

individual.Customer = newCustomer;
individual.Contact = contact;
TestContext.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 ?

Beta 1 Code :
You use the AddLink method defined on the context.

TestContext.AddLink(individual, "Contact", contact);
TestContext.AddLink(individual, "Customer", newCustomer);

The signature and the intent of the AddLink method is lucid , it binds 2 entities into a relation , its kinda like a priest at a wedding,
“I now bind you into the holy bond of 1..1 relations. You may now change your facebook status“

okay , jokes aside , this is what it looks like ..

AddLink ( Parentinstance ,”ChildPropertyName”,ChildInstance)

RTM Code :

You use the SetLink method defined on the context.

TestContext.SetLink(individual, "Contact", contact);
TestContext.SetLink(individual, "Customer", newCustomer);

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 ..

SetLink ( 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..

Individual existingIndividual = TestContext.Individual.Expand("Customer,Contact").Take<Individual>(1).First<Individual>();

TestContext.DetachLink(existingIndividual, "Contact", existingIndividual.Contact);
TestContext.DetachLink(existingIndividual, "Customer", existingIndividual.Customer);
TestContext.DeleteObject(existingIndividual);
TestContext.SaveChanges();

Wait !! what’s with the expand 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.

Well, that’s it from me , In the next part , we shall discuss entities with 1..N relations and how to work with them using the astoria context.
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.

I will update the code used in this sample and upload it later.