OdataToEntity is an easy way to create .Net Core OData services

When .Net Core came out, the old OData ASP.NET Web API version was incompatible with the new platform. This fatal flaw allowed me to create my own implementation of OData on the .Net Core platform. As a result of the creative rethinking of the previous implementation, it came to be understood that she suffered from an over-complicated design with a large number of unnecessary abstractions. The idea was to create an easy-to-use library that requires minimal coding. I present to you OdataToEntity, a library for creating OData services without writing code, you only need a data access context. As a result, to simplify the design of api, it was decided not to use interfaces in the code, and the library has full test coverage. To reduce external dependencies, the library is decoupled from HTTP, which allows you to implement OData on top of any transport. This engineering marvel is built under Framework 4.6.1 or .Net Core 2.0 and uses Microsoft.OData.Core 7.4. The following data contexts are supported:

1. Entity Framework 6.2
2. Entity Framework Core 2.0
3. Linq2Db

How it works

The main idea of ​​the project is to translate OData requests into an expression tree, which is then transmitted to the corresponding data access adapter.

To isolate the library from various ORM APIs, the OdataToEntity.Db.OeDataAdapter abstract class "data access adapter" is used. Each context implements its descendant from this class (Ef6: OeEf6DataAdapter, EfCore: OeEfCoreDataAdapter, Linq2Db: OeLinq2DbDataAdapter).

The data model is based on the OData Entity Data Model (EDM) description model of the data provided by your service. The EDM model is required by the ODataLib library to parse the query string. If user entities are tagged with attributes (System.ComponentModel.DataAnnotations), then the model can be built in a universal way suitable for all data providers.

//Create adapter data access, where OrderContext your DbContext var dataAdapter = new OeEfCoreDataAdapter<Model.OrderContext>(); //Build OData Edm Model EdmModel edmModel = dataAdapter.BuildEdmModel(); 

If the Entity Framework context is used and the Fluent API is used to describe the entities (without using attributes):
Entity Framework Core

 //Create adapter data access, where OrderContext your DbContext var dataAdapter = new OeEfCoreDataAdapter<Model.OrderContext>(); //Build OData Edm Model EdmModel edmModel = dataAdapter.BuildEdmModelFromEfCoreModel(); 

Entity Framework 6

 //Create adapter data access, where OrderEf6Context your DbContext var dataAdapter = new OeEf6DataAdapter<OrderEf6Context>(); //Build OData Edm Model EdmModel edmModel = dataAdapter.BuildEdmModelFromEf6Model(); 

Create a model from multiple data contexts

 //Create referenced data adapter var refDataAdapter = new OeEfCoreDataAdapter<Model.Order2Context>(); //Build referenced Edm Model EdmModel refModel = refDataAdapter.BuildEdmModel(); //Create root data adapter var rootDataAdapter = new OeEfCoreDataAdapter<Model.OrderContext>(); //Build root Edm Model EdmModel rootModel = rootDataAdapter.BuildEdmModel(refModel); 

The library can be used to read and edit data.
In read mode, the OData request is submitted to the library, it is parsed with the help of Microsoft.OData.Core (ODataLib) into the ODataLib representation, which is translated into the usual expression tree. The query is parameterized (i.e., the replacement of constant expressions with variables) and then transferred to the data access adapter. The adapter translates the general expression tree into a more specific, applicable in this data context. Creates a context that makes a query to the database, and the resulting entities are serialized in an OData JSON format.
In the edit mode, the entities of the model serialized in the OData JSON format are served as input to the library. Using ODataLib, it is deserialized into the essence of the data model, which are added to the data access context and stored in the database. Fields computed on the database side are returned to the client. Supported "batch change set" - batch add, delete, change entities. Editing tables describing tree data structures (self-referencing table). For Linq2Db, a data context similar to the DbContext Entity Framework was implemented, allowing you to edit the object graph.

Supported query types

1. $ apply (filter, groupby, aggregate (average, count, virtual property $ count, countdistinct, max, min, sum))
2. $ count
3. $ filter
4. $ orderby
5. $ select
6. $ skip
7. $ top
8. $ compute
9. $ skiptoken
10. lamda any
11. lambda all

Supported Features

1. cast
2. ceiling
3. concat
4. contains
5. day
6. endswith
7. floor
8. fractionalseconds
9. hour
10. indexof
11. length
12. minute
13. month
14. round
15. second
16. startswith
17. substring
18. tolower
19. toupper
20. trim
21. year

Usage example

The following data model is used in tests and examples.

 public sealed class Category { public ICollection<Category> Children { get; set; } public int Id { get; set; } [Required] public String Name { get; set; } public Category Parent { get; set; } public int? ParentId { get; set; } } public sealed class Customer { public String Address { get; set; } [InverseProperty(nameof(Order.AltCustomer))] public ICollection<Order> AltOrders { get; set; } [Key, Column(Order = 0), Required] public String Country { get; set; } [Key, Column(Order = 1)] public int Id { get; set; } [Required] public String Name { get; set; } [InverseProperty(nameof(Order.Customer))] public ICollection<Order> Orders { get; set; } public Sex? Sex { get; set; } } public sealed class Order { [ForeignKey("AltCustomerCountry,AltCustomerId")] public Customer AltCustomer { get; set; } public String AltCustomerCountry { get; set; } public int? AltCustomerId { get; set; } [ForeignKey("CustomerCountry,CustomerId")] public Customer Customer { get; set; } public String CustomerCountry { get; set; } public int CustomerId { get; set; } public DateTimeOffset? Date { get; set; } [DatabaseGenerated(DatabaseGeneratedOption.Identity)] public int Id { get; set; } public ICollection<OrderItem> Items { get; set; } [Required] public String Name { get; set; } public OrderStatus Status { get; set; } } public sealed class OrderItem { public int? Count { get; set; } [DatabaseGenerated(DatabaseGeneratedOption.Identity)] public int Id { get; set; } public Order Order { get; set; } public int OrderId { get; set; } public Decimal? Price { get; set; } [Required] public String Product { get; set; } } public enum OrderStatus { Unknown, Processing, Shipped, Delivering, Cancelled } public enum Sex { Male, Female } public sealed class OrderContext : DbContext { public DbSet<Category> Categories { get; set; } public DbSet<Customer> Customers { get; set; } public DbSet<Order> Orders { get; set; } public DbSet<OrderItem> OrderItems { get; set; } [Description("dbo.GetOrders")] public IEnumerable<Order> GetOrders(int? id, String name, OrderStatus? status) => throw new NotImplementedException(); public void ResetDb() => throw new NotImplementedException(); } 

An example of executing an OData request consists of only five lines:

 //Create adapter data access, where OrderContext your DbContext var dataAdapter = new OeEfCoreDataAdapter<Model.OrderContext>(); //Create query parser var parser = new OeParser(new Uri("http://dummy"), dataAdapter, dataAdapter.BuildEdmModel()); //Query var uri = new Uri("http://dummy/Orders?$select=Name"); //The result of the query var response = new MemoryStream(); //Execute query await parser.ExecuteGetAsync(uri, OeRequestHeaders.JsonDefault, response, CancellationToken.None); 

An example of saving new entities in the database also consists of five lines:

 string batch = @" --batch_6263d2a1-1ddc-4b02-a1c1-7031cfa93691 Content-Type: multipart/mixed; boundary=changeset_e9a0e344-4133-4677-9be8-1d0006e40bb6 --changeset_e9a0e344-4133-4677-9be8-1d0006e40bb6 Content-Type: application/http Content-Transfer-Encoding: binary Content-ID: 1 POST http://dummy/Customers HTTP/1.1 OData-Version: 4.0 OData-MaxVersion: 4.0 Content-Type: application/json;odata.metadata=minimal Accept: application/json;odata.metadata=minimal Accept-Charset: UTF-8 User-Agent: Microsoft ADO.NET Data Services {""@odata.type"":""#OdataToEntity.Test.Model.Customer"",""Address"":""Moscow"",""Id"":1,""Name"":""Ivan"",""Sex@odata.type"":""#OdataToEntity.Test.Model.Sex"",""Sex"":""Male""} --changeset_e9a0e344-4133-4677-9be8-1d0006e40bb6-- --batch_6263d2a1-1ddc-4b02-a1c1-7031cfa93691-- "; //Create adapter data access, where OrderContext your DbContext var dataAdapter = new OeEfCoreDataAdapter<Model.OrderContext>(); //Create query parser var parser = new OeParser(new Uri("http://dummy"), dataAdapter, dataAdapter.BuildEdmModel()); //Serialized entities in JSON UTF8 format var request = new MemoryStream(System.Text.Encoding.UTF8.GetBytes(batch)); //The result of the query var response = new MemoryStream(); //Execute query await parser.ExecuteBatchAsync(request, response, CancellationToken.None); 

An example of the stored procedure

 //Create adapter data access, where OrderContext your DbContext var dataAdapter = new OeEfCoreDataAdapter<Model.OrderContext>(); //Create query parser var parser = new OeParser(new Uri("http://dummy"), dataAdapter, dataAdapter.BuildEdmModel()); //The result of the stored procedure var response = new MemoryStream(); //Execute sored procedure await parser.ExecuteGetAsync(new Uri("http://dummy/GetOrders(name='Order 1',id=1,status=null)"), OeRequestHeaders.JsonDefault, response, CancellationToken.None); 

To set a procedure name other than the method name in c #, you can use the attribute

  [Description("dbo.GetOrders")] public IEnumerable<Order> GetOrders(int? id, String name, OrderStatus? status) => throw new NotImplementedException(); 

Other examples can be found in the test folder.

Paginated data sampling
Server-Driven Paging allows you to get a partial set of data whose size is set using the OeRequestHeaders.SetMaxPageSize method (int maxPageSize) . The server returns the data and a link to the next part in the @ odata.nextLink annotation, where the beginning of the next part of the data is recorded with the $ skiptoken tag. If the query returns data where in the sort the column participates allowing for NULL values ​​in the database (the Required attribute is not specified), you must set the OeDataAdapter.IsDatabaseNullHighestValue property for SQLite, MySql, Sql Server to false, for PostgreSql, Oracle to true.

 //Create adapter data access, where OrderContext your DbContext var dataAdapter = new OeEfCoreDataAdapter<Model.OrderContext>(Model.OrderContext.CreateOptions()) { IsDatabaseNullHighestValue = true //PostgreSql }; //Create query parser var parser = new OeParser(new Uri("http://dummy"), dataAdapter, dataAdapter.BuildEdmModel()); //Query var uri = new Uri("http://dummy/Orders?$select=Name&$orderby=Date"); //Set max page size OeRequestHeaders requestHeaders = OeRequestHeaders.JsonDefault.SetMaxPageSize(10); //The result of the query var response = new MemoryStream(); //Execute query await parser.ExecuteGetAsync(uri, requestHeaders, response, CancellationToken.None); 

If you want to get links, rather than real one-to-many navigation properties data, you must call the OeRequestHeaders.SetNavigationNextLink (true) method.

 //Query var uri = new Uri("http://dummy/Orders?$expand=Items"); //Set max page size, to-many navigation properties OeRequestHeaders requestHeaders = OeRequestHeaders.JsonDefault.SetMaxPageSize(10).SetNavigationNextLink(true); //The result of the query var response = new MemoryStream(); //Execute query await parser.ExecuteGetAsync(uri, requestHeaders, response, CancellationToken.None); 

Entity Framework Core features
For the Entity Framework Core provider, there is the ability to cache queries, which in existing tests allows us to raise the sample rate up to two times. The cache key is a parsed OData query with remote constant values, and the value is the delegate that accepts the data context and returns the result of the query. This allows you to exclude the stage of building the data query itself (IQueryable). To use this feature, use the OeEfCoreDataAdapter constructor (DbContextOptions options, Db.OeQueryCache queryCache) .
To use the DbContext object pool ( DbContextPool ), create an instance of OeEfCoreDataAdapter via the constructor with the DbContextOptions parameter

 //Create adapter data access, where OrderContext your DbContext var dataAdapter = new OeEfCoreDataAdapter<Model.OrderContext>(Model.OrderContext.CreateOptions()); 

Source code structure
The source code is divided into two parts: in the source folder, the library itself and assemblies of access to various data sources, in the test folder, tests and code samples.
Solution files in the sln folder.
The library itself is located in the source / OdataEntity project .
Adapter to the context of the Entity Framework 6.2 source / OdataToEntity.Ef6 .
Adapter to context Entity Framework Core source / OdataToEntity.EfCore .
Adapter to context Linq2Db source / OdataToEntity.Linq2Db .
Routing and base controller classes for Asp .Net Core Mvc source / OdataToEntity.AspNetCore

Tests:
Entity Framework Core in-memory database test / OdataToEntity.Test
Entity Framework Core Sql Server test / OdataToEntity.Test.EfCore.SqlServer
Entity Framework Core PostgreSql test / OdataToEntity.Test.EfCore.PostgreSql
Entity Framework 6 Sql Server test / OdataToEntity.Test.Ef6.SqlServer
Linq2Db Sql Server test / OdataToEntity.Test.Linq2Db

Examples of requests can be viewed in tests.

Examples;
HTTP service test / OdataToEntityCore.Asp / OdataToEntity.Test.AspServer
HTTP Mvc service test / OdataToEntityCore.Asp / OdataToEntity.Test.AspMvcServer
Microsoft.OData.Client client for the HTTP test / OdataToEntityCore.Asp / OdataToEntity.Test.AspClient service
Microsoft.OData.Client client and WCF server source / OdataToEntity.Test.Wcf

An example of a Wcf service contract that works with Microsoft.OData.Client

 [ServiceContract] public interface IOdataWcf { [OperationContract] Task<Stream> Get(String query, String acceptHeader); [OperationContract] Task<OdataWcfPostResponse> Post(OdataWcfPostRequest request); } [MessageContract] public sealed class OdataWcfPostRequest { [MessageHeader] public String ContentType { get; set; } [MessageBodyMember] public Stream RequestStream { get; set; } } [MessageContract] public sealed class OdataWcfPostResponse { [MessageBodyMember] public Stream ResponseStream { get; set; } } 

SQL Server Database Creation Script for test \ OdataToEntity.Test.EfCore.SqlServer \ script.sql tests
PostgreSql database creation script for test \ OdataToEntity.Test.EfCore.PostgreSql \ script.sql tests

→ Source Code
→ Nuget packages