WCF Data Services Team Blog

WCF Data Services 5.5.0 Prerelease

dpblogs — Thu, 16 May 2013 00:30:14 GMT

It’s that time again: yesterday we uploaded an RC for the upcoming 5.5.0 release. The 5.5.0 release will be another NuGet-only release.

What is in the release:

This release has two primary features: 1) significant enhancements to the URI parser and 2) public data source providers.

URI Parser

In the 5.2.0 release ODataLib provided a way to parse $filter and $orderby expressions into a metadata-bound abstract syntax tree (AST). In the 5.5.0 release we have updated the URI parser with support for most OData URIs. The newly introduced support for parsing $select and $expand is particularly notable. With the 5.5.0 release the URI Parser is mostly done. Future releases will focus on higher-order functions to further improve the developer experience.

Note: We are still trying to determine what the right API is for $select and $expand. While the API may change before RTM, the feature is functionally complete.

Public Data Source Providers

In this release we have made the Entity Framework and Reflection data source providers public. This gives more control to service writers. There is more work planned in the future but the work we’ve completed allows some advanced scenarios which were not possible earlier. For example, a service writer can now make use of the Entity Framework query-caching feature by intercepting the request and parameterizing the LINQ query before handing it off to Entity Framework. (Note that parameterizing a LINQ query is not the same as parameterizing a SQL query; EF always does the latter and therefore there is no security implications to failing to parameterize a LINQ to Entities query, the only impact is performance related.)

While the potential unlocked with this release is limited, this is the first move in a direction which will unlock many previously unachievable scenarios with the built in providers.

WCF Data Services 5.4.0 Release

dpblogs — Tue, 02 Apr 2013 22:16:15 GMT

Today we are releasing version 5.4.0 of WCF Data Services. As mentioned in the prerelease post, this release will be NuGet packages only. That means that we are not releasing an updated executable to the download center. If you create a new WCF Data Service or add a reference to an OData service, you should follow the standard procedure for making sure your NuGet packages are up-to-date. (Note that this is standard usage of NuGet, but it may be new to some WCF Data Services developers.)

Samples

If you haven’t noticed, we’ve been releasing a lot more frequently than we used to. As we adopted this rapid cadence, our documentation has fallen somewhat behind and we recognize that makes it hard for you to try out the new features. We do intend to release some samples demonstrating how to use the features below but we need a few more days to pull those samples together and did not want to delay the release. Once we get some samples together we will update this blog post (or perhaps add another blog post if we need more commentary than a gist can convey).

What is in the release:

Client deserialization/serialization hooks

We have a number of investments planned in the “request pipeline” area. In 5.4.0 we have a very big set of hooks for reaching into and modifying data as it is being read from or written to the wire format. These hooks provide extensibility points that enable a number of different scenarios such as modifying wire types, property names, and more.

Instance annotations on atom payloads

As promised in the 5.3.0 release notes, we now support instance annotations on Atom payloads. Instance annotations are an extensibility feature in OData feeds that allow OData requests and responses to be marked up with annotations that target feeds, single entities (entries), properties, etc. We do still have some more work to do in this area, such as the ability to annotate properties.

Client consumption of instance annotations

Also in this release, we have added APIs to the client to enable the reading of instance annotations on the wire. These APIs make use of the new deserialization/serialization pipelines on the client (see above). This API surface includes the ability to indicate which instance annotations the client cares about via the Prefer header. This will streamline the responses from OData services that honor the odata.include-annotations preference.

Simplified transition between Atom and JSON formats

In this release we have bundled a few less-noticeable features that should simplify the transition between the Atom and (the new) JSON format. (See also the bug fixes below on type resolver fixes.)

Bug fixes

In addition to the features above, we have included fixes for the following notable bugs:

Fixes an issue where reading a collection of complex values would fail if the new JSON format was used and a type resolver was not provided
Fixes an issue where ODataLib was not escaping literal values in IDs and edit links
Fixes an issue where requesting the service document with application/json;odata=nometadata would fail
Fixes an issue where using the new JSON format without a type resolver would create issues with derived types
(Usability bug) Makes it easier to track the current item in ODataLib in many situations
Fixes an issue where the LINQ provider on the client would produce $filter instead of a key expression for derived types with composite keys
(Usability bug) Fixes an issue where the inability to set EntityState and ETag values forced people to detach and attach entities for some operations
Fixes an issue where some headers required a case-sensitive match on the WCF DS client
Fixes an issue where 304 responses were sending back more headers than appropriate per the HTTP spec
Fixes an issue where a request for the new JSON format could result in an error that used the Atom format
Fixes an issue where it was possible to write an annotation value that was invalid according to the term
Fixes an issue where PATCH requests for OData v1/v2 payloads would return a 500 error rather than 405

We want your feedback

We always appreciate your comments on the blog posts, forums, Twitterverse and e-mail (mastaffo@microsoft.com). We do take your feedback seriously and prioritize accordingly. We are still early in the planning stages for 5.5.0 and 6.0.0, so feedback now will help us shape those releases.

WCF Data Services 5.4.0 Prerelease

dpblogs — Tue, 26 Mar 2013 17:53:57 GMT

Recently we uploaded an RC for our upcoming 5.4.0 release. This release will be NuGet packages only.

What is in the release:

Client deserialization/serialization hooks

Instance annotations on atom payloads

Client consumption of instance annotations

Simplified transition between Atom and JSON formats

In this release we have bundled a few less-noticeable features that should simplify the transition between the Atom and (the new) JSON format. (See also the bug fixes below on type resolver fixes.)

Bug fixes

In addition to the features above, we have included fixes for the following notable bugs:

Fixes an issue where reading a collection of complex values would fail if the new JSON format was used and a type resolver was not provided
Fixes an issue where ODataLib was not escaping literal values in IDs and edit links
Fixes an issue where requesting the service document with application/json;odata=nometadata would fail
Fixes an issue where using the new JSON format without a type resolver would create issues with derived types
(Usability bug) Makes it easier to track the current item in ODataLib in many situations
Fixes an issue where the LINQ provider on the client would produce $filter instead of a key expression for derived types with composite keys
(Usability bug) Fixes an issue where the inability to set EntityState and ETag values forced people to detach and attach entities for some operations
Fixes an issue where some headers required a case-sensitive match on the WCF DS client
Fixes an issue where 304 responses were sending back more headers than appropriate per the HTTP spec
Fixes an issue where a request for the new JSON format could result in an error that used the Atom format
Fixes an issue where it was possible to write an annotation value that was invalid according to the term
Fixes an issue where PATCH requests for OData v1/v2 payloads would return a 500 error rather than 405

What to expect over the next six months:

We will blog about this in more detail soon, but we have multiple releases planned that have some level of overlap. We should be publishing a 5.5.0 alpha soon (with additional URI parser functionality for Web API’s OData stack) and in a couple of months you should see a very early alpha of 6.0.0. We’re not ready to say much about 6.0.0 yet other than the fact that it will support OData v4 and will probably have some breaking changes, so we want to get it out there as soon as possible because…

We want your feedback

We always appreciate your comments on the blog posts, forums, Twitterverse and e-mail (mastaffo@microsoft.com). We do take your feedback seriously and prioritize accordingly. We would encourage you strongly to start pulling down these early bits, testing with your existing services, and telling us where things break, where we’ve gone too far, and where we haven’t gone far enough.

WCF Data Services 5.3.0 RTW

dpblogs — Mon, 18 Feb 2013 23:39:59 GMT

Today we are releasing an updated version of the WCF Data Services NuGet packages and tools installer. As mentioned in the prerelease blog post, this version of WCF DS has three notable new features as well as over 20 bug fixes.

What is in the release:

Instance annotations on feeds and entries (JSON only)

Instance annotations are an extensibility feature in OData feeds that allow OData requests and responses to be marked up with annotations that target feeds, single entities (entries), properties, etc. WCF Data Services 5.3.0 supports instance annotations in JSON payloads. Support for instance annotations in Atom payloads is forthcoming.

Action Binding Parameter Overloads

The OData specification allows actions with the same name to be bound to multiple different types. WCF Data Services 5.3 enables actions for different types to have the same name (for instance, both a Folder and a File may have a Rename action). This new support includes both serialization of actions with the same name as well as resolution of an action’s binding parameter using the new IDataServiceActionResolver interface.

Modification of the Request URL

For scenarios where it is desirable to modify request URLs before the request is processed, WCF Data Services 5.3 adds support for modifying the request URL in the OnStartProcessingRequest method. Service authors can modify both the request URL as well as URLs for the various parts of a batch request.

This release also contains the following noteworthy bug fixes:

Fixes an issue where code gen produces invalid code in VB
Fixes an issue where code gen fails when the Precision facet is set on spatial and time properties
Fixes an issue where code gen was incorrectly generating the INotifyPropertyChanged code for subtypes in different namespaces
Fixes an issue where odata.type was not written consistently in fullmetadata mode for JSON
Fixes an issue where a valid form of Edm.DateTime could not be parsed
Fixes an issue where the WCF DS client would not send type names for open properties on insert/update
Fixes an issue where the client Execute() method would fail for a particular payload with DataServiceVersion=1.0
Fixes an issue where type information was omitted in JSON fullmetadata payloads
Fixes an issue where open property type information was omitted in JSON update/insert requests
Fixes an issue where it was not possible to navigate relationships on entities with multi-part keys

WCF Data Services 5.3.0-rc1 Prerelease

dpblogs — Thu, 31 Jan 2013 20:05:03 GMT

Today we released an updated version of the WCF Data Services NuGet packages and tools installer. This version of WCF DS has some notable new features as well as several bug fixes.

What is in the release:

Instance annotations on feeds and entries (JSON only)

Action Binding Parameter Overloads

Modification of the Request URL

This release also contains the following noteworthy bug fixes:

Fixes an issue where code gen produces invalid code in VB
Fixes an issue where code gen fails when the Precision facet is set on spatial and time properties
Fixes an issue where odata.type was not written consistently in fullmetadata mode for JSON
Fixes an issue where a valid form of Edm.DateTime could not be parsed
Fixes an issue where the WCF DS client would not send type names for open properties on insert/update
Fixes an issue where the WCF DS client could not read responses from service operations which returned collections of complex or primitive types

WCF Data Services 5.2.0 Released

dpblogs — Mon, 17 Dec 2012 19:54:30 GMT

We’re pleased to announce that today we are releasing NuGet packages and a tools installer for WCF Data Services 5.2.0. As mentioned in the prerelease blog post, this release brings in the UriParser from ODataLib Contrib and contains a few bug fixes.

Bug Fixes

This release contains the following noteworthy bug fixes:

Fixes an issue where code gen for exceedingly large models would cause VS to crash (you need to run the installer to get this fix)
Provides a better error message when the service model exposes enum properties
Fixes an issue where IgnoreMissingProperties did not work properly with the new JSON format
Fixes an issue where an Atom response is unable to be read if the client is set to use the new JSON format

URI Parser

In this release ODataLib now provides a way to parse $filter and $orderby expressions into a metadata-bound abstract syntax tree (AST). This functionality is typically intended to be consumed by higher level libraries such as WCF Data Services and Web API.

For a detailed write-up on $filter and $orderby parsing, see this blog post.

General Reliability and Performance

In addition, we’ve invested a little bit more in improving the overall stability and performance of WCF Data Services. While we recognize that we have continued room for improvement, we are actively investing here and will continue to invest in reliability and performance over the next several releases.

What do you need to do?

This release is a little unusual because we fixed bugs in both code gen and the runtime. Most customers should run the installer, which will fix the code gen bug and ensure that new WCF Data Services are created with the other fixes in 5.2.0. If you are only authoring services and you use NuGet to update your dependencies, simply updating to 5.2.0 is sufficient to get the rest of the fixes. (Note, however, that if you don’t run the installer all new services will need to be updated to get the other fixes in 5.2.0.)

What do you think?

As always, we love it when our customers stay on the latest releases and give us feedback about what works, what needs to be improved, and what’s outright broken. If you have any feedback related to this release, please leave a comment below or e-mail me at mastaffo@microsoft.com.

WCF Data Services 5.2.0-rc1 Prerelease

dpblogs — Fri, 07 Dec 2012 22:38:11 GMT

A couple of days ago we posted a new set of NuGet packages and today we posted a new tools installer for WCF Data Services 5.2.0-rc1. This prerelease integrates the UriParser from ODataLib Contrib and fixes a few bugs.

What is in the prerelease

This prerelease contains the following noteworthy bug fixes:

Fixes an issue where code gen for exceedingly large models would cause VS to crash
Provides a better error message when the service model exposes enum properties
Fixes an issue where IgnoreMissingProperties did not work properly with the new JSON format
Fixes an issue where an Atom response is unable to be read if the client is set to use the new JSON format

URI Parser

In this release ODataLib now provides a way to parse filter and orderby expressions into a metadata-bound abstract syntax tree (AST). This functionality is typically intended to be consumed by higher level libraries such as WCF Data Services and Web API.

To parse a filter expression, use the following method on the new class ODataUriParser:

public static FilterClause ParseFilter(
    string filter,
    IEdmModel model,
    IEdmType elementType,
    IEdmEntitySet entitySet)

The ParseFilter method returns a FilterClause object. The Expression property on the FilterClause contains the root node of the AST that represents the filter expression. In order to walk the AST, use the Visitor pattern to handle an arbitrary QueryNode by examining the Kind property, and then casting accordingly. For instance:

switch (node.Kind)
{
    case QueryNodeKind.BinaryOperator:
        return Visit((BinaryOperatorNode)node);
    case QueryNodeKind.UnaryOperator:
        return Visit((UnaryOperatorNode)node);
    case QueryNodeKind.SingleValuePropertyAccess:
        return Visit((SingleValuePropertyAccessNode)node);
     // And so on...
}

Let’s say the filter string was "Name eq 'Bob'", and Name is a property on the elementType provided to ParseFilter. This expression is represented by a BinaryOperatorNode. The BinaryOperatorNode has a Left expression, which is a SingleValuePropertyAccessNode, capturing the Name property, and a Right expression, which is a ConstantNode, capturing the string literal 'Bob'.

To parse an orderby expression, use ODataUriParser.ParseOrderBy. This method is very similar to ParseFilter. The resulting OrderByClause also has an Expression property, which is an AST just like FilterClause. Since an $orderby system query option can specify more than one ordering expression, there is a ThenBy property on OrderByClause that points to the next OrderByClause. So in essence, you get a linked list of OrderByClause objects. For example, the string "Name asc, ShoeSize desc" would result in an OrderByClause with an Expression capturing the Name property, and a ThenBy property pointing to another OrderByClause capturing the intent to order by the ShoeSize in descending order.

For a more detailed write-up on filter and orderby parsing, read this blog post.

Feedback Please

We’d love to hear how well this release works for your service. Even if you don’t need the URI Parser functionality, please consider trying these new bits and providing us with feedback whether everything goes perfectly or you run into problems. As always, please feel free to leave a comment below or e-mail me directly at mastaffo@microsoft.com.

Using Add Service Reference with OData services after installing Windows Phone SDK 8.0

dpblogs — Wed, 31 Oct 2012 21:52:07 GMT

In this post, we will talk about how you can continue to consume OData v3 services after installing Windows Phone SDK 8.0.

If you are a developer who is using WCF Data Services to produce OData v3 services in Visual Studio 2012 and also only installed the new Windows Phone SDK 8.0 but not the OData Client Tools for Windows Phone Apps then you may experience a known issue.

After installing Windows Phone SDK 8.0 on your system which has Visual Studio 2012, you will be hitting a known issue if you:

have Visual Studio 2012 installed AND
installed Windows Phone SDK 8.0 AND
did not install the OData Client Tools for Windows Phone Apps AND
want to add or update a service reference for an OData v3 service

In this case, Add Service Reference will reference an older version of data services references instead of the version which supports OData v3. For this reason, you will not be able to immediately consume a v3 service. This is because the Windows Phone SDK 8.0 overwrites some settings which guides Add Service Reference to pull in the right references.

If you hit this issue, please re-run the latest WCF Data Services 5.0 for OData v3 installer. This will restore Add Service Reference for OData v3 services.

We apologize for this inconvenience.

How to update existing Windows Phone 7 OData applications to work with the new client tools

dpblogs — Wed, 31 Oct 2012 16:54:43 GMT

OData Client Tools for Windows Phone Apps is recently released to add support for consuming OData v3 services. You may already have a Windows Phone 7.1 application that consumes OData and want to update it to work with OData V3 services using the new Windows Phone SDK 8.0 and OData Client Tools for Windows Phone Apps.

In this short post we will describe how to update your existing Windows Phone 7 OData applications to take advantage of the new OData v3 support in client tools. This post assumes you already installed Windows Phone SDK 8.0 and OData Client Tools for Windows Phone Apps.

When an existing Windows Phone 7.1 application project is opened in the Windows Phone SDK 8.0, it will be referencing the System.Data.Services.Client.dll which doesn’t exist in the original reference path.

In this new release of the client tools, we re-architected our client assembly and split the one System.Data.Services.Client.dll assembly into four different assemblies. Therefore, these new assemblies need to be referenced to update the project. Fortunately, this is very trivial since we are using Nuget in this release.

Going through the following steps will update your existing project to work with the new client tools:

Remove assembly reference to System.Data.Services.Client.dll
Install the OData Client for Windows Phone Apps Nuget Package (Install-Package Microsoft.Data.Services.Client.WindowsPhone from Package Manager Console). This should add the new references and project should compile.

Now you are ready to enhance your existing application to work with OData v3 services.

OData Client Tools for Windows Phone Apps Now Available

dpblogs — Tue, 30 Oct 2012 19:27:31 GMT

Windows Phone 8 and Windows Phone SDK 8.0 were just announced and we are pleased to announce that OData Client Tools for Windows Phone 8 is also now available from the download center.

OData Client Tools for Windows Phone 8 brings OData V3 support to the Windows Phone platform. This release enables you to consume OData V3 services in your Windows Phone application. More specifically, this exciting release extends the Add Service Reference experience with client-side OData support for developing Windows Phone 7 and Windows Phone 8 applications using Windows Phone SDK 8.0. The tooling adds references that are capable of consuming OData services up to v3.

How can I get the installer?

You can download the installer for OData Client Tools for Windows Phone 8 from the download center. This release is not included with Windows Phone SDK 8.0 and needs to be installed separately. This release model will enable us to make release updates and fixes for the client tools and runtime components in a more efficient way.

If you don’t install the client tools and start using Add Service Reference to consume an OData service you will be prompted with a message such as the below:

You will need to navigate to the page and click on the OData Client Tools for Windows Phone 8 banner to download and install the client tools.

What are the prerequisites?

OData Client Tools for Windows Phone 8 requires Windows Phone SDK 8.0 to be installed.

In addition, Nuget Package Manager v2.1 is required enable Nuget support for Windows Phone 8 projects. Similar to our other platforms, we are embracing Nuget for the Windows Phone 8 platform as well. If you don’t already have the latest version of the Nuget Package Manager, please make sure to update either from within Visual Studio by navigating to Tools->Extensions and Updates or by downloading and installing from Nuget Package Manager v2.1 download page.

What is in this release?

As mentioned at the beginning, this release brings OData V3 support to Windows Phone platform. You can now write Windows Phone 7.1 and Windows Phone 8 applications using Windows Phone SDK 8.0 and take advantage of exciting OData v3 features like:

Spatial: You can now take advantage of the spatial support in OData v3 to create location aware OData enabled phone apps
Actions: You can now invoke actions defined on an OData V3 service.
Any/All Queries: You can now express queries like “are there any customers which have no orders”
Vocabularies: You can now consume vocabularies for creating richer experiences on Windows Phone applications
Properties Defined on Subtypes: You can now have better inheritance support by consuming models which have properties (primitive, complex and navigation) defined on subtypes of the base type associated with the set.
ODataLib/EdmLib: You can now use these lower level libraries on Windows Phone.

We are very excited with this release and we are looking forward to hearing your thoughts. Let us know what you think and feel free to point us to your OData enabled Windows Phone application.