C# Linq datatable动态groupby

最新推荐文章于 2024-08-05 19:30:18 发布
最新推荐文章于 2024-08-05 19:30:18 发布
阅读量9.1k 收藏 11
点赞数 2
分类专栏： LinQ 文章标签： LinQ datatable 动态 c#
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/duan1311/article/details/51769119
版权
这篇博客介绍了如何在C#中扩展Linq的GroupBy方法，以支持DataTable的动态分组。作者针对网上找到的不支持DataTable动态分组的方法进行了修改，使得可以传入分组列名，自动生成相应的Linq表达式。通过一个具体的例子展示了如何使用这个扩展方法，从而简化了对DataTable进行复杂分组的操作。
摘要由CSDN通过智能技术生成

声明：个人技术水平有限，欢迎指正。不喜勿喷
问题：可否传入分组列与合计列，自动进行分组合计
在网上找了很多，发现Scott大神写了一个动态的LinQ拼装方法，但是不支持DataTable的动态方法。个人做了一些修改。先看结果

对groupby 方法进行拓展，入参为一个字符串。（扩展方法在下面，非常长，大神写的源码，自己做了些修改）

举例：groupby 的入参为 字符串：new(Field("col1") as col1,Field("col2") as col2 ),调用结果就相当于一个linq:

var query = from p in source group p by new{ col1 = p.field("col1"),col2 = p.field("col2")}

上述的groupby 方法实现了之后，只要我实现一个动态拼接linq字符串的方法就可以啦！

 //拼写动态的group 字符串

                string vDmyLinq = "";
                for (int i = 0; i < vGroupColumns.Count; i++)
                {
                    if (string.IsNullOrEmpty(vDmyLinq))
                    {
                        vDmyLinq = @"new (Field(@" + i.ToString() + @") as " + vGroupColumns[i];
                    }
                    else
                    {
                        vDmyLinq = vDmyLinq + @" , Field(@" + i.ToString() + @") as " + vGroupColumns[i];
                    }
                }
                if (!string.IsNullOrEmpty(vDmyLinq))
                {
                    vDmyLinq = vDmyLinq + ")";
                }
                //获取group结果
                var queryList = source.AsEnumerable().GroupBy(vDmyLinq, vGroupColumns.ToArray(), types.ToArray());

  
//拼装查询的动态linq
                string vSelector = "";
                //获取分组列
                foreach (string item in vGroupColumns)
                {
                    if (string.IsNullOrEmpty(vSelector))
                    {
                        vSelector = "new(Key." + item + " as " + item;
                    }
                    else
                    {
                        vSelector = vSelector + ",Key." + item + " as " + item;
                    }
                }
                //匹配计算方法，获取要合计的列
                for (int i = 0; i < expColumns.Count; i++)
                {
                    var item = expColumns[i];
                    #region 匹配计算方法
                    string expreesionStr = item.ExpressionStr;
                    string vMethodName = expreesionStr.Substring(0, expreesionStr.IndexOf("("));
                    string linqExpreeMethod = "";
                    CellExpCommon.eExpression sumType;
                    bool l_bIsSumType = Enum.TryParse<CellExpCommon.eExpression>(vMethodName, out sumType);
                    if (l_bIsSumType)
                    {
                        if (sumType == CellExpCommon.eExpression.Avg)
                        {
                            linqExpreeMethod = "Average";


                            vSelector = vSelector + "," + linqExpreeMethod + "(Field(@" + i.ToString() + ")) as " + item.ColumnName;
                        }
                        else if (sumType == CellExpCommon.eExpression.Sum)
                        {
                            linqExpreeMethod = "Sum";


                            vSelector = vSelector + "," + linqExpreeMethod + "(Field(@" + i.ToString() + ")) as " + item.ColumnName;
                        }




                        else if (sumType == CellExpCommon.eExpression.Max)
                        {
                            linqExpreeMethod = "Max";
                            vSelector = vSelector + "," + linqExpreeMethod + "() as " + item.ColumnName;
                        }
                        else if (sumType == CellExpCommon.eExpression.Min)
                        {
                            linqExpreeMethod = "Min";
                            vSelector = vSelector + "," + linqExpreeMethod + "() as " + item.ColumnName;
                        }
                        else if (sumType == CellExpCommon.eExpression.Count)
                        {
                            linqExpreeMethod = "Count";
                            vSelector = vSelector + "," + linqExpreeMethod + "() as " + item.ColumnName;
                        }


                    }
                    #endregion
                    vSumCols.Add(item.ColumnName);
                    sumTypes.Add(table.Columns[item.ColumnName].DataType);
                }
                vSelector = vSelector + ")";


                var queryLIst2 = queryList.Select(vSelector, vSumCols.ToArray(), sumTypes.ToArray());

以上是拼装和调用GroupBy的方法，是不是很简单，只要传入分组列与合计列就OK了！

下面是对Scott大神的代码修改之后的动态拼装修改！也就是实现DataTable的GroupBy拓展方法！

using System.Collections.Generic;
using System.Text;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using System.Reflection.Emit;
using System.Threading;
using System.Data;
using System.Collections;

namespace System.Data
{
    public static class DynamicQueryable
    {

       
        public static IEnumerable Select(this IEnumerable sourceEnum, string keySelector, string[] values, Type[] types)
        {
            if (sourceEnum == null) throw new ArgumentNullException("source");
            if (keySelector == null) throw new ArgumentNullException("keySelector");
            IQueryable source = sourceEnum.AsQueryable();

            LambdaExpression keyLambda = DynamicExpression.ParseLambda(source.ElementType, null, keySelector, values, types);

            return source.Provider.Execute<IEnumerable>(
                 Expression.Call(
                     typeof(Enumerable), "Select",
                     new Type[] { source.ElementType, keyLambda.Body.Type },
                     source.Expression, keyLambda
                     )
                     );
        }
       
        public static IEnumerable GroupBy(this IEnumerable<DataRow> sourceEnum, string keySelector, string[] values,Type[] types)
        {
            if (sourceEnum == null) throw new ArgumentNullException("source");
            if (keySelector == null) throw new ArgumentNullException("keySelector");
            IQueryable<DataRow> source = sourceEnum.AsQueryable();

            LambdaExpression keyLambda = DynamicExpression.ParseLambda(source.ElementType, null, keySelector, values,types);

            return source.Provider.Execute<IEnumerable>(
                 Expression.Call(
                     typeof(Enumerable), "GroupBy",
                     new Type[] { source.ElementType, keyLambda.Body.Type },
                     source.Expression, keyLambda
                     )
                     );
        }
        public static IQueryable<T> Where<T>(this IQueryable<T> source, string predicate, params object[] values)
        {
            return (IQueryable<T>)Where((IQueryable)source, predicate, values);
        }

        public static IQueryable Where(this IQueryable source, string predicate, params object[] values)
        {
            if (source == null) throw new ArgumentNullException("source");
            if (predicate == null) throw new ArgumentNullException("predicate");
            LambdaExpression lambda = DynamicExpression.ParseLambda(source.ElementType, typeof(bool), predicate, values);
            return source.Provider.CreateQuery(
                Expression.Call(
                    typeof(Queryable), "Where",
                    new Type[] { source.ElementType },
                    source.Expression, Expression.Quote(lambda)));
        }

        public static IQueryable Select(this IQueryable source, string selector, params object[] values)
        {
            if (source == null) throw new ArgumentNullException("source");
            if (selector == null) throw new ArgumentNullException("selector");
            LambdaExpression lambda = DynamicExpression.ParseLambda(source.ElementType, null, selector, values);
            return source.Provider.CreateQuery(
                Expression.Call(
                    typeof(Queryable), "Select",
                    new Type[] { source.ElementType, lambda.Body.Type },
                    source.Expression, Expression.Quote(lambda)));
        }

        public static IQueryable<T> OrderBy<T>(this IQueryable<T> source, string ordering, params object[] values)
        {
            return (IQueryable<T>)OrderBy((IQueryable)source, ordering, values);
        }

        public static IQueryable OrderBy(this IQueryable source, string ordering, params object[] values)
        {
            if (source == null) throw new ArgumentNullException("source");
            if (ordering == null) throw new ArgumentNullException("ordering");
            ParameterExpression[] parameters = new ParameterExpression[] {
                Expression.Parameter(source.ElementType, "") };
            ExpressionParser parser = new ExpressionParser(parameters, ordering, values);
            IEnumerable<DynamicOrdering> orderings = parser.ParseOrdering();
            Expression queryExpr = source.Expression;
            string methodAsc = "OrderBy";
            string methodDesc = "OrderByDescending";
            foreach (DynamicOrdering o in orderings)
            {
                queryExpr = Expression.Call(
                    typeof(Queryable), o.Ascending ? methodAsc : methodDesc,
                    new Type[] { source.ElementType, o.Selector.Type },
                    queryExpr, Expression.Quote(Expression.Lambda(o.Selector, parameters)));
                methodAsc = "ThenBy";
                methodDesc = "ThenByDescending";
            }
            return source.Provider.CreateQuery(queryExpr);
        }

        public static IQueryable Take(this IQueryable source, int count)
        {
            if (source == null) throw new ArgumentNullException("source");
            return source.Provider.CreateQuery(
                Expression.Call(
                    typeof(Queryable), "Take",
                    new Type[] { source.ElementType },
                    source.Expression, Expression.Constant(count)));
        }

        public static IQueryable Skip(this IQueryable source, int count)
        {
            if (source == null) throw new ArgumentNullException("source");
            return source.Provider.CreateQuery(
                Expression.Call(
                    typeof(Queryable), "Skip",
                    new Type[] { source.ElementType },
                    source.Expression, Expression.Constant(count)));
        }

        public static IQueryable GroupBy(this IQueryable source, string keySelector, string elementSelector, params object[] values)
        {
            if (source == null) throw new ArgumentNullException("source");
            if (keySelector == null) throw new ArgumentNullException("keySelector");
            if (elementSelector == null) throw new ArgumentNullException("elementSelector");
            LambdaExpression keyLambda = DynamicExpression.ParseLambda(source.ElementType, null, keySelector, values);
            LambdaExpression elementLambda = DynamicExpression.ParseLambda(source.ElementType, null, elementSelector, values);
            return source.Provider.CreateQuery(
                Expression.Call(
                    typeof(Queryable), "GroupBy",
                    new Type[] { source.ElementType, keyLambda.Body.Type, elementLambda.Body.Type },
                    source.Expression, Expression.Quote(keyLambda), Expression.Quote(elementLambda)));
        }

        public static bool Any(this IQueryable source)
        {
            if (source == null) throw new ArgumentNullException("source");
            return (bool)source.Provider.Execute(
                Expression.Call(
                    typeof(Queryable), "Any",
                    new Type[] { source.ElementType }, source.Expression));
        }

        public static int Count(this IQueryable source)
        {
            if (source == null) throw new ArgumentNullException("source");
            return (int)source.Provider.Execute(
                Expression.Call(
                    typeof(Queryable), "Count",
                    new Type[] { source.ElementType }, source.Expression));
        }
    }

    public abstract class DynamicClass
    {
        public override string ToString()
        {
            PropertyInfo[] props = this.GetType().GetProperties(BindingFlags.Instance | BindingFlags.Public);
            StringBuilder sb = new StringBuilder();
            sb.Append("{");
            for (int i = 0; i < props.Length; i++)
            {
                if (i > 0) sb.Append(", ");
                sb.Append(props[i].Name);
                sb.Append("=");
                sb.Append(props[i].GetValue(this, null));
            }
            sb.Append("}");
            return sb.ToString();
        }
    }

    public class DynamicProperty
    {
        string name;
        Type type;

        public DynamicProperty(string name, Type type)
        {
            if (name == null) throw new ArgumentNullException("name");
            if (type == null) throw new ArgumentNullException("type");
            this.name = name;
            this.type = type;
        }

        public string Name
        {
            get { return name; }
        }

        public Type Type
        {
            get { return type; }
        }
    }

    public static class DynamicExpression
    {
        public static Expression Parse(Type resultType, string expression, params object[] values)
        {
            ExpressionParser parser = new ExpressionParser(null, expression, values);
            return parser.Parse(resultType);
        }

        public static LambdaExpression ParseLambda(Type itType, Type resultType, string expression, params object[] values)
        {
            return ParseLambda(new ParameterExpression[] { Expression.Parameter(itType, "") }, resultType, expression, values);
        }
      
        public static LambdaExpression ParseLambda(Type itType, Type resultType, string expression, string[] values,Type[] types)
        {
            return ParseLambda(new ParameterExpression[] { Expression.Parameter(itType, "") }, resultType, expression, values,types);
        }
        public static LambdaExpression ParseLambda(ParameterExpression[] parameters, Type resultType, string expression, params object[] values)
        {
            ExpressionParser parser = new ExpressionParser(parameters, expression, values);
            return Expression.Lambda(parser.Parse(resultType), parameters);
        }
        
        public static LambdaExpression ParseLambda(ParameterExpression[] parameters, Type resultType, string expression, string[] values,Type[] types)
        {
            ExpressionParser parser = new ExpressionParser(parameters, expression, values,types);
            return Expression.Lambda(parser.Parse(resultType), parameters);
        }
        public static Expression<Func<T, S>> ParseLambda<T, S>(string expression, params object[] values)
        {
            return (Expression<Func<T, S>>)ParseLambda(typeof(T), typeof(S), expression, values);
        }

        public static Type CreateClass(params DynamicProperty[] properties)
        {
            return ClassFactory.Instance.GetDynamicClass(properties);
        }

        public static Type CreateClass(IEnumerable<DynamicProperty> properties)
        {
            return ClassFactory.Instance.GetDynamicClass(properties);
        }
    }

    internal class DynamicOrdering
    {
        public Expression Selector;
        public bool Ascending;
    }

    internal class Signature : IEquatable<Signature>
    {
        public DynamicProperty[] properties;
        public int hashCode;

        public Signature(IEnumerable<DynamicProperty> properties)
        {
            this.properties = properties.ToArray();
            hashCode = 0;
            foreach (DynamicProperty p in properties)
            {
                hashCode ^= p.Name.GetHashCode() ^ p.Type.GetHashCode();
            }
        }

        public override int GetHashCode()
        {
            return hashCode;
        }

        public override bool Equals(object obj)
        {
            return obj is Signature ? Equals((Signature)obj) : false;
        }

        public bool Equals(Signature other)
        {
            if (properties.Length != other.properties.Length) return false;
            for (int i = 0; i < properties.Length; i++)
            {
                if (properties[i].Name != other.properties[i].Name ||
                    properties[i].Type != other.properties[i].Type) return false;
            }
            return true;
        }
    }

    internal class ClassFactory
    {
        public static readonly ClassFactory Instance = new ClassFactory();

        static ClassFactory() { }  // Trigger lazy initialization of static fields

        ModuleBuilder module;
        Dictionary<Signature, Type> classes;
        int classCount;
        ReaderWriterLock rwLock;

        private ClassFactory()
        {
            AssemblyName name = new AssemblyName("DynamicClasses");
            AssemblyBuilder assembly = AppDomain.CurrentDomain.DefineDynamicAssembly(name, AssemblyBuilderAccess.Run);
#if ENABLE_LINQ_PARTIAL_TRUST
            new ReflectionPermission(PermissionState.Unrestricted).Assert();
#endif
            try
            {
                module = assembly.DefineDynamicModule("Module");
            }
            finally
            {
#if ENABLE_LINQ_PARTIAL_TRUST
                PermissionSet.RevertAssert();
#endif
            }
            classes = new Dictionary<Signature, Type>();
            rwLock = new ReaderWriterLock();
        }

        public Type GetDynamicClass(IEnumerable<DynamicProperty> properties)
        {
            rwLock.AcquireReaderLock(Timeout.Infinite);
            try
            {
                Signature signature = new Signature(properties);
                Type type;
                if (!classes.TryGetValue(signature, out type))
                {
                    type = CreateDynamicClass(signature.properties);
                    classes.Add(signature, type);
                }
                return type;
            }
            finally
            {
                rwLock.ReleaseReaderLock();
            }
        }

        Type CreateDynamicClass(DynamicProperty[] properties)
        {
            LockCookie cookie = rwLock.UpgradeToWriterLock(Timeout.Infinite);
            try
            {
                string typeName = "DynamicClass" + (classCount + 1);
#if ENABLE_LINQ_PARTIAL_TRUST
                new ReflectionPermission(PermissionState.Unrestricted).Assert();
#endif
                try
                {
                    TypeBuilder tb = this.module.DefineType(typeName, TypeAttributes.Class |
                        TypeAttributes.Public, typeof(DynamicClass));
                    FieldInfo[] fields = GenerateProperties(tb, properties);
                    GenerateEquals(tb, fields);
                    GenerateGetHashCode(tb, fields);
                    Type result = tb.CreateType();
                    classCount++;
                    return result;
                }
最低0.47元/天 解锁文章
编程压力大
关注
专栏目录
C# 使用DataTable的GroupBy,对数据某列进行分组求和
qq_39040714的博客
09-18 1万+
C# 使用DataTable的GroupBy,对数据某列进行分组求和一、需求背景二、使用DataTable创建表及数据三、GroupBy对数据分组求和 一、需求背景 通过Data Table创建多个行，根据MaterialID进行Group By分组，对Qty进行求和运算. 原始数据 Material TotalQTY Qty A 10 1 B 20 1 B 20 2 A 10 3 要获得的数据 Material TotalQTY Qty A 10 4 B
动态构造任意复杂的 Linq Where 表达式
chinaherolts2008的博客
02-19 1753
前言 Linq 是 C# 中一个非常好用的集合处理库，用好了能帮我们简化大量又臭又长的嵌套循环，使处理逻辑清晰可见。EF 查询主要也是依赖 Linq。但是 Linq 相对 sql 也存在一些缺点，最主要的就是动态构造查询的难度。sql 只需要简单进行字符串拼接，操作难c#教程度很低（当然出错也相当容易），而 Linq 表达式由于对强类型表达式树的依赖，动态构造查询表达式基本相当于手写 AST（抽象语法树），可以说难度暴增。 AST 已经进入编译原理的领域，对计算机系统的了解程度需求比一般 crud 写
C# 高级数据处理：深入解析联接 Join 与 GroupJoin 操作的应用与实例演示
最新发布
qq_35320456的博客
08-05 765
LINQ 框架中提供的 join 方法包括 Join 和 GroupJoin。这些方法执行同等联接，即根据 2 个数据源的键是否相等来匹配这 2 个数据源的联接。（与此相较，Transact-SQL 支持除“等于”之外的联接运算符，例如“小于”运算符。）用关系数据库术语表达，就是说 Join 实现了内部联接，这种联接只返回那些在另一个数据集中具有匹配项的对象。GroupJoin 方法在关系数据库术语中没有直接等效项，但实现了内部联接和左外部联接的超集。
C#用DataTable实现Group by数据统计
weixin_30686845的博客
07-04 1215
1、用两层循环计算，前提条件是数据已经按分组的列排好序的。 DataTabledt=newDataTable();dt.Columns.AddRange(newDataColumn[]{newDataColumn("name",typeof(string)), newDataColumn("sex"...
C#DataTable 使用GroupBy方法的lamda 表达式和Linq语句写法
weixin_30750335的博客
10-28 559
DataTable ds = new DataTable(); //1、lamda 表达式写法（推荐） var result = ds.AsEnumerable().GroupBy(s => new{Year = s.Field<int>("Year"), Month = s.Field<int>("Month"), Day = s.Field<int>...
通过Linq 实现DataTable Group By
m0_55208453的博客
01-10 177
static void Main(string[] args){ DataTable dt = new DataTable(); dt.Columns.Add("A"); dt.Columns.Add("B"); dt.Columns.Add("C"); dt.Rows.Add("a1", "b1", "c1"); dt.Rows.Add("a1", "b2"...
如何在datatable中使用groupby进行分组统计
09-03
在这种情况下，可以利用LINQ（Language Integrated Query）的强大功能，尤其是它的GroupBy方法，来实现对DataTable的分组操作。 首先，让我们深入理解一下GroupBy方法。在LINQ中，GroupBy用于将源序列按照一个或多...
C# 在DataTable中使用LINQ
Line834dch738ly的博客
08-24 398
C# 在DataTable中使用LINQ 将LINQ查询结果保存为DataTable IEnumerable<DataRow> results1 = (from myRow in dataFile.AsEnumerable() where myRow.Field<string>("Test Flow Type") == "2" select
用C#实现对DataTable的JOIN,GROUP BY,FILTER,UNIONALL,DISTINCT
06-21
用C#实现对DataTable的JOIN,GROUP BY,FILTER,UNIONALL,DISTINCT
C# 中的GroupBy的动态拼接问题及GroupBy用法介绍
12-31
废话不多说了，直接给大家贴代码了，具体代码如下所示： public class Person { public string FirstName{set;get;} public string LastName{set;get;} public Person(){} public Person(string firstName, string lastName) { FirstName = firstName; LastName = lastName; } } List<Person> personList=new List<Person>(); personList.Add
C# 中的GroupBy的动态拼接问题及GroupBy<>用法介绍
08-28
主要介绍了C# 中的GroupBy的动态拼接问题,在文章给大家提到了C# List泛型集合中的GroupBy<>用法详解，需要的朋友可以参考下
DataTable分组
12-25
C#对DataTable一些小操作。
c#中使用Linq将dataTable进行分组，排序，计数
m0_73960651的博客
05-13 1376
排序操作可以通过OrderBy或方法完成。
c# 对DataTable进行分组group by
01-29 2679
var resultGroupedByColumn = dt.Rows.Cast<DataRow>().GroupBy(r => r.ItemArray[0]);//对索引为0的一列进行分组，结果是集合 转载于:https://www.cnblogs.com/SeNaiTes/p/10332827.html...
c# datatable 分组 group by
xyx_0300的博客
01-04 995
IEnumerable<IGrouping<string, DataRow>> result = datatable.Rows.Cast().GroupBy<DataRow, string>(dr => dr[“AAA”].ToString());//按AAA分组
Linq DataTable /List Group By 操作
cy520ta的博客
05-17 1682
1.linq List<object> group by 累加 var nameVals = (from x in modelParts group x by x.PartName into g select ne...
C# DataTable Group by
06-11
C#中可以使用`DataTable`的`Select`方法和`Compute`方法来实现`Group by`操作，具体实现步骤如下： 1. 使用`DataTable`的`Select`方法筛选出需要分组的数据，并按照分组的列进行排序。 ``` // 假设需要对DataTable中的"Name"列进行分组 DataTable dt = new DataTable(); // ... DataRow[] rows = dt.Select("", "Name ASC"); ``` 2. 使用`Compute`方法对分组后的数据进行聚合操作，将聚合结果存储到一个新的`DataTable`中。 ``` // 新建一个DataTable用于存储聚合结果 DataTable result = new DataTable(); result.Columns.Add("Name", typeof(string)); result.Columns.Add("Count", typeof(int)); // 使用Compute方法进行聚合操作 string currentName = ""; int count = 0; foreach (DataRow row in rows) { string name = row["Name"].ToString(); if (name != currentName) { if (currentName != "") { result.Rows.Add(currentName, count); } currentName = name; count = 1; } else { count++; } } // 添加最后一个分组的聚合结果 result.Rows.Add(currentName, count); ``` 这样就可以实现C#中的`DataTable`的`Group by`操作。当然，也可以使用第三方的开源库，如LINQ to DataSet来实现同样的功能。
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值