如何在C#中使用linq查询动态分组列表和选择值？

我有一个输入列表测试

class Tracker
{
    public string Toolid {get;set;}
    public string Description {get;set;}
    public int length {get;set;}
    public int breadth {get;set;}
    public int height {get;set;}

}

List<Tracker> test = new List<Tracker>();
test.Add( new Tracker {Toolid="A.1",Description ="ABC",length = 10, breadth =10,height = 50});
test.Add( new Tracker {Toolid="A.1",Description ="ABC", length = 10, breadth =10,height = 50});
test.Add( new Tracker {Toolid="C.1",Description ="ABCD", length = 10, breadth =10,height = 50});
test.Add( new Tracker {Toolid="D.1",Description ="Admin123", length = 10, breadth =10,height = 50});

类跟踪器
{
公共字符串工具ID{get；set；}
公共字符串说明{get；set；}
公共整数长度{get；set；}
公共整数宽度{get；set；}
公共整数高度{get；set；}
}
列表测试=新列表（）；
添加（新跟踪器{Toolid=“A.1”，Description=“ABC”，长度=10，宽度=10，高度=50}）；
添加（新跟踪器{Toolid=“A.1”，Description=“ABC”，长度=10，宽度=10，高度=50}）；
添加（新跟踪器{Toolid=“C.1”，Description=“ABCD”，长度=10，宽度=10，高度=50}）；
添加（新跟踪器{Toolid=“D.1”，Description=“Admin123”，长度=10，宽度=10，高度=50}）；

此列表包含更多值，如重量、颜色等。 为了更好地理解，我只在类Tracker中添加了5个成员变量

我需要根据另一个列表的值（grpList）对列表进行分组。 此列表（grpList）是动态的，因此列表中的参数和值的数量可能会更改。 所以我需要一个使用LINQ查询的动态分组列表。

案例1：有时此列表grpList包含2个值

List <string> grpList = new List<string>();

grpList.Add(ToolId);
grpList.Add(Description);

List grpList=new List（）；
grpList.Add（工具ID）；
grpList.添加（说明）；

如果是这样，我必须将列表test与ToolId和描述分组

案例2：如果列表grpList包含N个值，我必须使用“N”值对列表test进行分组

grpList中的值的数量各不相同。我使用grpList中的值对主列表测试进行分组。如果grpList包含2个值，则将测试列表分组为2个值。如果grpList包含5个值，则用5个值对测试列表进行分组

注意：我需要对列表进行分组测试（主列表）
grpList仅用于分组的值。

尝试反射：

List<string> grpList = new List<string>();
grpList.Add("Toolid");
grpList.Add("Description");

var groups = new Dictionary<string, IEnumerable>();
var all_properties = typeof(Tracker).GetProperties();

foreach ( var prop_name in grpList )
{
    var prop = all_properties.First( x => x.Name == prop_name);
    var group = test.GroupBy( x =>  prop.GetValue( x ) );
    groups.Add( prop_name, group );
}

尝试反射：

List<string> grpList = new List<string>();
grpList.Add("Toolid");
grpList.Add("Description");

var groups = new Dictionary<string, IEnumerable>();
var all_properties = typeof(Tracker).GetProperties();

foreach ( var prop_name in grpList )
{
    var prop = all_properties.First( x => x.Name == prop_name);
    var group = test.GroupBy( x =>  prop.GetValue( x ) );
    groups.Add( prop_name, group );
}

---

我使用了Enumerable.GroupBy方法选择器谓词。 下面是我如何生成谓词和解决方案的

public class Tracker
    {
        public string Toolid { get; set; }
        public string Description { get; set; }
        public int length { get; set; }
        public int breadth { get; set; }
        public int height { get; set; }
    }
    class Program
    {
        static void Main(string[] args)
        {
            List<Tracker> test = new List<Tracker>();
            test.Add(new Tracker { Toolid = "A.1", Description = "ABC", length = 50, breadth = 10, height = 50 });
            test.Add(new Tracker { Toolid = "A.1", Description = "ABC", length = 20, breadth = 10, height = 50 });
            test.Add(new Tracker { Toolid = "C.1", Description = "LMN", length = 10, breadth = 10, height = 50 });
            test.Add(new Tracker { Toolid = "D.1", Description = "Admin123", length = 7, breadth = 10, height = 50 });

            List<string> grpList = new List<string>();
            grpList.Add("length");
            grpList.Add("Description");

            var sourceParm = Expression.Parameter(typeof(Tracker), "x");
            List<Expression> propertyExpressions = new List<Expression>();
            foreach (var f in grpList.ToArray())
            {
                Expression conv = Expression.Convert(Expression.Property(sourceParm, f), typeof(object));
                propertyExpressions.Add(conv);
            }

            var concatMethod = typeof(string).GetMethod(
                                                   "Concat",
                                                    new[] { typeof(object), typeof(object), typeof(object) });
            Expression body = propertyExpressions.Aggregate((x, y) => Expression.Call(concatMethod, 
                                                                            x,
                                                                            Expression.Constant(","), 
                                                                            y));
            var groupSelector = Expression.Lambda<Func<Tracker, string>>(body, sourceParm);
            var j = test.GroupBy(groupSelector.Compile());
}

公共类跟踪器
{
公共字符串工具ID{get；set；}
公共字符串说明{get；set；}
公共整数长度{get；set；}
公共整数宽度{get；set；}
公共整数高度{get；set；}
}
班级计划
{
静态void Main（字符串[]参数）
{
列表测试=新列表（）；
添加（新跟踪器{Toolid=“A.1”，Description=“ABC”，长度=50，宽度=10，高度=50}）；
添加（新跟踪器{Toolid=“A.1”，Description=“ABC”，长度=20，宽度=10，高度=50}）；
添加（新跟踪器{Toolid=“C.1”，Description=“LMN”，长度=10，宽度=10，高度=50}）；
添加（新跟踪器{Toolid=“D.1”，Description=“Admin123”，长度=7，宽度=10，高度=50}）；
List grpList=新列表（）；
加上（“长度”）；
grpList.添加（“说明”）；
var sourceParm=Expression.Parameter（typeof（Tracker），“x”）；
List propertyExpressions=新列表（）；
foreach（grpList.ToArray（）中的变量f）
{
Expression conv=Expression.Convert（Expression.Property（sourceParm，f），typeof（object））；
propertyExpressions.Add（conv）；
}
var concatMethod=typeof（string）.GetMethod(
“海螺”，
新[]{typeof（object）、typeof（object）、typeof（object）}；
Expression body=propertyExpressions.Aggregate（（x，y）=>Expression.Call（concatMethod，
x,，
表达式。常量（“，”，
y） ）；
var groupSelector=Expression.Lambda（body，sourceParm）；
var j=test.GroupBy（groupSelector.Compile（））；
}

我使用了Enumerable.GroupBy方法选择器谓词。 下面是我如何生成谓词和解决方案的

public class Tracker
    {
        public string Toolid { get; set; }
        public string Description { get; set; }
        public int length { get; set; }
        public int breadth { get; set; }
        public int height { get; set; }
    }
    class Program
    {
        static void Main(string[] args)
        {
            List<Tracker> test = new List<Tracker>();
            test.Add(new Tracker { Toolid = "A.1", Description = "ABC", length = 50, breadth = 10, height = 50 });
            test.Add(new Tracker { Toolid = "A.1", Description = "ABC", length = 20, breadth = 10, height = 50 });
            test.Add(new Tracker { Toolid = "C.1", Description = "LMN", length = 10, breadth = 10, height = 50 });
            test.Add(new Tracker { Toolid = "D.1", Description = "Admin123", length = 7, breadth = 10, height = 50 });

            List<string> grpList = new List<string>();
            grpList.Add("length");
            grpList.Add("Description");

            var sourceParm = Expression.Parameter(typeof(Tracker), "x");
            List<Expression> propertyExpressions = new List<Expression>();
            foreach (var f in grpList.ToArray())
            {
                Expression conv = Expression.Convert(Expression.Property(sourceParm, f), typeof(object));
                propertyExpressions.Add(conv);
            }

            var concatMethod = typeof(string).GetMethod(
                                                   "Concat",
                                                    new[] { typeof(object), typeof(object), typeof(object) });
            Expression body = propertyExpressions.Aggregate((x, y) => Expression.Call(concatMethod, 
                                                                            x,
                                                                            Expression.Constant(","), 
                                                                            y));
            var groupSelector = Expression.Lambda<Func<Tracker, string>>(body, sourceParm);
            var j = test.GroupBy(groupSelector.Compile());
}

公共类跟踪器
{
公共字符串工具ID{get；set；}
公共字符串说明{get；set；}
公共整数长度{get；set；}
公共整数宽度{get；set；}
公共整数高度{get；set；}
}
班级计划
{
静态void Main（字符串[]参数）
{
列表测试=新列表（）；
添加（新跟踪器{Toolid=“A.1”，Description=“ABC”，长度=50，宽度=10，高度=50}）；
添加（新跟踪器{Toolid=“A.1”，Description=“ABC”，长度=20，宽度=10，高度=50}）；
添加（新跟踪器{Toolid=“C.1”，Description=“LMN”，长度=10，宽度=10，高度=50}）；
添加（新跟踪器{Toolid=“D.1”，Description=“Admin123”，长度=7，宽度=10，高度=50}）；
List grpList=新列表（）；
加上（“长度”）；
grpList.添加（“说明”）；
var sourceParm=Expression.Parameter（typeof（Tracker），“x”）；
List propertyExpressions=新列表（）；
foreach（grpList.ToArray（）中的变量f）
{
Expression conv=Expression.Convert（Expression.Property（sourceParm，f），typeof（object））；
propertyExpressions.Add（conv）；
}
var concatMethod=typeof（string）.GetMethod(
“海螺”，
新[]{typeof（object）、typeof（object）、typeof（object）}；
表达式体=propertyExpressions.Aggregate