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

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

ADO.NET Data Services SL Client Library - XDomain and Out Of Browser

PhaniRajuYN — Fri, 04 Sep 2009 05:32:00 GMT

The first in my two part blog posts about the new Silverlight Client Library we released in CTP2 is up on the team blog.

Using the ADO.NET Data Services Silverlight client in x-domain and out of browser scenarios – I

Stay tuned to the team blog for the the second part which talks about using the client library X-Domain and Out Of Browser
to access a data service which is authenticated with Forms Authentication.

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 :

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.

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

Interim Release: Making SL2 Beta 2 Clients Work With .NET Fx 3.5 SP1 RTM Servers

PhaniRajuYN — Wed, 03 Sep 2008 02:27:36 GMT

Cross-posted from here : Interim Release: Making SL2 Beta 2 Clients Work With .NET Fx 3.5 SP1 RTM Servers

As an offshoot of the feedback we got from different channels , ( Blogs , Direct emails to team members , our discussion forums, etc) we are releasing an “interim build” of the data services Silverlight client which works with the Silverlight 2 Beta 2 runtime ,and works with the RTM ADO.NET Data Services Server released as part of .Net Framework 3.5 SP1 RTM.

Download Location : ADO.NET Data Services Silverlight 2 B2 Client Refresh

How did we get here ?

We have different ship vehicles for the client and the server components.

When the Silverlight 2 Beta 2 Client shipped , the ADO.NET Data Services Server which was available was the one from .NET Framework 3.5 SP1 Beta1 and we made the SL client library work with the Server which was available when SL2 Beta 2 shipped.

When the RTM of .NET Framework 3.5 SP1 was released, the Silverlight Client library was still the one from the SL2 Beta 2 release.

The original plan was to ship a Silverlight Client Library for ADO.NET Data Services when Silverlight 2 RTMs. This meant that for a certain period of time , between when 3.5 SP1 RTM and SL2.0 RTM, users would have a Silverlight Client Library for ADO.NET Data Services which would not work with the RTM Server.

You can read more about this here : Compat Note: Silverlight Beta 2 Client & .NET Framework 3.5 SP1 Server Components

What is this release about ?

We took the Silverlight Client Library code that was going be released as part of the SL 2.0 RTM SDK (or almost, you never know when you’re set and won’t touch the bits again) and built it against the SL 2 Beta 2 Runtime and SDK components.This new downloadable assembly will allow your Silverlight applications built against Silverlight 2 Beta 2 to talk to Data Services servers built with the .NET 3.5 SP1 RTM release

Should everyone upgrade to this release of the client library ?

If your client applications are built on SL2 Beta 2 SDK and talk to the ADO.NET Data Services Server released as part of .NET Framework 3.5 SP1 Beta1 , then upgrading to this Assembly will break your client applications. Don’t upgrade unless the Data Services Server is from .NET Framework 3.5 SP1 RTM.

If you want your Silverlight applications built on SL2 Beta 2 SDK to talk to the Astoria Server released as part of the .NET Framework 3.5 SP1 RTM, then you should upgrade to this version of the System.Data.Services.Client Library.

Are there any gotchas to be aware of ?

Yes -- Don’t depend on this “interim release” for your production applications.

Wait until Silverlight 2.0 RTMs to deploy any Silverlight applications that use the System.Data.Services.Client library.

How different is this from the RTM library ?

Well, most of the code is the same as will be shipped in the Silverlight RTM SDK. The difference being that we have to depend on the SL2 Beta 2 Runtime for certain core functionality. So , consider this an early look at something close to what will come later on. Any feedback you give us will only help make the RTM library that much better.

Using the new Assembly

Download the new Silverlight Client Assembly from here : ADO.NET Data Services Silverlight 2 B2 Client Refresh

Installing the New Silverlight Client Assembly

1. Go to the %ProgramFiles%\Microsoft SDKs\Silverlight\v2.0\Libraries\Client folder

2. Backup the older System.Data.Services.Client.dll

3. Replace the older assembly with the new one.

Upgrading your applications to use the new SL Client Assembly

1. Remove any references to the older SL client library in your applications .

2. Compile to make sure that the build fails .

3. Add a reference to the newer SL Client assembly .

4. Compile again to make sure that the build succeeds .

Phani Raj
ADO.NET Data Services Test Team