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

.net c# dynamic-linq entity-framework linq

Question

How to utilize the LINQ OrderBy Clause to conditionally sort the column.

example: I Own a PropertyFilter.OrderBy and Filter.Order . InOrderBy numerous things, such as Name, Address, City, etc.Order I'm not sure how to sort it using conditional columns since it will either be ascending or descending.

Please use the code below as a guide.

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'm not sure what the problem is. I can see that the expression prop uses reflection, but not the prop property. GetValue does not function.

Please assist me with 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 may utilize the dynamic querying, selecting, and sorting supported System.Linq.Dynamic.Core library.

Sample of a 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");

dotnetfiddle is a functional example in its entirety.

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 may use it like this:

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

Hope it's useful to you!

federico scamuzzi

Related Questions

Linq: adding conditions to the where clause conditionally

I have a similar question....(from u in DataContext.Users where u.Division == strUserDiv && u.Age > 18 && u.Height > strHeightinFeet select new DTO_UserMaster { Prop1 = u.Name, }).ToList(); ...Depending on whether those requirements were supplied to the method conducting this query, I want to ad...
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 may choose from a variety of fields to choose how the returned report will be sorted. As I'm iterating over a list of sort fields, my issue is that I can't fully chain the OrderBy and ThenBy methods. I envision something along these lines:...foreach (string sort in data.SortParams) { switch (sort)...
entity-framework linq
asked by acullen72

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

The following LINQ expressions need confirmation or clarification:...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)... Do I have this right that the first approach is...L...
entity-framework linq linq-to-entities performance
asked by one.beat.consumer

C# Linq Column Name as variable

ZZZ_tmp
c# entity-framework linq
asked by Patrick

OrderBy & OrderByDescending DateTime In Generic Repository?

Make use of...Func... instead, assign...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).Sk...
c# datetime entity-framework-6 repository
asked by Jenish Rabadiya

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

In a C# project, I'm utilizing EntityFramework 6.1.3 and SQL Server. Two of my questions should essentially accomplish the same thing....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 >...
entity-framework-6 linq-to-sql sql-server
asked by Vanice

Group By Multiple Column In LINQ in C#

ZZZ_tmp
asp.net-mvc c# entity-framework linq
asked by TanvirArjel

Dynamic LINQ OrderBy Date only on DateTime Object Entity Framework

ZZZ_tmp
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

ZZZ_tmp
c# entity-framework-6 expression lambda linq
asked by NetMage

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

ZZZ_tmp
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