OData.QueryBuilder

Library for creating complex OData queries (OData version 4.01) based on data models with linq syntax.

Benefits

Support:
- nested extenders with a choice of filtering
- operators
  - in
  - any
  - all
- functions
  - date
    - date
  - string and collection
  - type
    - cast
- sorting by several fields with indication of direction
- dynamic properties

Installation

To install OData.QueryBuilder from Visual Studio, find OData.QueryBuilder in the NuGet package manager user interface or enter the following command in the package manager console:

Install-Package OData.QueryBuilder

To add a link to the main dotnet project, run the following command line:

dotnet add package OData.QueryBuilder

Usage

Build instance

As soon as possible, create a new instance of the OData.QueryBuilder object indicating the data models and the optional base path:

var odataQueryBuilder = new ODataQueryBuilder<Your OData root model>(<Your base url>?);

// specify the resource for which the request will be built
odataQueryBuilder.For<Your OData entity model>(s => s.ODataEntity)

ℹ️ OData.Query Builder assumes you are using OData Connected Service and you have a root model otherwise use:

var odataQueryBuilder = new ODataQueryBuilder(<Your base url>?);

// specify the resource for which the request will be built
odataQueryBuilder.For<Your OData entity model>("ODataEntity")

Select request type

The builder allows you to build queries on the key and the list:
- ByKey
  - expand
    - filter
    - select
    - orderby
    - orderby desc
    - skip
    - top
    - count
  - select
- ByList
  - expand
    - filter
    - select
    - orderby
    - orderby desc
    - top
  - filter
  - select
  - orderby
  - orderby desc
  - skip
  - top
  - count

Get Uri request or collection of operators from the builder

odataQueryBuilder.ToUri()
odataQueryBuilder.ToDictionary()

Usage operators

in

.Filter((s, f, o) => o.In(s.ODataKind.ODataCode.Code, new[] { "123", "512" }) && o.In(s.IdType, new[] { 123, 512 }))

$filter=ODataKind/ODataCode/Code in ('123','512') and IdType in (123,512)

any

.Filter((s, f, o) => o.Any(s.ODataKind.ODataCodes, v => v.IdCode == 1)

$filter=ODataKind/ODataCodes/any(v:v/IdCode eq 1)

all

.Filter((s, f, o) => o.All(s.ODataKind.ODataCodes, v => v.IdActive))

$filter=ODataKind/ODataCodes/all(v:v/IdActive)

Usage date functions

date

.Filter((s, f) => f.Date(s.Open) == DateTime.Today)

$filter=date(Open) eq 2019-02-09T00:00:00Z

Usage string and collections functions

contains

.Filter((s, f) => f.Contains(s.ODataKind.ODataCode.Code, "W"))

$filter=contains(ODataKind/ODataCode/Code,'W')

substringof

.Filter((s, f) => f.SubstringOf("W", s.ODataKind.ODataCode.Code))

$filter=substringof('W',ODataKind/ODataCode/Code)

toupper

.Filter((s, f) => f.ToUpper(s.ODataKind.ODataCode.Code) == "TEST_CODE")

$filter=toupper(ODataKind/ODataCode/Code) eq 'TEST_CODE'

tolower

.Filter((s, f) => f.ToLower(s.ODataKind.ODataCode.Code) == "test_code")

$filter=tolower(ODataKind/ODataCode/Code) eq 'test_code'

concat

.Filter((s, f) => f.Concat(s.ODataKind.ODataCode.Code, "_1") == "test_code_1")

$filter=concat(ODataKind/ODataCode/Code, '_1') eq 'test_code_1'

indexof

.Filter((s, f) => f.IndexOf(s.ODataKind.ODataCode.Code, "testCode") == 1)

$filter=indexof(ODataKind/ODataCode/Code,'testCode') eq 1

startswith

.Filter((s, f) => f.StartsWith(s.ODataKind.ODataCode.Code, "test"))

$filter=startswith(ODataKind/ODataCode/Code,'test')

length

.Filter((s, f) => f.Length(s.ODataKind.ODataCode.Code) > 0)

$filter=length(ODataKind/ODataCode/Code) gt 0

Usage type functions

cast

.Filter((s, f) => f.Contains(f.Cast(s.ODataKindNew.ODataCode.Code, "Edm.String"), "55"))

$filter=contains(cast(ODataKindNew/ODataCode/Code,Edm.String),'55')

Usage other functions

ReplaceCharacters

var dictionary = new Dictionary<string, string> { { "&", "%26" } });
var constValue = "3 & 4";
...
.Filter((s, f) => s.ODataKind.ODataCode.Code == f.ReplaceCharacters(
    constValue,
    dictionary)

$filter=ODataKind/ODataCode/Code eq '3 %26 4'

var strings = new string[] {
    "test\\YUYYUT",
    "test1\\YUYY123"
};
...
.Filter((s, f, o) => o.In(s.ODataKind.ODataCode.Code, f.ReplaceCharacters(
    strings,
    new Dictionary<string, string>() { { @"\", "%5C" } })))

$filter=ODataKind/ODataCode/Code in ('test%5C%5CYUYYUT','test1%5C%5CYUYY123')

For use-cases where a property which is used for queries needs to be dynamically resolved (eg. the user chooses the property name to filter on) a special method ODataProperty.FromPath<TProperty>() can be invoked in the query expressions:

...
.Filter(s => ODataProperty.FromPath<int>("IdRule") == 3))

Note that the generic type argument TProperty needs to match the type of the dynamically resolved property in the OData model.

Suppress exceptions

⚠️ May result in loss of control over the expected result.

Suppression of inclusion excludes the whole expression from the request

By default, suppression of function and operator argument exceptions is disabled. To enable it, you must pass the configuration ODataQueryBuilderOptions when initializing the builder with initialization of the SuppressExceptionOfNullOrEmptyFunctionArgs and SuppressExceptionOfNullOrEmptyOperatorArgs properties.

var builder = new ODataQueryBuilder<ODataInfoContainer>("http://mock/odata", new ODataQueryBuilderOptions {
    SuppressExceptionOfNullOrEmptyFunctionArgs = true,
    SuppressExceptionOfNullOrEmptyOperatorArgs = true,
});

var uri = builder
    .For<ODataTypeEntity>(s => s.ODataType)
    .ByList()
    .Filter((s, f, o) => o.In(s.ODataKind.ODataCode.Code, new string[0]) || o.In(s.ODataKind.ODataCode.Code, null)
        && f.Contains(s.ODataKind.ODataCode.Code, default(string)) 
        && o.In(s.IdType, new[] { 123, 512 }))
    .ToUri()