SelectMany 匿名类型和跳过迭代

Question

当您不总是想返回结果时，我一直在尝试寻找一种“干净”的模式来处理具有匿名类型的 .SelectMany。我最常见的用例如下所示：

1. 我们有一份我想要报告的客户列表。
2. 每个客户的数据都驻留在一个单独的数据库中，所以我做了一个并行.SelectMany
3. 在每个 lambda 表达式中，我为客户收集结果以形成最终报告。
4. 如果应该跳过特定客户，我需要返回一个空列表。
5. 我经常使用这些来快速报告，所以我更喜欢匿名类型。

例如，逻辑可能如下所示：

//c is a customer
var context = GetContextForCustomer(c);
// look up some data, myData using the context connection
if (someCondition)
  return myData.Select(x => new { CustomerID = c, X1 = x.x1, X2 = x.x2 });
else
  return null;

这可以作为一个 foreach 语句来实现：

var results = new List<WhatType?>();
foreach (var c in customers) {
  var context = GetContextForCustomer(c);
  if (someCondition)
    results.AddRange(myData.Select(x => new { CustomerID = c, X1 = x.x1, X2 = x.x2 }));
}

或者它可以使用.SelectMany 来实现，该.Where 预先过滤：

customers
  .Where(c => someCondition)
  .AsParallel()
  .SelectMany(c => {
     var context = GetContextForCustomer(c);
     return myData.Select(x => new { CustomerID = c, X1 = x.x1, X2 = x.x2 });
  })
  .ToList();

这两种方法都存在问题。 foreach 解决方案需要初始化一个List 来存储结果，并且您必须定义类型。 .SelectMany 和.Where 通常是不切实际的，因为someCondition 的逻辑相当复杂并且依赖于一些数据查找。所以我理想的解决方案应该是这样的：

customers
  .AsParallel()
  .SelectMany(c => {
     var context = GetContextForCustomer(c);
     if (someCondition)
       return myData.Select(x => new { CustomerID = c, X1 = x.x1, X2 = x.x2 });
     else
       continue?   return null?   return empty list?
  })
  .ToList();

我应该在else 行中添加什么来跳过返回值？我能想出的解决方案都不是有效的或理想的：

1. continue 无法编译，因为它不是活动的 foreach 循环
2. return null 导致 NRE
3. return空列表需要我重新初始化一个匿名类型的列表。

有没有一种方法可以干净、简单、整洁，并满足我所有（挑剔的）要求？

Answer 1

您可以返回一个空的Enumerable<dynamic>。这是一个示例（尽管没有您的客户和someCondition，因为我不知道他们是什么，但与您的示例具有相同的一般形式）：

new int[] { 1, 2, 3, 4 }
    .AsParallel()
    .SelectMany(i => {
        if (i % 2 == 0)
            return Enumerable.Repeat(new { i, squared = i * i }, i);
        else
            return Enumerable.Empty<dynamic>();
        })
    .ToList();

所以，有了你的对象和someCondition，它看起来像

customers
    .AsParallel()
    .SelectMany(c => {
        var context = GetContextForCustomer(c);
        if (someCondition)
            return myData.Select(x => new { CustomerID = c, X1 = x.x1, X2 = x.x2 });
        else
            return Enumerable.Empty<dynamic>();
       })
    .ToList();

Answer 2

不知道someCondition 和myData 长什么样……

你为什么不把上下文也用Select 和Where：

customers
.Select(c => GetContextForCustomer(c))
.Where(ctx => someCondition)
.SelectMany(ctx => 
    myData.Select(x => new { CustomerID = c, X1 = x.x1, X2 = x.x2 });

---

编辑：我刚刚意识到您需要进一步携带 customer 和 context，所以您可以这样做：

customers
.Select(c => new { Customer = c, Context = GetContextForCustomer(c) })
.Where(x => someCondition(x.Context))
.SelectMany(x => 
    myData.Select(d => new { CustomerID = x.Customer, X1 = d.x1, X2 = d.x2 });

Answer 3

您可以尝试以下操作：

customers
  .AsParallel()
  .SelectMany(c => {
     var context = GetContextForCustomer(c);
     if (someCondition)
       return myData.Select(x => new { CustomerID = c, X1 = x.x1, X2 = x.x2 });
     else
       return Enumerable.Empty<int>().Select(x => new { CustomerID = 0, X1 = "defValue", X2 = "defValue" });
  })
  .ToList();

所有具有相同属性集（相同名称和类型）的匿名类型被编译器组合成一个匿名类。这就是为什么你的Select 和Enumerable.Empty 上的T 都会返回相同的T。

Answer 4

您可以创建自己的SelectMany LINQ 方法的变体，它支持nulls：

public static class EnumerableExtensions
{
    public static IEnumerable<TResult> NullableSelectMany<TSource, TResult> (
        this IEnumerable<TSource> source,
        Func<TSource, IEnumerable<TResult>> selector)
    {
        if (source == null) 
            throw new ArgumentNullException("source");
        if (selector == null) 
            throw new ArgumentNullException("selector");
        foreach (TSource item in source) {
            IEnumerable<TResult> results = selector(item);
            if (results != null) {
                foreach (TResult result in results)
                    yield return result;
            }
        }
    }
}

现在您可以在 selector lambda 中返回 null。

Answer 5

接受的答案返回dynamic。最干净的方法是将过滤逻辑移动到 Where 中，这使得整个事情在 linq 上下文中看起来更好。由于您在问题中明确排除了这一点，而且我不喜欢在 linq 调用中多行编写代表，我将尝试this，但有人可能会认为它更hacky。

var results = new 
{ 
    customerID = default(int), //notice the casing of property names
    x1 = default(U), //whatever types they are
    x2 = default(V) 
}.GetEmptyListOfThisType();

foreach (var customerID in customers) {
  var context = GetContextForCustomer(customerID);
  if (someCondition)
    results.AddRange(myData.Select(x => new { customerID, x.x1, x.x2 }));
}

public static List<T> GetEmptyListOfThisType<T>(this T item)
{
    return new List<T>();
}

注意属性名称的正确使用与其他变量名称一致，因此您不必在Select 调用中再次编写属性名称。