Dynamic LINQ Expressions - I | Syncfusion Blogs
Live Chat Icon For mobile
Live Chat Icon
Popular Categories.NET  (174).NET Core  (29).NET MAUI  (207)Angular  (109)ASP.NET  (51)ASP.NET Core  (82)ASP.NET MVC  (89)Azure  (41)Black Friday Deal  (1)Blazor  (215)BoldSign  (14)DocIO  (24)Essential JS 2  (107)Essential Studio  (200)File Formats  (66)Flutter  (133)JavaScript  (221)Microsoft  (119)PDF  (81)Python  (1)React  (100)Streamlit  (1)Succinctly series  (131)Syncfusion  (915)TypeScript  (33)Uno Platform  (3)UWP  (4)Vue  (45)Webinar  (51)Windows Forms  (61)WinUI  (68)WPF  (159)Xamarin  (161)XlsIO  (36)Other CategoriesBarcode  (5)BI  (29)Bold BI  (8)Bold Reports  (2)Build conference  (8)Business intelligence  (55)Button  (4)C#  (147)Chart  (131)Cloud  (15)Company  (443)Dashboard  (8)Data Science  (3)Data Validation  (8)DataGrid  (63)Development  (628)Doc  (8)DockingManager  (1)eBook  (99)Enterprise  (22)Entity Framework  (5)Essential Tools  (14)Excel  (40)Extensions  (22)File Manager  (7)Gantt  (18)Gauge  (12)Git  (5)Grid  (31)HTML  (13)Installer  (2)Knockout  (2)Language  (1)LINQPad  (1)Linux  (2)M-Commerce  (1)Metro Studio  (11)Mobile  (507)Mobile MVC  (9)OLAP server  (1)Open source  (1)Orubase  (12)Partners  (21)PDF viewer  (43)Performance  (12)PHP  (2)PivotGrid  (4)Predictive Analytics  (6)Report Server  (3)Reporting  (10)Reporting / Back Office  (11)Rich Text Editor  (12)Road Map  (12)Scheduler  (52)Security  (3)SfDataGrid  (9)Silverlight  (21)Sneak Peek  (31)Solution Services  (4)Spreadsheet  (11)SQL  (10)Stock Chart  (1)Surface  (4)Tablets  (5)Theme  (12)Tips and Tricks  (112)UI  (387)Uncategorized  (68)Unix  (2)User interface  (68)Visual State Manager  (2)Visual Studio  (31)Visual Studio Code  (19)Web  (592)What's new  (332)Windows 8  (19)Windows App  (2)Windows Phone  (15)Windows Phone 7  (9)WinRT  (26)

Dynamic LINQ Expressions – I

Generating dynamic LINQ expressions needs a bit of understanding on the IQueryable interface. Check out Matt Warren’s series of posts on implementing the IQueryable interface –> LINQ Links. The strong drive for this post is that everything is strongly typed; of course we have the Dynamic LINQ library that comes in the MSDN sample, but that comes with the overhead of generating strings to perform operations. In many cases, strongly typed usage will result in controlling the flow more accurately.

Let’s take a look at the extensions library that will be used for generating expressions on a dynamic data source that implements IQueryable/IEnumerable. In this post, we will look at generating an OrderBy() query with different parameters defined in the Queryable class. Normally, there are helper classes that have an implementation for generating LINQ expressions for IEnumerable and IQueryable interfaces. The Queryable class defines a wrapper thru which we can make calls to the IQueryProvider implemented for that source type (IQuerable/IEnumerable).

With our implementation we will (1) make our objects AsQueryable() and (2) call the appropriate method from the Queryable class that defines the method.

OrderBy() Query

The OrderBy query generates a simple sort comparer with the property name that is present in the underlying IQueryable source:

/// IQueryable expression for sorting in ascending.

/// /// public static IQueryable OrderBy(this IQueryable source, string propertyName) { var sourceType = source.GetObjectType(); ParameterExpression paramExpression = Expression.Parameter(sourceType, sourceType.Name); MemberExpression memExp = Expression.PropertyOrField(paramExpression, propertyName); LambdaExpression lambda = Expression.Lambda(memExp, paramExpression); return source.Provider.CreateQuery( Expression.Call( typeof(Queryable), “OrderBy”, new Type[] { source.ElementType, lambda.Body.Type }, source.Expression, lambda)); }

Taking a closer look at the functions:

Expression.Parameter – Defines the parameter on which the object is referred. Normally we would assign some parameter for the source in our LINQ expressions, say for the Northwind Orders table:

var orders = Orders.OrderBy( order => order.ShipCountry );

Like so, we can dynamically generate the above expression as:

var ordersQuerable = orders.AsQueryable();

var sortedOrders = ordersQueryable.OrderBy(“ShipCountry”);

You may want to perform multi-sorting on the underlying IEnumerable type. The other OrderBy-related functions that have similar implementation are:

  • OrderByDescending
  • ThenBy
  • ThenByDescending

For building a big expression dynamically, all you have to do is loop thru the collection of sorted columns, and recursively build the expression by calling the OrderBy/OrderByDescending/ThenBy/ThenByDescending in some logical sequence.

Note: OrderByDescending/ThenByDescending will be generated only for an IOrderedQueryable instance. So you need to maintain some kind of an instance that holds IOrderedQueryable from the return set of OrderBy/ThenBy.

Helper Method

This retrieves the underlying object type for the IQueryable source.

private static Type GetObjectType(this IQueryable source)
    var enumerable = source.GetEnumerator();
    var hasItem = enumerable.MoveNext();
    if (hasItem)
        return enumerable.Current.GetType();
    return null;

In the next posts, we will check out generating WHERE/Predicate expressions dynamically.


Share this post:

Popular Now

Be the first to get updates

Subscribe RSS feed