我试图重写一些老SQL到LINQ到SQL。 我有一组存储过程与ROLLUP，但我不知道LINQ相当于是什么。 LINQ拥有的GroupBy，但它并不像它支持汇总。
结果，我试图让会是这样的一个简单的例子：
+-----------+---------------+--------------------+
| City | ServicePlan | NumberOfCustomers |
+-----------+---------------+--------------------+
| Seattle | Plan A | 10 |
| Seattle | Plan B | 5 |
| Seattle | All | 15 |
| Portland | Plan A | 20 |
| Portland | Plan C | 10 |
| Portland | All | 30 |
| All | All | 45 |
+-----------+---------------+--------------------+
关于我如何能使用LINQ to SQL获得这些结果的任何想法？
我想出了一个更简单的解决方案。 我试图使它的方式复杂得多，它需要的是。 而不需要3-5类/方法我只需要一个方法。
基本上，你做你的排序和分组你自己，然后调用WithRollup()得到一个List<>与小计和总计的项目。 我无法弄清楚如何生成SQL一边因此那些与LINQ做对象的小计和总计。 下面的代码：
/// <summary>
/// Adds sub-totals to a list of items, along with a grand total for the whole list.
/// </summary>
/// <param name="elements">Group and/or sort this yourself before calling WithRollup.</param>
/// <param name="primaryKeyOfElement">Given a TElement, return the property that you want sub-totals for.</param>
/// <param name="calculateSubTotalElement">Given a group of elements, return a TElement that represents the sub-total.</param>
/// <param name="grandTotalElement">A TElement that represents the grand total.</param>
public static List<TElement> WithRollup<TElement, TKey>(this IEnumerable<TElement> elements,
Func<TElement, TKey> primaryKeyOfElement,
Func<IGrouping<TKey, TElement>, TElement> calculateSubTotalElement,
TElement grandTotalElement)
{
// Create a new list the items, subtotals, and the grand total.
List<TElement> results = new List<TElement>();
var lookup = elements.ToLookup(primaryKeyOfElement);
foreach (var group in lookup)
{
// Add items in the current group
results.AddRange(group);
// Add subTotal for current group
results.Add(calculateSubTotalElement(group));
}
// Add grand total
results.Add(grandTotalElement);
return results;
}
以及如何使用它的一个例子：
class Program
{
static void Main(string[] args)
{
IQueryable<CustomObject> dataItems = (new[]
{
new CustomObject { City = "Seattle", Plan = "Plan B", Charges = 20 },
new CustomObject { City = "Seattle", Plan = "Plan A", Charges = 10 },
new CustomObject { City = "Seattle", Plan = "Plan B", Charges = 20 },
new CustomObject { City = "Seattle", Plan = "Plan A", Charges = 10 },
new CustomObject { City = "Seattle", Plan = "Plan A", Charges = 10 },
new CustomObject { City = "Seattle", Plan = "Plan A", Charges = 10 },
new CustomObject { City = "Portland", Plan = "Plan A", Charges = 10 },
new CustomObject { City = "Portland", Plan = "Plan A", Charges = 10 },
new CustomObject { City = "Portland", Plan = "Plan C", Charges = 30 },
new CustomObject { City = "Portland", Plan = "Plan C", Charges = 30 },
new CustomObject { City = "Portland", Plan = "Plan C", Charges = 30 }
}).AsQueryable();
IQueryable<CustomObject> orderedElements = from item in dataItems
orderby item.City, item.Plan
group item by new { item.City, item.Plan } into grouping
select new CustomObject
{
City = grouping.Key.City,
Plan = grouping.Key.Plan,
Charges = grouping.Sum(item => item.Charges),
Count = grouping.Count()
};
List<CustomObject> results = orderedElements.WithRollup(
item => item.City,
group => new CustomObject
{
City = group.Key,
Plan = "All",
Charges = group.Sum(item => item.Charges),
Count = group.Sum(item => item.Count)
},
new CustomObject
{
City = "All",
Plan = "All",
Charges = orderedElements.Sum(item => item.Charges),
Count = orderedElements.Sum(item => item.Count)
});
foreach (var result in results)
Console.WriteLine(result);
Console.Read();
}
}
class CustomObject
{
public string City { get; set; }
public string Plan { get; set; }
public int Count { get; set; }
public decimal Charges { get; set; }
public override string ToString()
{
return String.Format("{0} - {1} ({2} - {3})", City, Plan, Count, Charges);
}
}
我知道了！ 一个通用GroupByWithRollup。 它只有两列组，但可以很容易地扩展，以支持更多。 我也许会做另一种接受三列的版本。 键类/方法的分组<>，GroupByMany <>（），和GroupByWithRollup <>（）。 小计（）和GrandTotal（）方法是助手当你实际使用GroupByWithRollup <>（）。 下面是代码，其次是如何使用它的一个例子。
/// <summary>
/// Represents an instance of an IGrouping<>. Used by GroupByMany(), GroupByWithRollup(), and GrandTotal().
/// </summary>
public class Grouping<TKey, TElement> : IGrouping<TKey, TElement>
{
public TKey Key { get; set; }
public IEnumerable<TElement> Items { get; set; }
public IEnumerator<TElement> GetEnumerator()
{
return Items.GetEnumerator();
}
IEnumerator IEnumerable.GetEnumerator()
{
return Items.GetEnumerator();
}
}
public static class Extensions
{
/// <summary>
/// Groups by two columns.
/// </summary>
/// <typeparam name="TElement">Type of elements to group.</typeparam>
/// <typeparam name="TKey1">Type of the first expression to group by.</typeparam>
/// <typeparam name="TKey2">Type of the second expression to group by.</typeparam>
/// <param name="orderedElements">Elements to group.</param>
/// <param name="groupByKey1Expression">The first expression to group by.</param>
/// <param name="groupByKey2Expression">The second expression to group by.</param>
/// <param name="newElementExpression">An expression that returns a new TElement.</param>
public static IQueryable<Grouping<TKey1, TElement>> GroupByMany<TElement, TKey1, TKey2>(this IOrderedQueryable<TElement> orderedElements,
Func<TElement, TKey1> groupByKey1Expression,
Func<TElement, TKey2> groupByKey2Expression,
Func<IGrouping<TKey1, TElement>, IGrouping<TKey2, TElement>, TElement> newElementExpression
)
{
// Group the items by Key1 and Key2
return from element in orderedElements
group element by groupByKey1Expression(element) into groupByKey1
select new Grouping<TKey1, TElement>
{
Key = groupByKey1.Key,
Items = from key1Item in groupByKey1
group key1Item by groupByKey2Expression(key1Item) into groupByKey2
select newElementExpression(groupByKey1, groupByKey2)
};
}
/// <summary>
/// Returns a List of TElement containing all elements of orderedElements as well as subTotals and a grand total.
/// </summary>
/// <typeparam name="TElement">Type of elements to group.</typeparam>
/// <typeparam name="TKey1">Type of the first expression to group by.</typeparam>
/// <typeparam name="TKey2">Type of the second expression to group by.</typeparam>
/// <param name="orderedElements">Elements to group.</param>
/// <param name="groupByKey1Expression">The first expression to group by.</param>
/// <param name="groupByKey2Expression">The second expression to group by.</param>
/// <param name="newElementExpression">An expression that returns a new TElement.</param>
/// <param name="subTotalExpression">An expression that returns a new TElement that represents a subTotal.</param>
/// <param name="totalExpression">An expression that returns a new TElement that represents a grand total.</param>
public static List<TElement> GroupByWithRollup<TElement, TKey1, TKey2>(this IOrderedQueryable<TElement> orderedElements,
Func<TElement, TKey1> groupByKey1Expression,
Func<TElement, TKey2> groupByKey2Expression,
Func<IGrouping<TKey1, TElement>, IGrouping<TKey2, TElement>, TElement> newElementExpression,
Func<IGrouping<TKey1, TElement>, TElement> subTotalExpression,
Func<IQueryable<Grouping<TKey1, TElement>>, TElement> totalExpression
)
{
// Group the items by Key1 and Key2
IQueryable<Grouping<TKey1, TElement>> groupedItems = orderedElements.GroupByMany(groupByKey1Expression, groupByKey2Expression, newElementExpression);
// Create a new list the items, subtotals, and the grand total.
List<TElement> results = new List<TElement>();
foreach (Grouping<TKey1, TElement> item in groupedItems)
{
// Add items under current group
results.AddRange(item);
// Add subTotal for current group
results.Add(subTotalExpression(item));
}
// Add grand total
results.Add(totalExpression(groupedItems));
return results;
}
/// <summary>
/// Returns the subTotal sum of sumExpression.
/// </summary>
/// <param name="sumExpression">An expression that returns the value to sum.</param>
public static int SubTotal<TKey, TElement>(this IGrouping<TKey, TElement> query, Func<TElement, int> sumExpression)
{
return query.Sum(group => sumExpression(group));
}
/// <summary>
/// Returns the subTotal sum of sumExpression.
/// </summary>
/// <param name="sumExpression">An expression that returns the value to sum.</param>
public static decimal SubTotal<TKey, TElement>(this IGrouping<TKey, TElement> query, Func<TElement, decimal> sumExpression)
{
return query.Sum(group => sumExpression(group));
}
/// <summary>
/// Returns the grand total sum of sumExpression.
/// </summary>
/// <param name="sumExpression">An expression that returns the value to sum.</param>
public static int GrandTotal<TKey, TElement>(this IQueryable<Grouping<TKey, TElement>> query, Func<TElement, int> sumExpression)
{
return query.Sum(group => group.Sum(innerGroup => sumExpression(innerGroup)));
}
/// <summary>
/// Returns the grand total sum of sumExpression.
/// </summary>
/// <param name="sumExpression">An expression that returns the value to sum.</param>
public static decimal GrandTotal<TKey, TElement>(this IQueryable<Grouping<TKey, TElement>> query, Func<TElement, decimal> sumExpression)
{
return query.Sum(group => group.Sum(innerGroup => sumExpression(innerGroup)));
}
并利用它的一个例子：
class Program
{
static void Main(string[] args)
{
IQueryable<CustomObject> dataItems = (new[]
{
new CustomObject { City = "Seattle", Plan = "Plan B", Charges = 20 },
new CustomObject { City = "Seattle", Plan = "Plan A", Charges = 10 },
new CustomObject { City = "Seattle", Plan = "Plan B", Charges = 20 },
new CustomObject { City = "Seattle", Plan = "Plan A", Charges = 10 },
new CustomObject { City = "Seattle", Plan = "Plan A", Charges = 10 },
new CustomObject { City = "Seattle", Plan = "Plan A", Charges = 10 },
new CustomObject { City = "Portland", Plan = "Plan A", Charges = 10 },
new CustomObject { City = "Portland", Plan = "Plan A", Charges = 10 },
new CustomObject { City = "Portland", Plan = "Plan C", Charges = 30 },
new CustomObject { City = "Portland", Plan = "Plan C", Charges = 30 },
new CustomObject { City = "Portland", Plan = "Plan C", Charges = 30 }
}).AsQueryable();
List<CustomObject> results = dataItems.OrderBy(item => item.City).ThenBy(item => item.Plan).GroupByWithRollup(
item => item.City,
item => item.Plan,
(primaryGrouping, secondaryGrouping) => new CustomObject
{
City = primaryGrouping.Key,
Plan = secondaryGrouping.Key,
Count = secondaryGrouping.Count(),
Charges = secondaryGrouping.Sum(item => item.Charges)
},
item => new CustomObject
{
City = item.Key,
Plan = "All",
Count = item.SubTotal(subItem => subItem.Count),
Charges = item.SubTotal(subItem => subItem.Charges)
},
items => new CustomObject
{
City = "All",
Plan = "All",
Count = items.GrandTotal(subItem => subItem.Count),
Charges = items.GrandTotal(subItem => subItem.Charges)
}
);
foreach (var result in results)
Console.WriteLine(result);
Console.Read();
}
}
class CustomObject
{
public string City { get; set; }
public string Plan { get; set; }
public int Count { get; set; }
public decimal Charges { get; set; }
public override string ToString()
{
return String.Format("{0} - {1} ({2} - {3})", City, Plan, Count, Charges);
}
}
@Ecyrb，你好从五年后！
我只是很模糊地熟悉LINQ to SQL的，超出标准的LINQ（对象）。 但是，因为你有一个“LINQ”标签从“LINQ-2-SQL”标签分开的，因为你似乎是在结果主要感兴趣的（而不是注册与数据库的变化），因为这是唯一想出了，当我在寻找一个LINQ相当于SQL Server的“汇总”分组功能的一派真正相关的资源，我会为当今任何人同样需要我自己的替代解决方案。
基本上，我的方法是创建一个 “.GroupBy（）。ThenBy（）” 可链接的语法类似 “.OrderBy（）。ThenBy（）” 语法。 我希望延长IGrouping对象的集合 - 你从运行得到“.GroupBy（）”的结果 - 作为其源。 然后，它需要收集和取消组合他们回来在原来的对象分组之前。 最后，重新组的数据按照新的分组功能，制造另一组IGrouping的对象，并增加了新分组的对象到组源对象。
public static class mySampleExtensions {
public static IEnumerable<IGrouping<TKey, TSource>> ThenBy<TSource, TKey> (
this IEnumerable<IGrouping<TKey, TSource>> source,
Func<TSource, TKey> keySelector) {
var unGroup = source.SelectMany(sm=> sm).Distinct(); // thank you flq at http://stackoverflow.com/questions/462879/convert-listlistt-into-listt-in-c-sharp
var reGroup = unGroup.GroupBy(keySelector);
return source.Concat(reGroup);}
}
您可以使用该方法通过把常量的值到“.ThenBy（）”函数的相应区域，以匹配SQL服务器的汇总逻辑。 我更喜欢使用空值，因为它是铸造最灵活的恒定。 因为你在这两个.GroupBy（）和.ThenBy（使用）的功能必须得到相同的对象类型转换是非常重要的。 使用您在08月31 '09你的第一反应创造了“dataItems”变量，它应该是这样的：
var rollItUp = dataItems
.GroupBy(g=> new {g.City, g.Plan})
.ThenBy(g=> new {g.City, Plan = (string) null})
.ThenBy(g=> new {City = (string) null, Plan = (string) null})
.Select(s=> new CustomObject {
City = s.Key.City,
Plan = s.Key.Plan,
Count = s.Count(),
Charges = s.Sum(a=> a.Charges)})
.OrderBy(o=> o.City) // This line optional
.ThenBy(o=> o.Plan); // This line optional
你可以用‘所有’替换“.ThenBy（）”逻辑中的空白，你的愿望。
你可能会效仿SQL Server的分组集，也许立方体，用“）.ThenBy（”的帮助。 此外，“.ThenBy（）”是的工作对我很好，我不预见这个名字等同于任何问题“.ThenBy（）”，“.OrderBy（）”方法，因为它们有不同的签名，但如果有麻烦，你可能要考虑将其命名为“.ThenGroupBy（）”来区分。
如前所述，我不使用LINQ到SQL，但我使用F＃的类型提供系统，我的理解使用LINQ到SQL在许多方面引擎盖下。 所以，我想我这样的对象可拓从我的F＃项目，它的工作原理如我所料。 虽然我完全不知道，如果这意味着什么有趣或者在这方面。
颇为有趣的解决方案在这里提供
https://blogs.msdn.microsoft.com/mitsu/2007/12/21/playing-with-linq-grouping-groupbymany/
它描述了如何通过几个属性执行groupbby。 即：
var result = customers.GroupByMany(c => c.Country, c => c.City);
作为结果，你会得到可以简单地转换为平面列表层次结构。
