Live Chat Icon For mobile
Live Chat Icon
Popular Categories.NET  (141).NET Core  (21)Angular  (37)ASP.NET  (47)ASP.NET Core  (52)ASP.NET MVC  (83)Azure  (26)Blazor  (42)DocIO  (18)Essential JS 2  (63)Essential Studio  (158)Flutter  (37)JavaScript  (131)Microsoft  (95)PDF  (46)React  (28)Succinctly series  (118)Syncfusion  (371)TypeScript  (30)Uno Platform  (2)UWP  (4)Vue  (24)Webinar  (12)Windows Forms  (52)WPF  (84)Xamarin  (101)XlsIO  (19)Other CategoriesBarcode  (4)BI  (29)Bold BI  (3)Build conference  (6)Business intelligence  (53)Button  (4)C#  (97)Chart  (36)Cloud  (8)Company  (445)Dashboard  (4)Data Science  (3)Data Validation  (2)DataGrid  (25)Development  (232)Doc  (7)eBook  (89)Enterprise  (22)Entity Framework  (4)Essential Tools  (14)Excel  (10)Extensions  (6)File Manager  (3)Gantt  (6)Gauge  (3)Git  (3)Grid  (24)HTML  (8)Installer  (1)Knockout  (2)LINQPad  (1)Linux  (1)M-Commerce  (1)Metro Studio  (11)Mobile  (123)Mobile MVC  (9)OLAP server  (1)Orubase  (12)Partners  (20)PDF viewer  (14)PHP  (1)PivotGrid  (4)Predictive Analytics  (6)Report Server  (3)Reporting  (10)Reporting / Back Office  (11)Rich Text Editor  (5)Road Map  (9)Scheduler  (12)SfDataGrid  (7)Silverlight  (21)Sneak Peek  (10)Solution Services  (2)Spreadsheet  (2)SQL  (3)Stock Chart  (1)Surface  (4)Tablets  (5)Theme  (8)Tips and Tricks  (10)UI  (51)Uncategorized  (68)Unix  (2)User interface  (38)Visual State Manager  (1)Visual Studio  (12)Visual Studio Code  (6)Web  (77)What's new  (44)Windows 8  (19)Windows App  (1)Windows Phone  (15)Windows Phone 7  (9)WinRT  (26)
Share on twitter
Share on facebook
Share on linkedin

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.

Tags:

Share this post:

Share on twitter
Share on facebook
Share on linkedin

Leave a comment

Popular Now

Be the first to get updates

Subscribe RSS feed
Scroll To Top