LINQ、SelectMany 具有多种可能的结果

Question

我遇到的情况是，我有必须合并的对象列表。列表中的每个对象都有一个属性，用于解释在合并中应如何处理它。所以假设如下..

enum Cascade {
  Full,
  Unique,
  Right,
  Left
}

class Note {
  int Id { get; set; }
  Cascade Cascade { get; set; }
  // lots of other data.
}

var list1 = new List<Note>{
 new Note {
   Id = 1,
   Cascade.Full,
   // data
 },
 new Note {
   Id = 2,
   Cascade.Right,
   // data
 }
};
var list2 = new List<Note>{
  new Note {
   Id = 1,
   Cascade.Left,
   // data
  }
};
var list3 = new List<Note>{
  new Note {
    Id = 1,
    Cascade.Unique,
    // data similar to list1.Note[0]
  }
}

那么，我将有一个方法...

Composite(this IList<IList<Note>> notes){
  return new List<Note> {
      notes.SelectMany(g => g).Where(g => g.Cascade == Cascade.All).ToList()
      // Here is the problem... 
      .SelectMany(g => g).Where(g => g.Cascade == Cascade.Right)
      .Select( // I want to do a _LastOrDefault_ )
      // continuing for the other cascades. 
  }
}

这就是我迷路的地方。我需要执行多个 SelectMany 语句，但我不知道该怎么做。但这是预期的行为。

Cascade.Full

无论如何，Note 都将出现在最终集合中。

Cascade.Unique

Note 将出现在最终集合中一次，忽略任何重复项。

Cascade.Left

Note 将位于最终集合中，第一个 实例将取代后续实例。 （因此，注释 1、2、3 是相同的。注释 1 被推送）

Cascade.Right

Note 将位于最终集合中，Last< /strong> 实例取代重复项。 （所以注释 1、2、3 是相同的。注释 3 被推入低谷）

Answer 1

我认为你应该把问题分解成更小的部分。例如，您可以在单独的扩展方法中实现单个列表的级联规则。这是我未经测试的看法：

public static IEnumerable<Note> ApplyCascades(this IEnumerable<Note> notes)
    {
        var uniques = new HashSet<Note>();
        Note rightToYield = null;
        foreach (var n in notes)
        {
            bool leftYielded = false;

            if (n.Cascade == Cascade.All) yield return n;
            if (n.Cascade == Cascade.Left && !leftYielded)
            {
                yield return n;
                leftYielded = true;
            }
            if (n.Cascade == Cascade.Right)
            {
                rightToYield = n;
            }
            if (n.Cascade == Cascade.Unique && !uniques.Contains(n))
            {
                yield return n;
                uniques.Add(n);
            } 
        }

        if (rightToYield != null) yield return rightToYield;
    } 
}

此方法将允许实现原始扩展方法，如下所示：

    List<Note> Composite(IList<IList<Note>> notes)
    {
        var result = from list in notes
                     from note in list.ApplyCascades()
                     select note;
        return result.ToList();

    }