Select many允许您从查询源中选择一个属性，该属性是一个IEQuery集合，但它不会返回集合的集合（IEQuery <IEQuery>），而是将集合扁平化为单个集合。
下面是一个示例，您可以运行它来演示Select和SelectMany之间的差异：

//set up some data for our example
var tuple1 = new { Name = "Tuple1", Values = new int [] { 1, 2, 3 } };
var tuple2 = new { Name = "Tuple2", Values = new int [] { 4, 5, 6 } };
var tuple3 = new { Name = "Tuple3", Values = new int [] { 7, 8, 9 } };

//put the tuples into a collection
var tuples = new [] { tuple1, tuple2, tuple3 };

//"tupleValues" is an IEnumerable<IEnumerable<int>> that contains { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 } }
var tupleValues = tuples.Select(t => t.Values);

//"tupleSelectManyValues" is an IEnumerable<int> that contains { 1, 2, 3, 4, 5, 6, 7, 8, 9 }
var tupleSelectManyValues = tuples.SelectMany(t => t.Values);

字符串
通过使用SelectMany，可以更轻松地查询子集合中的值。

SelectMany有几个重载，其中一个允许你在遍历层次结构时跟踪父级和子级之间的任何关系。

• 示例 *：假设您有以下结构：League -> Teams -> Player

你可以很容易地返回一个球员的平面集合。但是，你可能会丢失球员所属球队的任何引用。
幸运的是，有一个超载为这样的目的：

var teamsAndTheirLeagues = 
         from helper in leagues.SelectMany
               ( l => l.Teams,
                   ( league, team ) => new { league, team } )
                      where helper.team.Players.Count > 2 
                           && helper.league.Teams.Count < 10
                           select new 
                           { 
                               LeagueID = helper.league.ID,
                               Team = helper.team 
                           };

字符串
上一个例子摘自Dan的IK博客：
http://blogs.interknowlogy.com/2008/10/10/use-linqs-selectmany-method-to-flatten-collections/
我强烈建议你去看看。

SelectMany基本上处理分层数据，主要有两种形式
(for示例的目的，请参阅此初始代码）

class TestObj
{
    public string Name { get; set; }
    public List<string> Items { get; set; }
}

var hierarchicalCollection = new List<TestObj>();

hierarchicalCollection.Add(new TestObj() 
    {Items = new List<string>()
        {"testObj1-Item1", "testObj1-Item2"}, Name="t1"});
hierarchicalCollection.Add(new TestObj() 
    {Items = new List<string>()
        {"testObj2-Item1", "testObj2-Item2"}, Name="t2"});

字符串
选项1）从集合的集合中创建集合（本质上是扁平化分层数据）

IEnumerable<string> flattenedCollection = 
    hierarchicalCollection.SelectMany(t => t.Items);

型
结果是：

"testObj1-Item1"
"testObj1-Item2"
"testObj2-Item1"
"testObj2-Item2"

型
选项2）从集合的集合中创建一个集合，然后通过对原始父集合的引用处理新集合中的每个项

IEnumerable<string> flattenedModifiedCollection = 
    hierarchicalCollection.SelectMany
        (t => t.Items, (t, i) => t.Name + " : " + i);

型
结果是：

"t1 : testObj1-Item1"
"t1 : testObj1-Item2"
"t2 : testObj2-Item1"
"t2 : testObj2-Item2"

型
上述用途中的每一个都具有一个变体，其中，正被处理的项的索引可用于变换函数。

我一直在使用这个扩展来深入层次结构。
当扩展变得有点混乱时，另一个很酷的方法是使用正式的LINQ方式，比如：

var vehicles = from cust in context.Customers
               from fleet in cust.Fleets
               from v in fleet.Vehicles
               select v;

字符串
这相当于：

var vehicles = context.Customers.SelectMany(c => c.Fleets).SelectMany(f => f.Vehicles);

型
这可能会得到一个有点冗长的时候，在哪里添加子句和连接等，希望这有帮助！

我在LINQ中使用SelectMany有一些乐趣。下面的链接描述了在LINQ select子句中返回一个IEEE800，它返回一个序列的序列，并使用SelectMany将其扁平化为一个简单的序列. "Linq to XML using Let, Yield return and Selectmany"。这不仅仅是一个SelectMany用例，而是从LINQ中的单个输入生成多个输出的方法的一部分。

下面是另一个（VB.NET）用法示例：

'Original list
Dim l() As String = {"/d", "/bc:\Temp\In*;c:\Temp\Out", "/hABC", "/s123"}

'Processed list: will list first 2 characters from each string member.
Dim L1 As IEnumerable(Of String) = l.SelectMany(Function(x As String) {x.Substring(0, 2)})

Dim L2 As List(Of String) = l.SelectMany(Function(x As String) {x.Substring(0, 2)}).ToList

'Will return dictionary like list with keys==2 characters and values the rest from each string member.
Dim L3 As List(Of KeyValuePair(Of String, String)) = l.SelectMany(Function(x As String) {New KeyValuePair(Of String, String)(x.Substring(0, 2), x.Substring(2))}).ToList

字符串