The Open Data Protocol, referred
to as OData, is a new data-sharing standard that breaks down silos and fosters an interoperative ecosystem for data consumers (clients) and producers (services) that is far more powerful than currently possible. It enables more applications
to make sense of a broader set of data, and helps every data service and client add value
to the whole ecosystem. WCF Data Services (previously known as ADO.
NET Data Services), then, was the first Microsoft technology
to support the Open Data Protocol
in Visual Studio 2008 SP1. It provides developers with client libraries for .
NET, Silverlight, AJAX, PHP and Java. Microsoft now also supports OData
in SQL Server 2008 R2, Windows Azure Storage, Excel 2010 (through PowerPivot), and SharePoint 2010. Many other other applications
in the works. * This post walks you through
how to create an OData feed, define a shape for the data and pre-filter the data using Visual Studio 2010, WCF Data Services and the Entity Framework. A sample project is attached at the bottom of Part 2 of this post. Pre-filtering and shaping OData feeds using WCF Data Services and the Entity Framework - Part 2 Create the
Web Application File –› New –› Project, Select “ASP.
NET Empty
Web Application” Add the Entity Data Model Right click on the
Web Application
in the Solution Explorer and select “Add New Item..” Select “ADO.
NET Entity Data Model” under "Data”. Name the Model “Northwind” and click “Add”.
In the “Choose Model Contents”, select “Generate Model From Database” and click “Next” Define a connection
to your database containing the Northwind database
in the next screen. We are going
to expose the Products table through our OData feed. Select “Products”
in the “Choose your Database Object” screen. Click “Finish”. We are done creating our Entity Data Model. Save the Northwind.edmx file created. Add the WCF Data Service Right click on the
Web Application
in the Solution Explorer and select “Add New Item..” Select “WCF Data Service” from the list and call the service “DataService” (creative, huh?). Click “Add”. Enable Access
to the Data Service Open the DataService.svc.cs class. The class is well commented and instructs us on the next steps. public class DataService : DataService< /* TODO: put your data source class name here */ >
{
// This method is called only once
to initialize service-wide policies.
public static void InitializeService(DataServiceConfiguration config)
{
// TODO: set rules
to indicate which entity sets and service operations are visible, updatable, etc.
// Examples:
// config.SetEntitySetAccessRule("MyEntityset", EntitySetRights.AllRead);
// config.SetServiceOperationAccessRule("MyServiceOperation", ServiceOperationRights.All);
config.DataServiceBehavior.MaxProtocolVersion = DataServiceProtocolVersion.V2;
}
}
Replace the comment that starts with “/* TODO:” with “NorthwindEntities” (the entity container name of the Model we created earlier).
WCF Data Services is initially locked down by default, FTW! No data is exposed without you explicitly setting it. You have explicitly specify which Entity sets you wish
to expose and what rights are allowed by using the SetEntitySetAccessRule. The SetServiceOperationAccessRule on the other hand sets rules for a specified operation.
Let us define an access rule
to expose the Products Entity we created earlier. We use the EnititySetRights.AllRead since we want
to give read only access. Our modified code is shown below.
public class DataService : DataService<NorthwindEntities>
{
public static void InitializeService(DataServiceConfiguration config)
{
config.SetEntitySetAccessRule("Products", EntitySetRights.AllRead);
config.DataServiceBehavior.MaxProtocolVersion = DataServiceProtocolVersion.V2;
}
}
We are done setting up our ODataFeed! Compile your project. Right click on DataService.svc and select “View
in Browser”
to see the OData feed.
To view the feed
in IE, you must make sure that "Feed Reading View" is turned off. You set this under Tools -› Internet Options -› Content tab.
If you navigate
to “Products”, you should see the Products feed. Note also that URIs are case sensitive. ie. Products work but products doesn’t.
Filtering our data
OData has a set of system query operations you can use
to perform common operations against data exposed by the model. For example,
to see only Products
in CategoryID 2, we can use the following request:
/DataService.svc/Products?$filter=CategoryID eq 2
At the time of this writing, supported operations are $orderby, $top, $skip, $filter, $expand, $format†, $select, $inlinecount.
Pre-filtering our data using Query Interceptors
The Product feed currently returns all Products. We want
to change that so that it contains only Products that have not been discontinued.
WCF introduces the concept of interceptors which allows us
to inject custom validation/policy logic into the request/response pipeline of a WCF data service.
We will use a QueryInterceptor
to pre-filter the data so that it returns only Products that are not discontinued.
To create a QueryInterceptor, write a method that returns an Expression<Func<T, bool>> and mark it with the QueryInterceptor attribute as shown below.
[QueryInterceptor("Products")]
public Expression<Func<Product, bool>> OnReadProducts()
{
return o => o.Discontinued == false;
}
Viewing the feed after compilation will only show products that have not been discontinued. We also confirm this by looking at the WHERE clause
in the SQL generated by the entity framework.
SELECT
[Extent1].[ProductID] AS [ProductID],
...
...
[Extent1].[Discontinued] AS [Discontinued]
FROM [dbo].[Products] AS [Extent1]
WHERE 0 = [Extent1].[Discontinued]
Other examples of Query/Change interceptors can be seen here including an example
to filter data based on the identity of the authenticated user.
We are done pre-filtering our data.
In the next part of this post, we will see
how to shape our data.
Pre-filtering and shaping OData feeds using WCF Data Services and the Entity Framework - Part 2
Foot Notes
* http://msdn.microsoft.com/en-us/data/aa937697.aspx
† $format did not work for me. The way
to get a Json response is
to include the following
in the request header “Accept: application/json, text/javascript, */*” when making the request. This is easily done with most JavaScript libraries.
