Selective Custom Binding

[Matt Meleski]

Hi,

 I have implemented custom binding  as described in this example:

http://demos.telerik.com/aspnet-mvc/razor/grid/custombinding

It works for me, but I have one question:

I have implemented Custom code for paging.

I would also like to Sort, but do not want to write any custom code to do this.
i.e. I would like to take advantage of the built in sorting for this.

Therefore in my method decorated with the below attribute:

 [GridAction(EnableCustomBinding = true)]
 public ActionResult _CustomBinding(GridCommand command)

Can I do something to invoke the built in/default sorting
Or:
Can I do something in my view to indicate I want to do the default sorting?

Thanks.

[Petur Subev]

Hello Matt,

I am afraid that there is no way to just implement one of the binding responsibilities. You should either implement all of them or you should disable custom binding.

All the best,
Petur Subev
the Telerik team

[Dadv]

Hi,

You could use generic sorter to simplify the job :

    public static class GenericSorter<T>
    {
        public static IQueryable<T> Sort(IQueryable<T> query, IEnumerable<SortDescriptor> sorters)
        {
            int i = 0;
            foreach (var sort in sorters)
            {
                if (i++ == 0)
                    query = GenericSorter<T>.Sort(query, sort.Member, (int)sort.SortDirection);
                else
                    query = GenericSorter<T>.ThenSortBy(query as IOrderedQueryable<T>, sort.Member, (int)sort.SortDirection);
            }

            return query;
        }

        public static IQueryable<T> Sort(IQueryable<T> query, string sortMember, int sortDirection)
        {
            Type tp = typeof(T).GetProperty(sortMember).PropertyType;


            Type sorterType = typeof(GenericSorterDirection<,>).MakeGenericType(typeof(T), tp);

            var sorterObject = Activator.CreateInstance(sorterType);

            string direction = "Ascending";

            if (sortDirection != 0)
            {
                direction = "Descending";
            }

            return (IQueryable<T>)sorterType.GetMethod(direction, new Type[] { typeof(List<T>), typeof(string) })
            .Invoke(sorterObject, new object[] { query, sortMember });
        }

        public static IQueryable<T> Sort(IEnumerable<T> query, string sortMember, int sortDirection)
        {
            Type tp = typeof(T).GetProperty(sortMember).PropertyType;


            Type sorterType = typeof(GenericSorterDirection<,>).MakeGenericType(typeof(T), tp);

            var sorterObject = Activator.CreateInstance(sorterType);

            string direction = "Ascending";

            if (sortDirection != 0)
            {
                direction = "Descending";
            }

            return (IQueryable<T>)sorterType.GetMethod(direction, new Type[] { typeof(List<T>), typeof(string) })
            .Invoke(sorterObject, new object[] { query, sortMember });
        }


        public static IOrderedQueryable<T> ThenSortBy(IOrderedQueryable<T> query, string sortMember, int sortDirection)
        {
            Type tp = typeof(T).GetProperty(sortMember).PropertyType;


            Type sorterType = typeof(GenericSorterDirection<,>).MakeGenericType(typeof(T), tp);

            var sorterObject = Activator.CreateInstance(sorterType);

            string direction = "Ascending";

            if (sortDirection != 0)
            {
                direction = "Descending";
            }

            var temp = sorterType.GetMethod("ThenBy" + direction, new Type[] { typeof(IOrderedQueryable<T>), typeof(string) });
            var temp2 = temp.Invoke(sorterObject, new object[] { query, sortMember });

            return (IOrderedQueryable<T>)temp2;
        }
    }

    internal sealed class GenericSorterDirection<T, PT>
    {
        public IEnumerable<T> Ascending(IEnumerable source, string sortMember)
        {
            var param = Expression.Parameter(typeof(T), "item");

            var sortLambda = Expression.Lambda<Func<T, PT>>(Expression.Convert(Expression.Property(param, sortMember), typeof(PT)), param);

            return source.OfType<T>().AsQueryable<T>().OrderBy<T, PT>(sortLambda);
        }

        public IEnumerable<T> Ascending(IEnumerable<T> source, string sortMember)
        {
            var param = Expression.Parameter(typeof(T), "item");

            var sortLambda = Expression.Lambda<Func<T, PT>>(Expression.Convert(Expression.Property(param, sortMember), typeof(PT)), param);

            return source.AsQueryable<T>().OrderBy<T, PT>(sortLambda);
        }

        public IEnumerable<T> Descending(IEnumerable source, string sortMember)
        {
            var param = Expression.Parameter(typeof(T), "item");

            var sortLambda = Expression.Lambda<Func<T, PT>>(Expression.Convert(Expression.Property(param, sortMember), typeof(PT)), param);

            return source.OfType<T>().AsQueryable<T>().OrderByDescending<T, PT>(sortLambda);
        }

        public IEnumerable<T> Descending(IEnumerable<T> source, string sortMember)
        {
            var param = Expression.Parameter(typeof(T), "item");

            var sortLambda = Expression.Lambda<Func<T, PT>>(Expression.Convert(Expression.Property(param, sortMember), typeof(PT)), param);

            return source.AsQueryable<T>().OrderByDescending<T, PT>(sortLambda);
        }

        public IEnumerable<T> ThenByDescending(IOrderedQueryable<T> source, string sortMember)
        {
            var param = Expression.Parameter(typeof(T), "item");

            var sortLambda = Expression.Lambda<Func<T, PT>>(Expression.Convert(Expression.Property(param, sortMember), typeof(PT)), param);

            return source.ThenByDescending<T, PT>(sortLambda);
        }

        public IEnumerable<T> ThenByAscending(IOrderedQueryable<T> source, string sortMember)
        {
            var param = Expression.Parameter(typeof(T), "item");

            var sortLambda = Expression.Lambda<Func<T, PT>>(Expression.Convert(Expression.Property(param, sortMember), typeof(PT)), param);

            return source.ThenBy<T, PT>(sortLambda);
        }
    }
}