How to Conditionally the column in LINQ OrderByDescending for OrderBy in C#?

.net c# dynamic-linq entity-framework linq

Question

How to Conditionally sort the column using LINQ OrderBy Clause.

ex- I have a Property Filter.OrderBy and Filter.Order . In OrderBy could be many ex> Name, Address ,City etc and Order will be ascending or descending but I am not sure how to sort it with conditional columns

Please find the below code for reference -

IQueryable<Filter> query;

PropertyInfo prop = typeof(Filter).GetProperty(Filter.OrderBy);  

if (Filter.Order ==" Ascending"){
  query = query.OrderBy ( x = > prop.GetValue(x,null));
}
else if (Filter.Order ==" Descending"){
  query = query.OrderByDescending ( x = > prop.GetValue(x,null));
}

But query is failing . I am not sure what is the issue I can see the prop property using reflection but the expression prop.GetValue is not working .

Please help me on this

1
0
3/26/2020 9:40:29 PM

Fastest Entity Framework Extensions

Bulk Insert
Bulk Delete
Bulk Update
Bulk Merge

Accepted Answer

You can use the library System.Linq.Dynamic.Core which supports dynamic querying, selecting and ordering.

Example code:

var q = new List<Person>
{
    new Person{Name = "C", Age = 30 },
    new Person{Name = "A", Age = 7 },
    new Person{Name = "B", Age = 5 }
}.AsQueryable();

var x1 = q.OrderBy("Name asc");

var a1 = q.OrderBy("Age desc");

For a full working example, see dotnetfiddle

0
3/28/2020 3:38:52 PM

Popular Answer

public static class LinqUtils
    {
        /// <summary>
        /// Orders the by.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="source">The source.</param>
        /// <param name="propertyName">Name of the property.</param>
        /// <param name="direction">The direction.</param>
        /// <returns></returns>
        public static IOrderedMongoQueryable<T> OrderBy<T>(this IMongoQueryable<T> source, string propertyName, OrderDirection direction)
        {
            switch (direction)
            {
                case OrderDirection.ASC:
                    return source.OrderBy(ToLambda<T>(propertyName));

                case OrderDirection.DESC:
                    return source.OrderByDescending(ToLambda<T>(propertyName));

                default:
                    return source.OrderBy(ToLambda<T>(propertyName));
            }

        }

        /// <summary>
        /// Orders the by.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="source">The source.</param>
        /// <param name="propertyName">Name of the property.</param>
        /// <param name="direction">The direction.</param>
        /// <returns></returns>
        public static IOrderedMongoQueryable<T> OrderBy<T>(this IMongoQueryable<T> source, string propertyName, int direction)
        {
            var dir = (OrderDirection)direction;

            switch (dir)
            {
                case OrderDirection.ASC:
                    return source.OrderBy(ToLambda<T>(propertyName));

                case OrderDirection.DESC:
                    return source.OrderByDescending(ToLambda<T>(propertyName));

                default:
                    return source.OrderBy(ToLambda<T>(propertyName));
            }

        }


        /// <summary>
        /// Orders the by.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="source">The source.</param>
        /// <param name="propertyName">Name of the property.</param>
        /// <returns></returns>
        public static IOrderedMongoQueryable<T> OrderBy<T>(this IMongoQueryable<T> source, string propertyName)
        {
            return source.OrderBy(ToLambda<T>(propertyName));
        }

        /// <summary>
        /// Orders the by descending.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="source">The source.</param>
        /// <param name="propertyName">Name of the property.</param>
        /// <returns></returns>
        public static IOrderedMongoQueryable<T> OrderByDescending<T>(this IMongoQueryable<T> source, string propertyName)
        {
            return source.OrderByDescending(ToLambda<T>(propertyName));
        }

        /// <summary>
        /// Wheres the specified property name.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="source">The source.</param>
        /// <param name="propertyName">Name of the property.</param>
        /// <param name="stringToSource">The string to source.</param>
        /// <returns></returns>
        public static IMongoQueryable<T> Where<T>(this IMongoQueryable<T> source, string propertyName, string stringToSource)
        {
            return source.Where(ToLambdaWhere<T>(propertyName, stringToSource));
        }


        /// <summary>
        /// Wheres the text.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="query">The query.</param>
        /// <param name="field">The field.</param>
        /// <param name="search">The search.</param>
        /// <returns></returns>
        public static IMongoQueryable<T> WhereText<T>(this IMongoQueryable<T> query, Expression<Func<T, object>> field, string search)
        {

            search = Regex.Escape(search);
            var filter = Builders<T>.Filter.Text(search);
            var member = HelpersLinq.PropertyName<T>(field);

            var regexFilter = string.Format("^{0}.*", search);
            var filterRegex = Builders<T>.Filter.Regex(member, BsonRegularExpression.Create(new Regex(regexFilter, RegexOptions.IgnoreCase)));

            return query.Where(_ => filter.Inject() && filterRegex.Inject());
        }

        /// <summary>
        /// Converts to lambda.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="propertyName">Name of the property.</param>
        /// <returns></returns>
        private static Expression<Func<T, object>> ToLambda<T>(string propertyName)
        {
            var parameter = Expression.Parameter(typeof(T));
            var property = Expression.Property(parameter, propertyName);
            var propAsObject = Expression.Convert(property, typeof(object));

            return Expression.Lambda<Func<T, object>>(propAsObject, parameter);
        }

        /// <summary>
        /// Converts to lambdawhere.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="propertyName">Name of the property.</param>
        /// <param name="stringToSearch">The string to search.</param>
        /// <returns></returns>
        private static Expression<Func<T, bool>> ToLambdaWhere<T>(string propertyName, string stringToSearch)
        {
            //var parameter = Expression.Parameter(typeof(T));

            // Create a parameter to use for both of the expression bodies.
            var parameter = Expression.Parameter(typeof(T), "x");
            // Invoke each expression with the new parameter, and combine the expression bodies with OR.
            var predicate = Expression.Lambda<Func<T, bool>>(Expression.Call(Expression.PropertyOrField(parameter, propertyName), "Contains", null, Expression.Constant(stringToSearch)), parameter);

            return predicate;
        }
    }


    public static class HelpersLinq
    {
        public static string PropertyName<T>(Expression<Func<T, object>> expression)
        {
            var member = expression.Body as MemberExpression;
            if (member != null && member.Member is PropertyInfo)
                return member.Member.Name;

            throw new ArgumentException("Expression is not a Property", "expression");
        }
    }

public enum OrderDirection
{
    ASC = 1,
    DESC
}

So you can use it like :

 initialQuery.OrderBy("Name", OrderDirection.ASC)

Hope it helps you!

federico scamuzzi

Related Questions

Linq: adding conditions to the where clause conditionally

I have a query like this...(from u in DataContext.Users where u.Division == strUserDiv && u.Age > 18 && u.Height > strHeightinFeet select new DTO_UserMaster { Prop1 = u.Name, }).ToList(); ...I want to add the various conditions like age, height based on whether those conditions were provided to ...
entity-framework linq linq-to-sql
asked by user20358

Programmatically chain OrderBy/ThenBy using LINQ / Entity Framework

I have a reporting interface where the end user gets to select multiple fields for the sort order of the returned report. The problem I am having is that I can't really chain the OrderBy / ThenBy methods, since I'm iterating through a list of sort fields. I'm thinking something like this:...foreach (string sort in data.SortParams) { switch (so...
entity-framework linq
asked by acullen72

LINQ to Entities -- OrderBy().ToLisT() vs. ToList().OrderBy()

I'm looking for confirmation/clarification with these LINQ expressions:...var context = new SomeCustomDbContext() // LINQ to Entities? var items = context.CustomItems.OrderBy(i => i.Property).ToList(); // LINQ to Objects? var items2 = context.CustomItems.ToList().OrderBy(i => i.Property); ...(Q1)... Am I correct in thinking the first method is ....
entity-framework linq linq-to-entities performance
asked by one.beat.consumer

C# Linq Column Name as variable

I have a table where I want to make a query on variable columns. Like:...private void query(string column, string value) { using (var db = new myDB()) { var s1 = (from c in db.Components where (**column** == **value**) select new {c.id, **column**}); } } ...lets say I want to look for a supplier...
c# entity-framework linq
asked by Patrick

OrderBy & OrderByDescending DateTime In Generic Repository?

Try using ...Func... delegate instead on ...Expression<Func>...public virtual IQueryable<T> GetAll( Func<T,object> predicate, Sorted _sort = Sorted.ASC, int _max = 0, int _skip = 0 ) { IQueryable<T> query = _sort == Sorted.ASC ? //Sorted is enum _entities.Set<T>().OrderBy(predicate...
c# datetime entity-framework-6 repository
asked by Jenish Rabadiya

OrderBy().FirstOrDefault(<condition>) vs. Where(<condition>).OrderBy().FirstOrDefault()

Im using EntitiyFramework 6.1.3 with SQL Server in a C# Project. I've two queries which basically should do the same....1....Exams.GroupBy(x=>x.SubjectID).Select(x => x.OrderBy(y => y.Level.NumericValue).FirstOrDefault(y => y.Date.Value > DateTime.Today)) ...2....Exams.GroupBy(x=>x.SubjectID).Select(x => x.Where(y => y.Date.Value > DateTime.Today)....
entity-framework-6 linq-to-sql sql-server
asked by Vanice

Group By Multiple Column In LINQ in C#

I have a class like as follows:...public class ActualClass { public string BookName { get; set; } public string IssuerName { get; set; } public DateTime DateOfIssue { get; set; } public bool Status { get; set; } } ...It has following data in the table: ...I would like to group them by ...IssuerName... and ...DateOfIssue... for the f...
asp.net-mvc c# entity-framework linq
asked by TanvirArjel

Dynamic LINQ OrderBy Date only on DateTime Object Entity Framework

You can use the approach from my answer to ...Dynamic Linq + Entity Framework: datetime modifications for dynamic select..., i.e. post process the query expression with custom ...ExpressionVisitor... and replace the unsupported methods with their ...DbFunctions... equivalents. In this particular case, replace the ...DateTime.Date... property with ....
c# entity-framework entity-framework-6 linq linq-to-entities
asked by Ivan Stoev

How to pass an Expression into Entity Framework LINQ query OrderBy clause

This isn't as simple as it seems. You need to combine ...Expression...s or build ...Expression...s to generate what you want, and unfortunately C# doesn't include a lot of help in that area....The easiest approach is to use an extension method for ...LambdaExpression... composition. It depends on some ...Expression... extension methods for replacin...
c# entity-framework-6 expression lambda linq
asked by NetMage

C# Linq-to-Entities OrderByDescending isn't working

You are sorting on a constant value (...sportTeam.Score...) Try ...OrderByDescending(st => st.Score) ...instead of ...OrderByDescending(st => sportTeam.Score)
c# entity-framework-6 linq sql-server
asked by oerkelens

Fastest Entity Framework Extensions

Bulk Insert
Bulk Delete
Bulk Update
Bulk Merge
View more on Stack Overflow

Prime Library

Performance

Expression Evaluator

More Projects...

Related

Licensed under: CC-BY-SA with attribution
Not affiliated with Stack Overflow
Licensed under: CC-BY-SA with attribution
Not affiliated with Stack Overflow