List实现行转列的通用方案
最近在做报表统计方面的需求，涉及到行转列报表。根据以往经验使用SQL可以比较容易完成，这次决定挑战一下直接通过代码方式完成行转列。期间遇到几个问题和用到的新知识这里整理记录一下。
阅读目录
问题介绍
以家庭月度费用为例，可以在[Name,Area,Month]三个维度上随意组合进行分组，三个维度中选择一个做为列显示。
/// <summary>
/// 家庭费用情况
/// </summary>
public class House
{
/// <summary>
/// 户主姓名
/// </summary>
public string Name { get; set; } /// <summary>
/// 所属行政区域
/// </summary>
public string Area { get; set; } /// <summary>
/// 月份
/// </summary>
public string Month { get; set; } /// <summary>
/// 电费金额
/// </summary>
public double DfMoney { get; set; } /// <summary>
/// 水费金额
/// </summary>
public double SfMoney { get; set; } /// <summary>
/// 燃气金额
/// </summary>
public double RqfMoney { get; set; }
}
| 户主-月明细报表 | ||||||
| 户主姓名 | 2016-01 | 2016-02 | ||||
|---|---|---|---|---|---|---|
| 电费 | 水费 | 燃气费 | 电费 | 水费 | 燃气费 | |
| 张三 | 240.9 | 30 | 25 | 167 | 24.5 | 17.9 |
| 李四 | 56.7 | 24.7 | 13.2 | 65.2 | 18.9 | 14.9 |
| 区域-月明细报表 | ||||||
| 区域 | 2016-01 | 2016-02 | ||||
|---|---|---|---|---|---|---|
| 电费 | 水费 | 燃气费 | 电费 | 水费 | 燃气费 | |
| 江夏区 | 2240.9 | 330 | 425 | 5167 | 264.5 | 177.9 |
| 洪山区 | 576.7 | 264.7 | 173.2 | 665.2 | 108.9 | 184.9 |
| 区域月份-户明细报表 | |||||||
| 区域 | 月份 | 张三 | 李四 | ||||
|---|---|---|---|---|---|---|---|
| 燃气费 | 电费 | 水费 | 燃气费 | 电费 | 水费 | ||
| 江夏区 | 2016-01 | 2240.9 | 330 | 425 | 5167 | 264.5 | 177.9 |
| 洪山区 | 2016-01 | 576.7 | 264.7 | 173.2 | 665.2 | 108.9 | 184.9 |
| 江夏区 | 2016-02 | 3240.9 | 430 | 525 | 6167 | 364.5 | 277.9 |
| 洪山区 | 2016-02 | 676.7 | 364.7 | 273.2 | 765.2 | 208.9 | 284.9 |
现在后台查出来的数据是List<House>类型，前台传过来分组维度和动态列字段。
第1个表格前台传给后台参数
{DimensionList:['Name'],DynamicColumn:'Month'}
第2个表格前台传给后台参数
{DimensionList:['Area'],DynamicColumn:'Month'}
第3个表格前台传给后台参数
{DimensionList:['Area','Month'],DynamicColumn:'Name'}
问题描述清楚后，仔细分析后你就会发现这里的难题在于动态分组，也就是怎么根据前台传过来的多个维度对List进行分组。
动态Linq
下面使用System.Linq.Dynamic完成行转列功能，Nuget上搜索System.Linq.Dynamic即可下载该包。
代码进行了封装，实现了通用的List<T>行转列功能。
/// <summary>
/// 动态Linq方式实现行转列
/// </summary>
/// <param name="list">数据</param>
/// <param name="DimensionList">维度列</param>
/// <param name="DynamicColumn">动态列</param>
/// <returns>行转列后数据</returns>
private static List<dynamic> DynamicLinq<T>(List<T> list, List<string> DimensionList, string DynamicColumn, out List<string> AllDynamicColumn) where T : class
{
//获取所有动态列
var columnGroup = list.GroupBy(DynamicColumn, "new(it as Vm)") as IEnumerable<IGrouping<dynamic, dynamic>>;
List<string> AllColumnList = new List<string>();
foreach (var item in columnGroup)
{
if (!string.IsNullOrEmpty(item.Key))
{
AllColumnList.Add(item.Key);
}
}
AllDynamicColumn = AllColumnList;
var dictFunc = new Dictionary<string, Func<T, bool>>();
foreach (var column in AllColumnList)
{
var func = DynamicExpression.ParseLambda<T, bool>(string.Format("{0}==\"{1}\"", DynamicColumn, column)).Compile();
dictFunc[column] = func;
} //获取实体所有属性
Dictionary<string, PropertyInfo> PropertyInfoDict = new Dictionary<string, PropertyInfo>();
Type type = typeof(T);
var propertyInfos = type.GetProperties(BindingFlags.Instance | BindingFlags.Public);
//数值列
List<string> AllNumberField = new List<string>();
foreach (var item in propertyInfos)
{
PropertyInfoDict[item.Name] = item;
if (item.PropertyType == typeof(int) || item.PropertyType == typeof(double) || item.PropertyType == typeof(float))
{
AllNumberField.Add(item.Name);
}
} //分组
var dataGroup = list.GroupBy(string.Format("new ({0})", string.Join(",", DimensionList)), "new(it as Vm)") as IEnumerable<IGrouping<dynamic, dynamic>>;
List<dynamic> listResult = new List<dynamic>();
IDictionary<string, object> itemObj = null;
T vm2 = default(T);
foreach (var group in dataGroup)
{
itemObj = new ExpandoObject();
var listVm = group.Select(e => e.Vm as T).ToList();
//维度列赋值
vm2 = listVm.FirstOrDefault();
foreach (var key in DimensionList)
{
itemObj[key] = PropertyInfoDict[key].GetValue(vm2);
} foreach (var column in AllColumnList)
{
vm2 = listVm.FirstOrDefault(dictFunc[column]);
if (vm2 != null)
{
foreach (string name in AllNumberField)
{
itemObj[name + column] = PropertyInfoDict[name].GetValue(vm2);
}
}
}
listResult.Add(itemObj);
}
return listResult;
}
标红部分使用了System.Linq.Dynamic动态分组功能，传入字符串即可分组。使用了dynamic类型，关于dynamic介绍可以参考其它文章介绍哦。
System.Linq.Dynamic其它用法
上面行转列代码见识了System.Linq.Dynamic的强大，下面再介绍一下会在开发中用到的方法。
Where过滤
list.Where("Name=@0", "张三")
上面用到了参数化查询，实现了查找姓名是张三的数据，通过这段代码你或许感受不到它的好处。但是和EntityFramework结合起来就可以实现动态拼接SQL的功能了。
/// <summary>
/// EF实体查询封装
/// </summary>
/// <typeparam name="T">实体类型</typeparam>
/// <param name="Query">IQueryable对象</param>
/// <param name="gridParam">过滤条件</param>
/// <returns>查询结果</returns>
public static EFPaginationResult<T> PageQuery<T>(this IQueryable<T> Query, QueryCondition gridParam)
{
//查询条件
EFFilter filter = GetParameterSQL<T>(gridParam);
var query = Query.Where(filter.Filter, filter.ListArgs.ToArray());
//查询结果
EFPaginationResult<T> result = new EFPaginationResult<T>();
if (gridParam.IsPagination)
{
int PageSize = gridParam.PageSize;
int PageIndex = gridParam.PageIndex < ? : gridParam.PageIndex;
//获取排序信息
string sort = GetSort(gridParam, typeof(T).FullName);
result.Data = query.OrderBy(sort).Skip(PageIndex * PageSize).Take(PageSize).ToList<T>();
if (gridParam.IsCalcTotal)
{
result.Total = query.Count();
result.TotalPage = Convert.ToInt32(Math.Ceiling(result.Total * 1.0 / PageSize));
}
else
{
result.Total = result.Data.Count();
}
}
else
{
result.Data = query.ToList();
result.Total = result.Data.Count();
}
return result;
}
/// <summary>
/// 通过查询条件,获取参数化查询SQL
/// </summary>
/// <param name="gridParam">过滤条件</param>
/// <returns>过滤条件字符</returns>
private static EFFilter GetParameterSQL<T>(QueryCondition gridParam)
{
EFFilter result = new EFFilter();
//参数值集合
List<object> listArgs = new List<object>();
string filter = "1=1"; #region "处理动态过滤条件"
if (gridParam.FilterList != null && gridParam.FilterList.Count > )
{
StringBuilder sb = new StringBuilder(); int paramCount = ;
DateTime dateTime;
//操作符
string strOperator = string.Empty;
foreach (var item in gridParam.FilterList)
{
//字段名称为空则跳过
if (string.IsNullOrEmpty(item.FieldName))
{
continue;
}
//匹配枚举，防止SQL注入
Operator operatorEnum = (Operator)Enum.Parse(typeof(Operator), item.Operator, true); //跳过字段值为空的
if (operatorEnum != Operator.Null && operatorEnum != Operator.NotNull && string.IsNullOrEmpty(item.FieldValue))
{
continue;
}
strOperator = operatorEnum.GetDescription();
if (item.IgnoreCase && !item.IsDateTime)
{
//2016-07-19添加查询时忽略大小写比较
item.FieldValue = item.FieldValue.ToLower();
item.FieldName = string.Format("{0}.ToLower()", item.FieldName);
}
switch (operatorEnum)
{
//等于,不等于，小于，大于，小于等于，大于等于
case Operator.EQ:
case Operator.NE:
case Operator.GT:
case Operator.GE:
case Operator.LT:
case Operator.LE:
if (item.IsDateTime)
{
if (DateTime.TryParse(item.FieldValue, out dateTime))
{
if (!item.FieldValue.Contains("00:00:00") && dateTime.ToString("HH:mm:ss") == "00:00:00")
{
if (operatorEnum == Operator.LE)
{
listArgs.Add(DateTime.Parse(dateTime.ToString("yyyy-MM-dd") + " 23:59:59"));
}
else
{
listArgs.Add(dateTime);
}
}
else
{
listArgs.Add(dateTime);
}
sb.AppendFormat(" AND {0} {1} @{2}", item.FieldName, strOperator, paramCount);
}
}
else
{
listArgs.Add(ConvertToType(item.FieldValue, GetPropType<T>(item.FieldName)));
sb.AppendFormat(" AND {0} {1} @{2}", item.FieldName, strOperator, paramCount);
}
paramCount++;
break;
case Operator.Like:
case Operator.NotLike:
case Operator.LLike:
case Operator.RLike:
listArgs.Add(item.FieldValue);
if (operatorEnum == Operator.Like)
{
sb.AppendFormat(" AND {0}.Contains(@{1})", item.FieldName, paramCount);
}
else if (operatorEnum == Operator.NotLike)
{
sb.AppendFormat(" AND !{0}.Contains(@{1})", item.FieldName, paramCount);
}
else if (operatorEnum == Operator.LLike)
{
sb.AppendFormat(" AND {0}.EndsWith(@{1})", item.FieldName, paramCount);
}
else if (operatorEnum == Operator.RLike)
{
sb.AppendFormat(" AND {0}.StartsWith(@{1})", item.FieldName, paramCount);
}
paramCount++;
break;
case Operator.Null:
listArgs.Add(item.FieldValue);
sb.AppendFormat(" AND {0}=null", item.FieldName);
paramCount++;
break;
case Operator.NotNull:
listArgs.Add(item.FieldValue);
sb.AppendFormat(" AND {0}!=null", item.FieldName);
paramCount++;
break;
case Operator.In:
sb.AppendFormat(" AND (");
foreach (var schar in item.FieldValue.Split(','))
{
listArgs.Add(schar);
sb.AppendFormat("{0}=@{1} or ", item.FieldName, paramCount);
paramCount++;
}
sb.Remove(sb.Length - , );
sb.AppendFormat(" )");
break;
case Operator.NotIn:
sb.AppendFormat(" AND (");
foreach (var schar in item.FieldValue.Split(','))
{
listArgs.Add(schar);
sb.AppendFormat("{0}!=@{1} and ", item.FieldName, paramCount);
paramCount++;
}
sb.Remove(sb.Length - , );
sb.AppendFormat(" )");
break;
}
if (sb.ToString().Length > )
{
filter = sb.ToString().Substring(, sb.Length - );
}
}
#endregion }
result.Filter = filter;
result.ListArgs = listArgs;
return result;
}
DataTable行转列
该部分是根据网友反馈后期再补充上的内容，意在完善行转列。下面给出实现代码
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Data;
using System.Linq; namespace DataTable_RowToColumn
{
class Program
{
static void Main(string[] args)
{
DataTable dt = InitTable();
List<string> DimensionList = new List<string>() { "Area", "Month" };
string DynamicColumn = "Name";
List<string> AllDynamicColumn = null;
DataTable dtResult = RowToColumn(dt, DimensionList, DynamicColumn, out AllDynamicColumn);
Console.WriteLine(JsonConvert.SerializeObject(dtResult, Formatting.Indented));
Console.Read();
} /// <summary>
/// 动态Linq方式实现行转列
/// </summary>
/// <param name="list">数据</param>
/// <param name="DimensionList">维度列</param>
/// <param name="DynamicColumn">动态列</param>
/// <returns>行转列后数据</returns>
private static DataTable RowToColumn(DataTable dt, List<string> DimensionList, string DynamicColumn, out List<string> AllDynamicColumn)
{
//获取所有动态列
AllDynamicColumn = new List<string>();
foreach (DataRow dr in dt.DefaultView.ToTable(true, DynamicColumn).Rows)
{
if (dr[DynamicColumn] != null && !string.IsNullOrEmpty(dr[DynamicColumn].ToString()))
{
AllDynamicColumn.Add(dr[DynamicColumn].ToString());
}
} //数值列
Dictionary<string, Type> AllNumberColumn = new Dictionary<string, Type>();
foreach (DataColumn item in dt.Columns)
{
if (item.DataType == typeof(int) || item.DataType == typeof(double) || item.DataType == typeof(float))
{
AllNumberColumn.Add(item.ColumnName, item.DataType);
}
} //结果DataTable创建
DataTable dtResult = new DataTable();
foreach (var item in DimensionList)
{
dtResult.Columns.Add(item, typeof(string));
}
//动态列
foreach (var dynamicValue in AllDynamicColumn)
{
foreach (var item in AllNumberColumn.Keys)
{
dtResult.Columns.Add(item + dynamicValue, AllNumberColumn[item]);
}
} //分组-优化性能
Dictionary<string, List<DataRow>> dict = new Dictionary<string, List<DataRow>>();
List<DataRow> drList = null;
string groupKey = "";
foreach (DataRow dr in dt.Rows)
{
groupKey = "";
foreach (var item in DimensionList)
{
groupKey += dr[item] + "#";
}
if (!dict.TryGetValue(groupKey, out drList))
{
drList = new List<DataRow>();
dict[groupKey] = drList;
}
drList.Add(dr);
} DataRow drReult = null;
DataTable dtTemp = null;
Dictionary<object, DataTable> dictTable = null;
foreach (var kv in dict)
{
drReult = dtResult.NewRow();
var arrKey = kv.Key.Split('#');
int i = ;
foreach (var key in DimensionList)
{
drReult[key] = arrKey[i];
i++;
}
dictTable = (from p in kv.Value.AsEnumerable()
group p by p.Field<object>(DynamicColumn) into g
select g).ToDictionary(e => e.Key, e => e.CopyToDataTable());
foreach (var dynamicValue in AllDynamicColumn)
{
if (dictTable.TryGetValue(dynamicValue, out dtTemp))
{
foreach (var numColumn in AllNumberColumn.Keys)
{
drReult[numColumn + dynamicValue] = dtTemp.Compute("sum(" + numColumn + ")", "");
}
}
else
{
foreach (var numColumn in AllNumberColumn.Keys)
{
drReult[numColumn + dynamicValue] = ;
}
}
}
dtResult.Rows.Add(drReult);
}
return dtResult;
} private static DataTable InitTable()
{
DataTable dt = new DataTable();
dt.Columns.Add("Name", typeof(string));
dt.Columns.Add("Area", typeof(string));
dt.Columns.Add("Month", typeof(string));
dt.Columns.Add("DfMoney", typeof(double));
dt.Columns.Add("SfMoney", typeof(double));
dt.Columns.Add("RqfMoney", typeof(double)); DataRow row = dt.NewRow();
row["Name"] = "张三";
row["Month"] = "2016-01";
row["Area"] = "江夏区";
row["DfMoney"] = 240.9;
row["SfMoney"] = ;
row["RqfMoney"] = ;
dt.Rows.Add(row); row = dt.NewRow();
row["Name"] = "张三";
row["Month"] = "2016-02";
row["Area"] = "江夏区";
row["DfMoney"] = ;
row["SfMoney"] = 24.5;
row["RqfMoney"] = 17.9;
dt.Rows.Add(row); row = dt.NewRow();
row["Name"] = "小燕子";
row["Month"] = "2016-01";
row["Area"] = "江夏区";
row["DfMoney"] = 340.9;
row["SfMoney"] = ;
row["RqfMoney"] = ;
dt.Rows.Add(row); row = dt.NewRow();
row["Name"] = "小燕子";
row["Month"] = "2016-02";
row["Area"] = "江夏区";
row["DfMoney"] = ;
row["SfMoney"] = 64.5;
row["RqfMoney"] = 77.9;
dt.Rows.Add(row); row = dt.NewRow();
row["Name"] = "李四";
row["Month"] = "2016-01";
row["Area"] = "洪山区";
row["DfMoney"] = 56.7;
row["SfMoney"] = 24.7;
row["RqfMoney"] = 13.2;
dt.Rows.Add(row); row = dt.NewRow();
row["Name"] = "李四";
row["Month"] = "2016-02";
row["Area"] = "洪山区";
row["DfMoney"] = 65.2;
row["SfMoney"] = 18.9;
row["RqfMoney"] = 14.9;
dt.Rows.Add(row); row = dt.NewRow();
row["Name"] = "尔康";
row["Month"] = "2016-01";
row["Area"] = "洪山区";
row["DfMoney"] = 156.7;
row["SfMoney"] = 124.7;
row["RqfMoney"] = 33.2;
dt.Rows.Add(row); row = dt.NewRow();
row["Name"] = "尔康";
row["Month"] = "2016-02";
row["Area"] = "洪山区";
row["DfMoney"] = 35.2;
row["SfMoney"] = 28.9;
row["RqfMoney"] = 44.9;
dt.Rows.Add(row);
return dt;
}
}
}
总结
本篇通过行转列引出了System.Linq.Dynamic，并且介绍了过滤功能，其实它的用处还有很多，等待大家发掘。下面给出本文示例代码：DynamicLinq
我的博客即将搬运同步至腾讯云+社区，邀请大家一同入驻：https://cloud.tencent.com/developer/support-plan
如果，您认为阅读这篇博客让您有些收获，不妨点击一下右下角的【推荐】按钮。
如果，您希望更容易地发现我的新博客，不妨点击一下绿色通道的【关注我】。
如果，想给予我更多的鼓励，求打
因为，我的写作热情也离不开您的肯定支持。
感谢您的阅读，如果您对我的博客所讲述的内容有兴趣，请继续关注我的后续博客，我是焰尾迭 。
List实现行转列的通用方案的更多相关文章
- List,DataTable实现行转列的通用方案
最近在做报表统计方面的需求,涉及到行转列报表.根据以往经验使用SQL可以比较容易完成,这次决定挑战一下直接通过代码方式完成行转列.期间遇到几个问题和用到的新知识这里整理记录一下. 阅读目录 问题介绍 ...
- ORACLE 行转列的通用过程
--测试数据create table rowtocol_test asselect 2009 year,1 month,'部门1' dept,50000 expenditure from dualun ...
- C#List实现行转列
List实现行转列的通用方案 最近在做报表统计方面的需求,涉及到行转列报表.根据以往经验使用SQL可以比较容易完成,这次决定挑战一下直接通过代码方式完成行转列.期间遇到几个问题和用到的新知识这里整理记 ...
- SQL 行转列和列转行
SQL 行转列和列转行 行列互转,是一个经常遇到的需求.实现的方法,有case when方式和2005之后的内置pivot和unpivot方法来实现. 在读了技术内幕那一节后,虽说这些解决方案早就用过 ...
- SQL行转列和列转行
行列互转,是一个经常遇到的需求.实现的方法,有case when方式和2005之后的内置pivot和unpivot方法来实现. 在读了技术内幕那一节后,虽说这些解决方案早就用过了,却没有系统性的认识和 ...
- sql行转列和列转行(转)
行列互转,是一个经常遇到的需求.实现的方法,有case when方式和2005之后的内置pivot和unpivot方法来实现. 在读了技术内幕那一节后,虽说这些解决方案早就用过了,却没有系统性的认识和 ...
- ORACLE行转列通用过程
create or replace procedure row_to_col(tabname in varchar2, group_ ...
- ORACLE行转列通用过程(转)
1.使用视图 SQL code? 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 create or r ...
- Sql 行转列、列转行及分页
说明:本实例是以 SQL Server 2005 为运行环境的. 准备工作:创建一个名为 DB 的数据库(CREATE DATABASE DB). 一.T-SQL 行转列 1.创建如下表 CREATE ...
随机推荐
- UIStackView属性解释
Distribution 分布: Fill:填充,会根据优先级来压缩或伸长元素 Fill Equal:全都相等,并且都填充满 Fill Proportionally:按比例填充,根据元素的内容多少的比 ...
- 汇编语言实现led灯的跑马灯
led实验1.看原理图 看设备工作的原理(可能需要阅读芯片手册),看设备与cpu的连接关系 GPIO具有输入输出功能.输入:cpu想知道io引脚是高电平还是低电平那么就是输入方式输出:cpu想控制io ...
- Android环境搭建与HelloWorld
引言 本系列适合0基础的人员,因为我就是从0开始的,此系列记录我步入Android开发的一些经验分享,望与君共勉!作为Android队伍中的一个新人的我,如果有什么不对的地方,还望不吝赐教. 在开始A ...
- iOS 之 Block Variable
在某个变量前面加__block ,这个变量就变成了block variable.那么就可以在block里面修改该值.
- Linux目录结构示意详解图
- 冒泡排序法-java案例详解
/** * 功能:冒泡排序法 * 思想:通过对待排序序列从后向前(从下标较大的元素开始),依次比较相邻元素的排序码, * ,若发现逆序这交换,使得排序码较小的元素逐渐从后部移向前部(从下标较大的单元移 ...
- C#如何给PDF文档添加注释
整理文档时,我们可能会需要在一些或一段文字上添加注释加以说明,那如何以编程的方式实现呢?本文将实例讲述C#中如何使用免费组件给PDF文档添加文本注释,包括自由文本注释.自由文本注释能允许我们自定义它的 ...
- Codeforces374A
A. Inna and Pink Pony time limit per test1 second memory limit per test 256 megabytes input standard ...
- 从svn上回滚版本
转载地址:http://blog.csdn.net/happyqyt/article/details/7107039 提交SVN后想回滚到旧版本. 选择TortoiseSVN→Repo-browser ...
- 有趣的++i和i++
作为一个天天和代码“约会”的人来说i++和++i这玩意再熟悉不过了,因为使用频率太高了. 虽然如此,但也未必见得我们真的了解她,不妨猜猜下面的输出结果. #inlcude <stdio.h> ...