我可能自己写这个，但我试图完成它的具体方式让我失望。我正在尝试编写一种类似于 .NET 3.5 中引入的其他方法的通用扩展方法，它将采用嵌套的 IEnumerables（等等）并将其展平为一个 IEnumerable。有人有想法么？
具体来说，我在扩展方法本身的语法方面遇到了问题，因此我可以研究扁平化算法。
Matt
问问题
25356 次
13 回答
47
这是一个可能有帮助的扩展。它将遍历对象层次结构中的所有节点，并挑选出符合条件的节点。它假定层次结构中的每个对象都有一个包含其子对象的集合属性。
这是扩展名：
/// Traverses an object hierarchy and return a flattened list of elements
/// based on a predicate.
///
/// TSource: The type of object in your collection.</typeparam>
/// source: The collection of your topmost TSource objects.</param>
/// selectorFunction: A predicate for choosing the objects you want.
/// getChildrenFunction: A function that fetches the child collection from an object.
/// returns: A flattened list of objects which meet the criteria in selectorFunction.
public static IEnumerable<TSource> Map<TSource>(
this IEnumerable<TSource> source,
Func<TSource, bool> selectorFunction,
Func<TSource, IEnumerable<TSource>> getChildrenFunction)
{
// Add what we have to the stack
var flattenedList = source.Where(selectorFunction);
// Go through the input enumerable looking for children,
// and add those if we have them
foreach (TSource element in source)
{
flattenedList = flattenedList.Concat(
getChildrenFunction(element).Map(selectorFunction,
getChildrenFunction)
);
}
return flattenedList;
}
示例（单元测试）：
首先，我们需要一个对象和一个嵌套对象层次结构。
一个简单的节点类
class Node
{
public int NodeId { get; set; }
public int LevelId { get; set; }
public IEnumerable<Node> Children { get; set; }
public override string ToString()
{
return String.Format("Node {0}, Level {1}", this.NodeId, this.LevelId);
}
}
以及一种获得 3 级深层节点层次结构的方法
private IEnumerable<Node> GetNodes()
{
// Create a 3-level deep hierarchy of nodes
Node[] nodes = new Node[]
{
new Node
{
NodeId = 1,
LevelId = 1,
Children = new Node[]
{
new Node { NodeId = 2, LevelId = 2, Children = new Node[] {} },
new Node
{
NodeId = 3,
LevelId = 2,
Children = new Node[]
{
new Node { NodeId = 4, LevelId = 3, Children = new Node[] {} },
new Node { NodeId = 5, LevelId = 3, Children = new Node[] {} }
}
}
}
},
new Node { NodeId = 6, LevelId = 1, Children = new Node[] {} }
};
return nodes;
}
第一次测试：扁平化层次结构，不过滤
[Test]
public void Flatten_Nested_Heirachy()
{
IEnumerable<Node> nodes = GetNodes();
var flattenedNodes = nodes.Map(
p => true,
(Node n) => { return n.Children; }
);
foreach (Node flatNode in flattenedNodes)
{
Console.WriteLine(flatNode.ToString());
}
// Make sure we only end up with 6 nodes
Assert.AreEqual(6, flattenedNodes.Count());
}
这将显示：
Node 1, Level 1
Node 6, Level 1
Node 2, Level 2
Node 3, Level 2
Node 4, Level 3
Node 5, Level 3
第二个测试：获取具有偶数 NodeId 的节点列表
[Test]
public void Only_Return_Nodes_With_Even_Numbered_Node_IDs()
{
IEnumerable<Node> nodes = GetNodes();
var flattenedNodes = nodes.Map(
p => (p.NodeId % 2) == 0,
(Node n) => { return n.Children; }
);
foreach (Node flatNode in flattenedNodes)
{
Console.WriteLine(flatNode.ToString());
}
// Make sure we only end up with 3 nodes
Assert.AreEqual(3, flattenedNodes.Count());
}
这将显示：
Node 6, Level 1
Node 2, Level 2
Node 4, Level 3
于 2008-10-23T11:48:45.207 回答
20
嗯......我不确定你到底想要什么，但这里有一个“一级”选项：
public static IEnumerable<TElement> Flatten<TElement,TSequence> (this IEnumerable<TSequence> sequences)
where TSequence : IEnumerable<TElement>
{
foreach (TSequence sequence in sequences)
{
foreach(TElement element in sequence)
{
yield return element;
}
}
}
如果这不是你想要的，你能提供你想要的签名吗？如果您不需要通用形式，而只想做 LINQ to XML 构造函数所做的那种事情，那相当简单——尽管迭代器块的递归使用效率相对较低。就像是：
static IEnumerable Flatten(params object[] objects)
{
// Can't easily get varargs behaviour with IEnumerable
return Flatten((IEnumerable) objects);
}
static IEnumerable Flatten(IEnumerable enumerable)
{
foreach (object element in enumerable)
{
IEnumerable candidate = element as IEnumerable;
if (candidate != null)
{
foreach (object nested in candidate)
{
yield return nested;
}
}
else
{
yield return element;
}
}
}
请注意，这会将字符串视为一系列字符，但是 - 您可能希望将特殊情况下的字符串作为单独的元素而不是将它们展平，具体取决于您的用例。
这有帮助吗？
于 2008-09-26T19:47:25.600 回答
12
我想我会分享一个包含错误处理和单一逻辑方法的完整示例。
递归展平很简单：
LINQ 版本
public static class IEnumerableExtensions
{
public static IEnumerable<T> SelectManyRecursive<T>(this IEnumerable<T> source, Func<T, IEnumerable<T>> selector)
{
if (source == null) throw new ArgumentNullException("source");
if (selector == null) throw new ArgumentNullException("selector");
return !source.Any() ? source :
source.Concat(
source
.SelectMany(i => selector(i).EmptyIfNull())
.SelectManyRecursive(selector)
);
}
public static IEnumerable<T> EmptyIfNull<T>(this IEnumerable<T> source)
{
return source ?? Enumerable.Empty<T>();
}
}
非 LINQ 版本
public static class IEnumerableExtensions
{
public static IEnumerable<T> SelectManyRecursive<T>(this IEnumerable<T> source, Func<T, IEnumerable<T>> selector)
{
if (source == null) throw new ArgumentNullException("source");
if (selector == null) throw new ArgumentNullException("selector");
foreach (T item in source)
{
yield return item;
var children = selector(item);
if (children == null)
continue;
foreach (T descendant in children.SelectManyRecursive(selector))
{
yield return descendant;
}
}
}
}
设计决策
我决定：
- 禁止对 null 进行展平
IEnumerable，这可以通过删除异常抛出来改变，并且：- 在第一版
source = source.EmptyIfNull();之前添加return - 在第二版
if (source != null)之前添加foreach
- 在第一版
- 允许选择器返回一个空集合 - 这样我就从调用者那里移除了确保子列表不为空的责任，这可以通过以下方式更改：
- 在第一个版本中删除
.EmptyIfNull()- 注意SelectMany如果选择器返回 null 将失败 - 在第二个版本中删除
if (children == null) continue;- 请注意，foreach空IEnumerable参数将失败
- 在第一个版本中删除
- 允许
.Where在调用方或子选择器内过滤子句，而不是传递子过滤器选择器参数：- 它不会影响效率，因为在两个版本中它都是延迟调用
- 它会将另一个逻辑与该方法混合，我更喜欢将逻辑分开
样品使用
我在 LightSwitch 中使用这个扩展方法来获取屏幕上的所有控件：
public static class ScreenObjectExtensions
{
public static IEnumerable<IContentItemProxy> FindControls(this IScreenObject screen)
{
var model = screen.Details.GetModel();
return model.GetChildItems()
.SelectManyRecursive(c => c.GetChildItems())
.OfType<IContentItemDefinition>()
.Select(c => screen.FindControl(c.Name));
}
}
于 2013-06-21T14:26:22.450 回答
7
这是修改后的 Jon Skeet 的答案，允许超过“一个级别”：
static IEnumerable Flatten(IEnumerable enumerable)
{
foreach (object element in enumerable)
{
IEnumerable candidate = element as IEnumerable;
if (candidate != null)
{
foreach (object nested in Flatten(candidate))
{
yield return nested;
}
}
else
{
yield return element;
}
}
}
免责声明：我不知道 C#。
在 Python 中也是如此：
#!/usr/bin/env python
def flatten(iterable):
for item in iterable:
if hasattr(item, '__iter__'):
for nested in flatten(item):
yield nested
else:
yield item
if __name__ == '__main__':
for item in flatten([1,[2, 3, [[4], 5]], 6, [[[7]]], [8]]):
print(item, end=" ")
它打印：
1 2 3 4 5 6 7 8
于 2008-11-21T21:04:12.953 回答
6
这不是 [SelectMany][1] 的用途吗？
enum1.SelectMany(
a => a.SelectMany(
b => b.SelectMany(
c => c.Select(
d => d.Name
)
)
)
);
于 2008-09-26T19:48:49.357 回答
3
功能：
public static class MyExtentions
{
public static IEnumerable<T> RecursiveSelector<T>(this IEnumerable<T> nodes, Func<T, IEnumerable<T>> selector)
{
if(nodes.Any() == false)
{
return nodes;
}
var descendants = nodes
.SelectMany(selector)
.RecursiveSelector(selector);
return nodes.Concat(descendants);
}
}
用法：
var ar = new[]
{
new Node
{
Name = "1",
Chilren = new[]
{
new Node
{
Name = "11",
Children = new[]
{
new Node
{
Name = "111",
}
}
}
}
}
};
var flattened = ar.RecursiveSelector(x => x.Children).ToList();
于 2015-05-19T12:08:29.877 回答
2
好的，这是另一个版本，它结合了上面大约 3 个答案。
递归的。使用产量。通用的。可选过滤谓词。可选的选择功能。尽可能简洁。
public static IEnumerable<TNode> Flatten<TNode>(
this IEnumerable<TNode> nodes,
Func<TNode, bool> filterBy = null,
Func<TNode, IEnumerable<TNode>> selectChildren = null
)
{
if (nodes == null) yield break;
if (filterBy != null) nodes = nodes.Where(filterBy);
foreach (var node in nodes)
{
yield return node;
var children = (selectChildren == null)
? node as IEnumerable<TNode>
: selectChildren(node);
if (children == null) continue;
foreach (var child in children.Flatten(filterBy, selectChildren))
{
yield return child;
}
}
}
用法：
// With filter predicate, with selection function
var flatList = nodes.Flatten(n => n.IsDeleted == false, n => n.Children);
于 2018-04-15T22:57:03.030 回答
1
SelectMany扩展方法已经这样做了。
将序列的每个元素投影到 IEnumerable<(Of <(T>)>) 并将结果序列展平为一个序列。
于 2008-10-23T12:16:57.257 回答
1
由于 VB 中不提供 yield 并且 LINQ 提供了延迟执行和简洁的语法，因此您也可以使用。
<Extension()>
Public Function Flatten(Of T)(ByVal objects As Generic.IEnumerable(Of T), ByVal selector As Func(Of T, Generic.IEnumerable(Of T))) As Generic.IEnumerable(Of T)
If(objects.Any()) Then
Return objects.Union(objects.Select(selector).Where(e => e != null).SelectMany(e => e)).Flatten(selector))
Else
Return objects
End If
End Function
public static class Extensions{
public static IEnumerable<T> Flatten<T>(this IEnumerable<T> objects, Func<T, IEnumerable<T>> selector) where T:Component{
if(objects.Any()){
return objects.Union(objects.Select(selector).Where(e => e != null).SelectMany(e => e).Flatten(selector));
}
return objects;
}
}
编辑为包括：
- 每个https://stackoverflow.com/a/30325216/107683的空可枚举 ，
- 每个https://stackoverflow.com/a/39338919/107683可枚举为 null
- C# 实现。
于 2010-09-17T19:04:47.123 回答
1
我不得不从头开始实现我的，因为如果有一个循环，即一个指向其祖先的孩子，所有提供的解决方案都会中断。如果您有与我相同的要求，请查看此（如果我的解决方案在任何特殊情况下会中断，请告诉我）：
如何使用：
var flattenlist = rootItem.Flatten(obj => obj.ChildItems, obj => obj.Id)
代码：
public static class Extensions
{
/// <summary>
/// This would flatten out a recursive data structure ignoring the loops. The end result would be an enumerable which enumerates all the
/// items in the data structure regardless of the level of nesting.
/// </summary>
/// <typeparam name="T">Type of the recursive data structure</typeparam>
/// <param name="source">Source element</param>
/// <param name="childrenSelector">a function that returns the children of a given data element of type T</param>
/// <param name="keySelector">a function that returns a key value for each element</param>
/// <returns>a faltten list of all the items within recursive data structure of T</returns>
public static IEnumerable<T> Flatten<T>(this IEnumerable<T> source,
Func<T, IEnumerable<T>> childrenSelector,
Func<T, object> keySelector) where T : class
{
if (source == null)
throw new ArgumentNullException("source");
if (childrenSelector == null)
throw new ArgumentNullException("childrenSelector");
if (keySelector == null)
throw new ArgumentNullException("keySelector");
var stack = new Stack<T>( source);
var dictionary = new Dictionary<object, T>();
while (stack.Any())
{
var currentItem = stack.Pop();
var currentkey = keySelector(currentItem);
if (dictionary.ContainsKey(currentkey) == false)
{
dictionary.Add(currentkey, currentItem);
var children = childrenSelector(currentItem);
if (children != null)
{
foreach (var child in children)
{
stack.Push(child);
}
}
}
yield return currentItem;
}
}
/// <summary>
/// This would flatten out a recursive data structure ignoring the loops. The end result would be an enumerable which enumerates all the
/// items in the data structure regardless of the level of nesting.
/// </summary>
/// <typeparam name="T">Type of the recursive data structure</typeparam>
/// <param name="source">Source element</param>
/// <param name="childrenSelector">a function that returns the children of a given data element of type T</param>
/// <param name="keySelector">a function that returns a key value for each element</param>
/// <returns>a faltten list of all the items within recursive data structure of T</returns>
public static IEnumerable<T> Flatten<T>(this T source,
Func<T, IEnumerable<T>> childrenSelector,
Func<T, object> keySelector) where T: class
{
return Flatten(new [] {source}, childrenSelector, keySelector);
}
}
于 2014-07-14T22:59:05.430 回答
0
static class EnumerableExtensions
{
public static IEnumerable<T> Flatten<T>(this IEnumerable<IEnumerable<T>> sequence)
{
foreach(var child in sequence)
foreach(var item in child)
yield return item;
}
}
也许像这样？或者你的意思是它可能很深？
于 2008-09-26T19:42:53.007 回答
0
class PageViewModel {
public IEnumerable<PageViewModel> ChildrenPages { get; set; }
}
Func<IEnumerable<PageViewModel>, IEnumerable<PageViewModel>> concatAll = null;
concatAll = list => list.SelectMany(l => l.ChildrenPages.Any() ?
concatAll(l.ChildrenPages).Union(new[] { l }) : new[] { l });
var allPages = concatAll(source).ToArray();
于 2018-05-03T10:16:55.940 回答
-1
基本上，您需要有一个主 IENumerable 在您的递归函数之外，然后在您的递归函数中（伪代码）
private void flattenList(IEnumerable<T> list)
{
foreach (T item in list)
{
masterList.Add(item);
if (item.Count > 0)
{
this.flattenList(item);
}
}
}
虽然我真的不确定嵌套在 IEnumerable 中的 IEnumerable 是什么意思……那里面是什么？嵌套多少级？最后的类型是什么？显然我的代码不正确，但我希望它能让你思考。
于 2008-09-26T19:47:06.680 回答