public void Should_be_faster_than_linqToQuerystring()
{
var baseDatetime = new DateTime(2003, 01, 01);
var linqToQueryStringStopwatch = new Stopwatch();
linqToQueryStringStopwatch.Start();
for (int i = 0; i < 10000; i++)
{
var date = baseDatetime.AddDays(i).ToString("s");
var linqToQuerystringFiltered = Data.ConcreteCollection.LinqToQuerystring($"?$filter=Name eq 'Apple' and (Complete eq true or Date gt datetime'{date}')");
}
linqToQueryStringStopwatch.Stop();
var parseStringStopwatch = new Stopwatch();
parseStringStopwatch.Start();
var language = new ODataFilterLanguage();
for (int i = 0; i < 10000; i++)
{
var date = baseDatetime.AddDays(i).ToString("s");
var filter = language.Parse <LinqToQuerystringTestDataFixture.ConcreteClass>($"Name eq 'Apple' and (Complete eq true or Date gt datetime'{date}')");
}
parseStringStopwatch.Stop();
Output.WriteLine($"LinqToQueryString Duration: {linqToQueryStringStopwatch.Elapsed}");
Output.WriteLine($"StringToExpression Duration: {parseStringStopwatch.Elapsed}");
Assert.True(parseStringStopwatch.ElapsedMilliseconds < linqToQueryStringStopwatch.ElapsedMilliseconds);
}
public void Parse(string queryString)
{
if (!string.IsNullOrEmpty(queryString))
{
var queryStrings = HttpUtility.ParseQueryString(queryString);
if (queryStrings.HasKeys() && queryStrings.AllKeys.Contains("$filter"))
{
string filter = queryStrings["$filter"];
var language = new ODataFilterLanguage();
Expression <Func <T, bool> > predicateExpression = language.Parse <T>(filter);
Filter = predicateExpression.Compile();
}
if (queryStrings.HasKeys() && queryStrings.AllKeys.Contains("$top"))
{
string top = queryStrings["$top"];
ParseTop(top);
}
if (queryStrings.HasKeys() && queryStrings.AllKeys.Contains("$skip"))
{
string skip = queryStrings["$skip"];
ParseSkip(skip);
}
if (queryStrings.HasKeys() && queryStrings.AllKeys.Contains("$orderby"))
{
string orderby = queryStrings["$orderby"];
OrderByClause <T> orderbyClause = new OrderByClause <T>();
orderbyClause.Parse(orderby);
Sort = orderbyClause.RootExpression;
SortDirection = orderbyClause.Direction;
}
}
}
public static Expression <Func <T, bool> > ParseFilter <T>(string filter) where T : class
{
var language = new ODataFilterLanguage();
var formatterFilter = FormatFilter(filter);
return(language.Parse <T>(formatterFilter));
}
private static IQueryable <T> ApplyFilter <T>(this IQueryable <T> queryable, string filter)
{
if (string.IsNullOrEmpty(filter))
{
return(queryable);
}
try
{
var pred = ODataFilter.Parse <T>(filter);
return(queryable.Where(pred));
}
catch (Exception e)
{
throw new FormatException("invalid filter", e);
}
}
public Expression <Func <TEntity, bool> > GetFilterPredicate(string filter)
{
Expression <Func <TEntity, bool> > result = null;
if (!string.IsNullOrWhiteSpace(filter))
{
var language = new ODataFilterLanguage();
try
{
result = language.Parse <TEntity>(filter);
}
catch (Exception exception)
{
throw Error.FilterOData(exception);
}
}
return(result);
}
public Expression <Func <WorkOrderClass, bool> > GetFilterPredicate(string filter)
{
Expression <Func <WorkOrderClass, bool> > result = null;
if (!string.IsNullOrWhiteSpace(filter))
{
var language = new ODataFilterLanguage();
try
{
result = language.Parse <WorkOrderClass>(filter);
}
catch (Exception exception)
{
throw new FilterODataException(exception);
}
}
return(result);
}
public FilterDefinition <Flow> GetFilterDefinition(string filter)
{
var filterDefinition = Builders <Flow> .Filter.Empty;
try
{
if (!string.IsNullOrWhiteSpace(filter))
{
var matches = filter.Split(new string[] { " and " }, StringSplitOptions.RemoveEmptyEntries);
if (matches.Count() == 9)
{
var properties = GetFilterProperties(matches);
var source = (from p in properties
where p.Name == FlowFilterProperties.Source
select p.Value).SingleOrDefault();
var operation = (from p in properties
where p.Name == FlowFilterProperties.Operation
select p.Value).SingleOrDefault();
var site = (from p in properties
where p.Name == FlowFilterProperties.Site
select p.Value).SingleOrDefault();
var operationalDepartment = (from p in properties
where p.Name == FlowFilterProperties.OperationalDepartment
select p.Value).SingleOrDefault();
var typePlanning = (from p in properties
where p.Name == FlowFilterProperties.TypePlanning
select p.Value).SingleOrDefault();
var customer = (from p in properties
where p.Name == FlowFilterProperties.Customer
select p.Value).SingleOrDefault();
var productionSite = (from p in properties
where p.Name == FlowFilterProperties.ProductionSite
select p.Value).SingleOrDefault();
var transportType = (from p in properties
where p.Name == FlowFilterProperties.TransportType
select p.Value).SingleOrDefault();
var driverWait = (from p in properties
where p.Name == FlowFilterProperties.DriverWait
select p.Value).SingleOrDefault();
filterDefinition = Builders <Flow> .Filter.Where(x => (x.Filter.Sources.Contains(new FlowSource(source)) || x.Filter.Sources.Contains(new FlowSource("x"))) &&
(x.Filter.Operations.Contains(new FlowOperation(operation)) || x.Filter.Operations.Contains(new FlowOperation("x"))) &&
(x.Filter.Sites.Contains(new FlowSite(site)) || x.Filter.Sites.Contains(new FlowSite("x"))) &&
(x.Filter.OperationalDepartments.Contains(new FlowOperationalDepartment(operationalDepartment)) || x.Filter.OperationalDepartments.Contains(new FlowOperationalDepartment("x"))) &&
(x.Filter.TypePlannings.Contains(new FlowTypePlanning(typePlanning)) || x.Filter.TypePlannings.Contains(new FlowTypePlanning("x"))) &&
(x.Filter.Customers.Contains(new FlowCustomer(customer)) || x.Filter.Customers.Contains(new FlowCustomer("x"))) &&
(x.Filter.ProductionSites.Contains(new FlowProductionSite(productionSite)) || x.Filter.ProductionSites.Contains(new FlowProductionSite("x"))) &&
(x.Filter.TransportTypes.Contains(new FlowTransportType(transportType)) || x.Filter.TransportTypes.Contains(new FlowTransportType("x"))) &&
(x.Filter.DriverWait == driverWait || x.Filter.DriverWait == "x"));
}
else
{
try
{
var language = new ODataFilterLanguage();
var predicate = language.Parse <Flow>(filter);
filterDefinition = predicate;
}
catch (OperationInvalidException ex)
{
throw new FilterODataException(ex.Message);
}
}
}
}
catch (Exception ex)
{
throw new FilterODataException(ex.Message);
}
return(filterDefinition);
}