c# - 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 语句，但我不知道该怎么做。但这是预期的行为。

级联.Full

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

级联.Unique

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

级联.Left

Note 将出现在最终集合中，第一个 实例将取代后续实例。 (那么，注释 1、2、3 是相同的。注释 1 被推过)

级联.Right

Note 将在最终集合中，Last 实例取代重复项。 (所以注释 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();

    }