{"id":4665,"date":"2021-08-26T02:25:56","date_gmt":"2021-08-26T09:25:56","guid":{"rendered":"https:\/\/devblogs.microsoft.com\/odata\/?p=4665"},"modified":"2021-08-26T02:25:56","modified_gmt":"2021-08-26T09:25:56","slug":"support-for-fetching-nested-paths-in-odata-web-api","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/odata\/support-for-fetching-nested-paths-in-odata-web-api\/","title":{"rendered":"Support for fetching nested paths in OData Web API"},"content":{"rendered":"

Background<\/h2>\n

OData services use nested paths to access properties or entities related to a resource. For example, if you want to access orders of a given customer, you would use a request path like:<\/p>\n

http:\/\/localhost:8080\/Customers\/1\/Orders<\/code><\/p>\n

Microsoft.AspNetCore.OData<\/code> 7.x provides two main approaches for handling such requests: convention and attribute routing.<\/p>\n

In the first approach, we create controller actions with conventional naming patterns to handle specific scenarios.<\/p>\n

For example, if you want to handle fetching the customers entity set (\/Customers<\/code>), you would implement a Get()<\/code> method in the CustomersController<\/code> that returns the collection corresponding to the entity set as follows:<\/p>\n

public IActionResult<IQueryable<Customer>> Get()\r\n{\r\n    return Ok(dbContext.Customers);\r\n}<\/pre>\n
To retrieve a single customer by key, you would implement a Get(int key)<\/code> method that returns the requested customer as follows:<\/p>\n
public IActionResult<Customer> Get([FromODataUri] int key)\r\n{\r\n    return Ok(dbContext.Customers.FirstOrDefault(c => c.Id.Equals(key)));\r\n}<\/pre>\n
To handle requests like \/Customers\/1\/Orders<\/code>, you would need to implement GetOrders(int key)<\/code> method as follows:<\/p>\n
public IActionResult<IQueryable<Order>> GetOrders([FromODataUri] int key)\r\n{\r\n     return Ok(dbContext.Customers.SingleOrDefault(c => c.Id.Equals(key))?.Orders);\r\n}<\/pre>\n
The convention-based approach only allows 2 levels of nesting. Beyond that you need to specify each route explicitly using the ODataRoute<\/code> attribute. For example, to handle a route like http:\/\/localhost:8080\/Customers\/1\/Orders\/1\/Items<\/code> you would need to implement an action like:<\/p>\n
[ODataRoute(\"Customers({customerId})\/Orders\/({orderId})\/Items\")]\r\npublic IActionResult<IQueryable<Order>> GetOrderItems(\r\n    [FromODataUri] int customerId,\r\n    [FromODataUri] int orderId)\r\n{\r\n    return Ok(dbContext.Orders.FirstOrDefault(o => o.Id.Equals(orderId) && o.CustomerId.Equals(customerId))?.Items);\r\n}\r\n\r\n<\/pre>\n
With the existing approaches, we would need to implement a different controller action for each property or navigation property we want to access and for each level of nesting we want to support. Sometimes we just want to make it possible for clients to retrieve declared properties without implement special logic for such scenarios. We are introducing a new feature in Microsoft.AspNetCore.OData<\/code> that makes such scenarios much easier to implement.<\/p>\n
Introducing EnableNestedPaths<\/code> Attribute<\/h2>\n
Microsoft.AspNetCore.OData<\/code> 7.5.9 introduces a new EnableNestedPaths<\/code> attribute that allows you to handle all those requests we have mentioned with only a single Get()<\/code> method. The Get()<\/code> action should return a collection (either IQueryable<\/code> or IEnumerable<\/code>) corresponding to the entity set for that controller. For example:<\/p>\n
 <\/p>\n
public class CustomersController\r\n{\r\n\r\n    [EnableNestedPaths]\r\n\r\n    public IActionResult<IQueryable<Customer>> Get()\r\n    {\r\n\r\n        return Ok(dbContext.Customers);\r\n\r\n    }\r\n\r\n}<\/pre>\n
 <\/p>\n
Now this method will handle all GET<\/code> requests to with \/Customers<\/code> as the navigation source, with a few exceptions (explained later in this article). However, if you still have actions that handle specific requests like Get(int key)<\/code>, GetOrders(int key)<\/code>, etc., then those actions will take precedence. The EnableNestedPaths<\/code> attribute only handles requests for which no other controller action is set to handle. To illustrate this point, let us assume we have the following controller in our application:<\/p>\n
public class CustomersController\r\n{\r\n\r\n    [EnableNestedPaths]\r\n\r\n    public IActionResult<IQueryable<Customer>> Get() { \/*... *\/}\r\n\r\n    public IActionResult<Customer> Get(int key) { \/* ... *\/ }\r\n\r\n    public IActionResult<IQueryable<Order>> GetOrders(int key) {\/* ... *\/}\r\n\r\n}<\/pre>\n
The following table shows which controller actions will receive the specified requests:<\/p>\n\n\n\n\n\n\n\n\n
Path<\/strong><\/td>\nAction<\/strong><\/td>\n<\/tr>\n
\/Customers<\/code><\/td>\nGet()<\/code><\/td>\n<\/tr>\n
\/Customers(1)<\/code><\/td>\nGet(int key)<\/code><\/td>\n<\/tr>\n
\/Customers(1)\/Orders<\/code><\/td>\nGetOrders(int key)<\/code><\/td>\n<\/tr>\n
\/Customers(1)\/Name<\/code><\/td>\nGet()<\/code><\/td>\n<\/tr>\n
\/Customers(1)\/Orders(2)\/Items<\/code><\/td>\nGet()<\/code><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
 <\/p>\n
The feature also works for singleton controllers. In this case, you should use the SingleResult<T><\/code> wrapper to wrap the object returned by your controller action in an IQueryable<\/code>:<\/p>\n
public class BestCustomerController {\r\n    [EnableNestedPaths]\r\n    public IActionResult<IQueryable<Customer>> Get() {\r\n        return Ok(new SingleResult<Customer>.Create(new [] { this.BestCustomer }.AsQueryable()});\r\n    }\r\n}<\/pre>\n
The action should either be called Get<\/code> or Get{NavigationSource}<\/code> (e.g. GetCustomers<\/code> for the entity set, GetBestCustomer<\/code> for the singleton).<\/p>\n
The EnableNestedPaths<\/code> attribute applies query transformations to the collection returned by your controller action to retrieve the data that matches the path being requested. You can use EnableNestedPaths<\/code> alongside EnableQuery<\/code> attribute to allow query options to be automatically applied to your results. The query transformations from EnableNestedPaths<\/code> are applied before those from EnableQuery<\/code>.<\/p>\n
Current Limitations<\/h2>\n