{"id":1844,"date":"2013-01-29T17:58:18","date_gmt":"2013-01-29T17:58:18","guid":{"rendered":"https:\/\/blogs.msdn.microsoft.com\/webdev\/2013\/01\/29\/getting-started-with-asp-net-web-api-odata-in-3-simple-steps\/"},"modified":"2013-01-29T17:58:18","modified_gmt":"2013-01-29T17:58:18","slug":"getting-started-with-asp-net-web-api-odata-in-3-simple-steps","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/dotnet\/getting-started-with-asp-net-web-api-odata-in-3-simple-steps\/","title":{"rendered":"Getting started with ASP.NET Web API OData in 3 simple steps"},"content":{"rendered":"

With the upcoming ASP.NET 2012.2 release, we\u2019ll be adding support for OData to Web API. In this blog post, I\u2019ll go over the three simple steps you\u2019ll need to go through to get your first OData service up and running:<\/p>\n

    \n
  1. Creating your EDM model <\/li>\n
  2. Configuring an OData route <\/li>\n
  3. Implementing an OData controller <\/li>\n<\/ol>\n

    Before we dive in, the code snippets in this post won\u2019t work if you\u2019re using the RC build. You can upgrade to using our latest nightly build by taking a look at this helpful blog post<\/a>.<\/p>\n

    1) Creating your EDM model<\/h3>\n

    First, we\u2019ll create an EDM model to represent the data model we want to expose to the world. The ODataConventionModelBuilder class makes this this easy by using a set of conventions to reflect on your type and come up with a reasonable model. Let\u2019s say we want to expose an entity set called Movies that represents a movie collection. In that case, we can create a model with a couple lines of code:<\/p>\n

    \n
    \n
       1:<\/span> ODataConventionModelBuilder modelBuilder = new<\/span> ODataConventionModelBuilder();<\/pre>\n
    <\/p>\n
       2:<\/span> modelBuilder.EntitySet<Movie>("Movies"<\/span>);<\/pre>\n
    <\/p>\n
       3:<\/span> IEdmModel model = modelBuilder.GetEdmModel();<\/pre>\n
    <\/div>\n<\/div>\n
    2) Configuring an OData route<\/h3>\n
    Next, we\u2019ll want to configure an OData route. Instead of using MapHttpRoute the way you would in Web API, the only difference here is that you use MapODataRoute and pass in your model. The model gets used for parsing the request URI as an OData path and routing the request to the right entity set controller and action. This would look like this:<\/p>\n
    \n
    \n
       1:<\/span> config.Routes.MapODataRoute(routeName: "OData"<\/span>, routePrefix: "odata"<\/span>, model: model);<\/pre>\n
    <\/div>\n<\/div>\n
    The route prefix above is the prefix for this particular route. So it would only match request URIs that start with http:\/\/server\/vroot\/odata<\/a>, where vroot is your virtual root. And since the model gets passed in as a parameter to the route, you can actually have multiple OData routes configured with a different model for each route.<\/p>\n
    3) Implementing an OData controller<\/h3>\n
    Finally, we just have to implement our MoviesController to expose our entity set. Instead of deriving from ApiController, you\u2019ll need to derive from ODataController. ODataController is a new base class that wires up the OData formatting and action selection for you. Here\u2019s what an implementation might look like:<\/p>\n
    \n
    \n
       1:<\/span> public<\/span> class<\/span> MoviesController : ODataController<\/pre>\n
    <\/p>\n
       2:<\/span> {<\/pre>\n
    <\/p>\n
       3:<\/span>     List<Movie> _movies = TestData.Movies;<\/pre>\n
    <\/p>\n
       4:<\/span>  <\/pre>\n
    <\/p>\n
       5:<\/span>     [Queryable]<\/pre>\n
    <\/p>\n
       6:<\/span>     public<\/span> IQueryable<Movie> GetMovies()<\/pre>\n
    <\/p>\n
       7:<\/span>     {<\/pre>\n
    <\/p>\n
       8:<\/span>         return<\/span> _movies.AsQueryable();<\/pre>\n
    <\/p>\n
       9:<\/span>     }<\/pre>\n
    <\/p>\n
      10:<\/span>  <\/pre>\n
    <\/p>\n
      11:<\/span>     public<\/span> Movie GetMovie([FromODataUri] int<\/span> key)<\/pre>\n
    <\/p>\n
      12:<\/span>     {<\/pre>\n
    <\/p>\n
      13:<\/span>         return<\/span> _movies[key];<\/pre>\n
    <\/p>\n
      14:<\/span>     }<\/pre>\n
    <\/p>\n
      15:<\/span>  <\/pre>\n
    <\/p>\n
      16:<\/span>     public<\/span> Movie Patch([FromODataUri] int<\/span> key, Delta<Movie> patch)<\/pre>\n
    <\/p>\n
      17:<\/span>     {<\/pre>\n
    <\/p>\n
      18:<\/span>         Movie movieToPatch = _movies[key];<\/pre>\n
    <\/p>\n
      19:<\/span>         patch.Patch(movieToPatch);<\/pre>\n
    <\/p>\n
      20:<\/span>         return<\/span> movieToPatch;<\/pre>\n
    <\/p>\n
      21:<\/span>     }<\/pre>\n
    <\/p>\n
      22:<\/span> }<\/pre>\n
    <\/div>\n<\/div>\n
    There\u2019s a few things to point out here. Notice the [Queryable] attribute on the GetMovies method. This enables OData query syntax on that particular action. So you can apply filtering, sorting, and other OData query options to the results of the action. Next, we have the [FromODataUri] attributes on the key parameters. These attributes instruct Web API that the parameters come from the URI and should be parsed as OData URI parameters instead of as Web API parameters. Finally, Delta<T> is a new OData class that makes it easy to perform partial updates on entities.<\/p>\n
    One important thing to realize here is that the controller name, the action names, and the parameter names all matter. OData controller and action selection work a little differently than they do in Web API. Instead of being based on route parameters, OData controller and action selection is based on the OData meaning of the request URI. So for example if you made a request for http:\/\/server\/vroot\/odata\/$metadata<\/a>, the request would actually get dispatched to a separate special controller that returns the metadata document for the OData service. Notice how the controller name also matches the entity set name we defined previously. I\u2019ll try to go into more depth about OData routing in a future blog post.<\/p>\n
    Instead of deriving from ODataController, you can also choose to derive from EntitySetController. EntitySetController is a convenient base class for exposing entity sets that provides simple methods you can override. It also takes care of sending back the right OData response in a variety of cases, like sending a 404 Not Found if an entity with a certain key could not be found. Here\u2019s what the same implementation as above looks like with EntitySetController:<\/p>\n
    \n
    \n
       1:<\/span> public<\/span> class<\/span> MoviesController : EntitySetController<Movie, int<\/span>><\/pre>\n
    <\/p>\n
       2:<\/span> {<\/pre>\n
    <\/p>\n
       3:<\/span>     List<Movie> _movies = TestData.Movies;<\/pre>\n
    <\/p>\n
       4:<\/span>  <\/pre>\n
    <\/p>\n
       5:<\/span>     [Queryable]<\/pre>\n
    <\/p>\n
       6:<\/span>     public<\/span> override<\/span> IQueryable<Movie> Get()<\/pre>\n
    <\/p>\n
       7:<\/span>     {<\/pre>\n
    <\/p>\n
       8:<\/span>         return<\/span> _movies.AsQueryable();<\/pre>\n
    <\/p>\n
       9:<\/span>     }<\/pre>\n
    <\/p>\n
      10:<\/span>  <\/pre>\n
    <\/p>\n
      11:<\/span>     protected<\/span> override<\/span> Movie GetEntityByKey(int<\/span> key)<\/pre>\n
    <\/p>\n
      12:<\/span>     {<\/pre>\n
    <\/p>\n
      13:<\/span>         return<\/span> _movies[key];<\/pre>\n
    <\/p>\n
      14:<\/span>     }<\/pre>\n
    <\/p>\n
      15:<\/span>  <\/pre>\n
    <\/p>\n
      16:<\/span>     protected<\/span> override<\/span> Movie PatchEntity(int<\/span> key, Delta<Movie> patch)<\/pre>\n
    <\/p>\n
      17:<\/span>     {<\/pre>\n
    <\/p>\n
      18:<\/span>         Movie movieToPatch = _movies[key];<\/pre>\n
    <\/p>\n
      19:<\/span>         patch.Patch(movieToPatch);<\/pre>\n
    <\/p>\n
      20:<\/span>         return<\/span> movieToPatch;<\/pre>\n
    <\/p>\n
      21:<\/span>     }<\/pre>\n
    <\/p>\n
      22:<\/span> }<\/pre>\n
    <\/div>\n<\/div>\n
    Notice how you don\u2019t need [FromODataUri] anymore because EntitySetController has already added it for you on its own action parameters. That\u2019s just one of the several advantages of using EntitySetController as a base class.<\/p>\n
    Now that we have a working OData service, let\u2019s try out a few requests. If you send a request to http:\/\/localhost\/odata\/Movies(2)<\/a> with an \u201capplication\/json\u201d Accept header, you should get a response that looks like this:<\/p>\n
    \n
    \n
       1:<\/span> {<\/pre>\n
    <\/p>\n
       2:<\/span>   "odata.metadata"<\/span>: "http:\/\/localhost\/odata\/$metadata#Movies\/@Element"<\/span>,<\/pre>\n
    <\/p>\n
       3:<\/span>   "ID"<\/span>: 2,<\/pre>\n
    <\/p>\n
       4:<\/span>   "Title"<\/span>: "Gladiator"<\/span>,<\/pre>\n
    <\/p>\n
       5:<\/span>   "Director"<\/span>: "Ridley Scott"<\/span>,<\/pre>\n
    <\/p>\n
       6:<\/span>   "YearReleased"<\/span>: 2000<\/pre>\n
    <\/p>\n
       7:<\/span> }<\/pre>\n
    <\/div>\n<\/div>\n
    On the other hand, if you set an \u201capplication\/atom+xml\u201d Accept header, you might see a response that looks like this:<\/p>\n
    \n
    \n
       1:<\/span> <?<\/span>xml<\/span> version<\/span>="1.0"<\/span> encoding<\/span>="utf-8"<\/span>?><\/span><\/pre>\n
    <\/p>\n
       2:<\/span> <<\/span>entry<\/span> xml:base<\/span>="http:\/\/localhost\/odata\/"<\/span> xmlns<\/span>="http:\/\/www.w3.org\/2005\/Atom"<\/span> xmlns:d<\/span>="http:\/\/schemas.microsoft.com\/ado\/2007\/08\/dataservices"<\/span> xmlns:m<\/span>="http:\/\/schemas.microsoft.com\/ado\/2007\/08\/dataservices\/metadata"<\/span> xmlns:georss<\/span>="http:\/\/www.georss.org\/georss"<\/span> xmlns:gml<\/span>="http:\/\/www.opengis.net\/gml"<\/span>><\/span><\/pre>\n
    <\/p>\n
       3:<\/span>   <<\/span>id<\/span>><\/span>http:\/\/localhost\/odata\/Movies(2)<\/<\/span>id<\/span>><\/span><\/pre>\n
    <\/p>\n
       4:<\/span>   <<\/span>category<\/span> term<\/span>="MovieDemo.Model.Movie"<\/span> scheme<\/span>="http:\/\/schemas.microsoft.com\/ado\/2007\/08\/dataservices\/scheme"<\/span> \/><\/span><\/pre>\n
    <\/p>\n
       5:<\/span>   <<\/span>link<\/span> rel<\/span>="edit"<\/span> href<\/span>="http:\/\/localhost\/odata\/Movies(2)"<\/span> \/><\/span><\/pre>\n
    <\/p>\n
       6:<\/span>   <<\/span>link<\/span> rel<\/span>="self"<\/span> href<\/span>="http:\/\/localhost\/odata\/Movies(2)"<\/span> \/><\/span><\/pre>\n
    <\/p>\n
       7:<\/span>   <<\/span>title<\/span> \/><\/span><\/pre>\n
    <\/p>\n
       8:<\/span>   <<\/span>updated<\/span>><\/span>2013-01-30T19:29:57Z<\/<\/span>updated<\/span>><\/span><\/pre>\n
    <\/p>\n
       9:<\/span>   <<\/span>author<\/span>><\/span><\/pre>\n
    <\/p>\n
      10:<\/span>     <<\/span>name<\/span> \/><\/span><\/pre>\n
    <\/p>\n
      11:<\/span>   <\/<\/span>author<\/span>><\/span><\/pre>\n
    <\/p>\n
      12:<\/span>   <<\/span>content<\/span> type<\/span>="application\/xml"<\/span>><\/span><\/pre>\n
    <\/p>\n
      13:<\/span>     <<\/span>m:properties<\/span>><\/span><\/pre>\n
    <\/p>\n
      14:<\/span>       <<\/span>d:ID<\/span> m:type<\/span>="Edm.Int32"<\/span>><\/span>2<\/<\/span>d:ID<\/span>><\/span><\/pre>\n
    <\/p>\n
      15:<\/span>       <<\/span>d:Title<\/span>><\/span>Gladiator<\/<\/span>d:Title<\/span>><\/span><\/pre>\n
    <\/p>\n
      16:<\/span>       <<\/span>d:Director<\/span>><\/span>Ridley Scott<\/<\/span>d:Director<\/span>><\/span><\/pre>\n
    <\/p>\n
      17:<\/span>       <<\/span>d:YearReleased<\/span> m:type<\/span>="Edm.Int32"<\/span>><\/span>2000<\/<\/span>d:YearReleased<\/span>><\/span><\/pre>\n
    <\/p>\n
      18:<\/span>     <\/<\/span>m:properties<\/span>><\/span><\/pre>\n
    <\/p>\n
      19:<\/span>   <\/<\/span>content<\/span>><\/span><\/pre>\n
    <\/p>\n
      20:<\/span> <\/<\/span>entry<\/span>><\/span><\/pre>\n
    <\/div>\n<\/div>\n
    As you can see, the Json.NET and DataContractSerializer-based responses you\u2019re used to getting when using Web API controllers get replaced with the OData equivalents when you derive from ODataController.<\/p>\n","protected":false},"excerpt":{"rendered":"
    With the upcoming ASP.NET 2012.2 release, we\u2019ll be adding support for OData to Web API. In this blog post, I\u2019ll go over the three simple steps you\u2019ll need to go through to get your first OData service up and running: Creating your EDM model Configuring an OData route Implementing an OData controller Before we dive […]<\/p>\n","protected":false},"author":449,"featured_media":58792,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[197],"tags":[],"class_list":["post-1844","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-aspnet"],"acf":[],"blog_post_summary":"
    With the upcoming ASP.NET 2012.2 release, we\u2019ll be adding support for OData to Web API. In this blog post, I\u2019ll go over the three simple steps you\u2019ll need to go through to get your first OData service up and running: Creating your EDM model Configuring an OData route Implementing an OData controller Before we dive […]<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/posts\/1844","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/users\/449"}],"replies":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/comments?post=1844"}],"version-history":[{"count":0,"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/posts\/1844\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/media\/58792"}],"wp:attachment":[{"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/media?parent=1844"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/categories?post=1844"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/tags?post=1844"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}