C# 在一对多关系上使用动态linq扩展和jqgrid

我不确定问题的标题是否正确，如果不让我知道，我会更改它。好的，首先我在asp.net应用程序中使用jgrid。我有一个助手，可以设置页面大小、行数并进行排序。问题是，我只能对当前表的参数进行排序。当参数名称来自通过关系连接的单独表时，它不起作用

linq扩展用于orderBy和thenBy，它们都接受字符串参数和排序顺序参数。我曾尝试将字符串参数设置为“WaterSample.Name”，WaterSample是关系中的另一个表，并在该表中命名一个参数，但不幸的是，我在c#中无法这样做，因为我使用的是匿名类型。因此，我的问题是，我是否可以让线扩展在关系中搜索，以找到与属性名称匹配的内容。对不起，如果这是一个有点困惑我还是相当新的林克

我已经包括了下面包含扩展的类

namespace Helpers
{
    [ModelBinder(typeof(GridModelBinder))]
    [Serializable]
    public class JqGridSettings
    {

        public int PageIndex { get; set; }
        public int PageSize { get; set; }
        public string SortColumn { get; set; }
        public string SortOrder { get; set; }
        public string SortColumn2 { get; set; }
        public string SortOrder2 { get; set; }
        public string SortColumn3 { get; set; }
        public string SortOrder3 { get; set; }

        public JqGridSettings()
        {
        }

        /// <summary>
        /// Initializes a new instance of the GridSettings class.
        /// </summary>
        /// <param name="stringData">The string that represents the a GridSettings object.</param>
        public JqGridSettings(string stringData)
        {
            var tempArray = stringData.Split(new[] { "#;" }, StringSplitOptions.None);
            PageSize = int.Parse(tempArray[0]);
            PageIndex = int.Parse(tempArray[1]);
            SortColumn = tempArray[2];
            SortOrder = tempArray[3];
        }

        /// <summary>
        /// Build a string used to cache the current GridSettings object.
        /// </summary>
        /// <returns>A string that represents the current GridSettings object.</returns>
        public override string ToString()
        {
            return string.Format("{0}#;{1}#;{2}#;{3}", PageSize, PageIndex, SortColumn,SortOrder);
        }

        public IQueryable<T> LoadGridData<T>(IQueryable<T> dataSource, out int count)
        {
            var query = dataSource;
            //
            // Sorting and Paging by using the current grid settings.
            //
            query = query.OrderBy<T>(SortColumn, SortOrder);
            if (String.IsNullOrEmpty(SortColumn2) == false)
            {
                query = query.ThenBy<T>(SortColumn2, SortOrder2);
            }
            if (String.IsNullOrEmpty(SortColumn3) == false)
            {
                query = query.ThenBy<T>(SortColumn3, SortOrder3);
            }
            count = query.Count();
            //
            if (PageIndex < 1)
                PageIndex = 1;
            //
            var data = query.Skip((PageIndex - 1) * PageSize).Take(PageSize);
            return data;
        }
    }

    public static class LinqExtensions
    {
        public static IQueryable<T> OrderBy<T>(this IQueryable<T> query, string sortColumn, string direction)
        {
            var methodName = string.Format("OrderBy{0}", direction.ToLower() == "asc" ? "" : "descending");
            var parameter = Expression.Parameter(query.ElementType, "p");
            var memberAccess = sortColumn.Split('.').Aggregate<string, MemberExpression>(null, (current, property) => Expression.Property(current ?? (parameter as Expression), property));

            var orderByLambda = Expression.Lambda(memberAccess, parameter);
            var result = Expression.Call(typeof(Queryable),methodName,new[]{query.ElementType, memberAccess.Type},query.Expression,Expression.Quote(orderByLambda));

            return query.Provider.CreateQuery<T>(result);
        }

        public static IQueryable<T> ThenBy<T>(this IQueryable<T> query, string sortColumn, string direction)
        {
            var methodName = string.Format("ThenBy{0}", direction.ToLower() == "asc" ? "" : "descending");
            var parameter = Expression.Parameter(query.ElementType, "p");
            var memberAccess = sortColumn.Split('.').Aggregate<string, MemberExpression>(null, (current, property) => Expression.Property(current ?? (parameter as Expression), property));

            var orderByLambda = Expression.Lambda(memberAccess, parameter);
            var result = Expression.Call(typeof(Queryable), methodName, new[] { query.ElementType, memberAccess.Type }, query.Expression, Expression.Quote(orderByLambda));

            return query.Provider.CreateQuery<T>(result);
        }
    }

    public class GridModelBinder : IModelBinder
    {
        public object BindModel(ControllerContext controllerContext, ModelBindingContext bindingContext)
        {
            try
            {
                var request = controllerContext.HttpContext.Request;
                return new JqGridSettings
                {
                    PageIndex = int.Parse(request["page"] ?? "1"),
                    PageSize = int.Parse(request["rows"] ?? "50"),
                    SortColumn = request["sidx"] ?? "",
                    SortOrder = request["sord"] ?? "asc",
                };
            }
            catch
            {
                //
                // For unexpected errors use the default settings!
                //
                return null;
            }
        }
    }

}

名称空间帮助程序
{
[ModelBinder（typeof（GridModelBinder））]
[可序列化]
公共类JqGridSettings
{
公共int页索引{get；set；}
公共int PageSize{get；set；}
公共字符串SortColumn{get；set；}
公共字符串排序器{get；set；}
公共字符串SortColumn2{get；set；}
公共字符串排序器2{get；set；}
公共字符串SortColumn3{get；set；}
公共字符串排序器3{get；set；}
公共JqGridSettings（）
{
}
/// 
///初始化GridSettings类的新实例。
/// 
///表示GridSettings对象的名称的字符串。
公共JqGridSettings（字符串stringData）
{
var tempArray=stringData.Split（新的[]{“#”}，StringSplitOptions.None）；
PageSize=int.Parse（tempArray[0]）；
PageIndex=int.Parse（tempArray[1]）；
SortColumn=tempArray[2]；
SortOrder=tempArray[3]；
}
/// 
///生成用于缓存当前GridSettings对象的字符串。
/// 
///表示当前GridSettings对象的字符串。
公共重写字符串ToString（）
{
返回string.Format（“{0}}{1}}{2}{3}”，PageSize，PageIndex，SortColumn，SortOrder）；
}
公共IQueryable LoadGridData（IQueryable数据源，out int计数）
{
var查询=数据源；
//
//使用当前网格设置进行排序和分页。
//
query=query.OrderBy（SortColumn，SortOrder）；
if（String.IsNullOrEmpty（SortColumn2）=false）
{
query=query.ThenBy（SortColumn2，SortOrder2）；
}
if（String.IsNullOrEmpty（SortColumn3）=false）
{
query=query.ThenBy（SortColumn3，SortOrder3）；
}
count=query.count（）；
//
如果（页面索引<1）
PageIndex=1；
//
var data=query.Skip（（PageIndex-1）*PageSize.Take（PageSize）；
返回数据；
}
}
公共静态类LinqExtensions
{
公共静态IQueryable OrderBy（此IQueryable查询，字符串sortColumn，字符串方向）
{
var methodName=string.Format（“OrderBy{0}”，direction.ToLower（）=“asc”？：“descending”）；
var参数=Expression.parameter（query.ElementType，“p”）；
var memberAccess=sortColumn.Split（'.'）.Aggregate（null，（当前，属性）=>Expression.property（当前？？？（参数作为表达式），属性））；
var orderByLambda=Expression.Lambda（memberAccess，参数）；
var result=Expression.Call（typeof（Queryable），methodName，new[]{query.ElementType，memberAccess.Type}，query.Expression，Expression.Quote（orderByLambda））；
返回query.Provider.CreateQuery（结果）；
}
公共静态IQueryable ThenBy（此IQueryable查询，字符串排序列，字符串方向）
{
var methodName=string.Format（“ThenBy{0}”，direction.ToLower（）=“asc”？：“descending”）；
var参数=Expression.parameter（query.ElementType，“p”）；
var memberAccess=sortColumn.Split（'.'）.Aggregate（null，（当前，属性）=>Expression.property（当前？？？（参数作为表达式），属性））；
var orderByLambda=Expression.Lambda（memberAccess，参数）；
var result=Expression.Call（typeof（Queryable），methodName，new[]{query.ElementType，memberAccess.Type}，query.Expression，Expression.Quote（orderByLambda））；
返回query.Provider.CreateQuery（结果）；
}
}
公共类GridModelBinder:IModelBinder
{
公共对象绑定模型（ControllerContext ControllerContext，ModelBindingContext bindingContext）
{
尝试
{
var request=controllerContext.HttpContext.request；
返回新的JqGridSettings
{
PageIndex=int.Parse（请求[“页面”]？？“1”），
PageSize=int.Parse（请求[“行”]？？“50”），
SortColumn=请求[“sidx”]？？“，
SortOrder=请求[“sord”]？？“asc”，
};
}
抓住
{
//
//对于意外错误，请使用默认设置！
//
返回null；
}
}
}
}

---

感谢您的帮助或建议。

数据集中总共有多少行需要显示（数据集将不断增长，因此它将变得相当大。不幸的是，我们没有使用实体框架。那么您使用什么来代替实体框架？据我所知，我们只使用linq。过滤效果很好，如果pr