将 IEnumerable 拆分为两个

Question

我想将一个列表分成两个列表，一个可以直接处理，另一个是剩余的，将通过链传递给其他处理程序。

输入：

• 一个项目列表
• 一种过滤方法，用于确定将项目包含在哪个列表中。

输出：

• “真实”列表
• “假”列表

这已经存在了吗？也许我目前没有想到的 Linq 方法？否则，有人有好的 C# 示例吗？

Answer 1

这是一种简单的方法。请注意，ToLookup 急切地评估输入序列。

List<int> list = new List<int> { 1, 2, 3, 4, 5, 6 };

var lookup = list.ToLookup(num => num % 2 == 0);

IEnumerable<int> trueList = lookup[true];
IEnumerable<int> falseList = lookup[false];

您可以使用GroupBy 对输入序列进行惰性求值，但它不是相当那么漂亮：

var groups = list.GroupBy(num => num % 2 == 0);

IEnumerable<int> trueList = groups.Where(group => group.Key).FirstOrDefault();
IEnumerable<int> falseList = groups.Where(group => !group.Key).FirstOrDefault();

Answer 2

经过一些考虑和一些相当垃圾的想法，我得出了结论：不要试图让 LINQ 为你做这件事。

有几个简单的循环来消耗您的输入序列，将每个元素传递给第一个可以处理它的“处理程序”，并确保您的最后一个处理程序捕获所有内容，或者在最坏的情况下返回 List 而不是 @ 987654322@.

public static void Handle(
    IEnumerable<T> source,
    Action<T> catchAll,
    params Func<T, bool>[] handlers)
{
    foreach (T t in source)
    {
        int i = 0; bool handled = false;
        while (i < handlers.Length && !handled)
            handled = handlers[i++](t);
        if (!handled) catchAll(t);
    }
}

// e.g.
public bool handleP(int input, int p)
{
    if (input % p == 0)
    {
        Console.WriteLine("{0} is a multiple of {1}", input, p);
        return true;
    }
    return false;
}


Handle(
    source,
    i => { Console.WriteLine("{0} has no small prime factor"); },
    i => handleP(i, 2),
    i => handleP(i, 3),
    ...
    );

这样做的好处是可以按输入顺序处理每个元素，而不是将它们分成组并在您随后执行任何操作之前丢失排序。

Answer 3

我同意 Servy 的回答，但是在 cmets 进行之后，我认为这种方法可能会很有趣：

static class EnumerableExtensions
{
    public static IEnumerable<TSource> Fork<TSource>(
        this IEnumerable<TSource> source,
        Func<TSource, bool> filter,
        Action<TSource> secondary)
    {
        if (source == null) throw new ArgumentNullException("source");
        //...

        return ForkImpl(source, filter, secondary);
    }

    private static IEnumerable<TSource> ForkImpl<TSource>(
        this IEnumerable<TSource> source,
        Func<TSource, bool> filter,
        Action<TSource> secondary)
    {
        foreach(var e in source)
            if (filter(e))
                yield return e;
            else
                secondary(e);
    }
}

可以这样使用：

var ints = new [] { 1,2,3,4,5,6,7,8,9 };

// one possible use of the secondary sequence: accumulation
var acc = new List<int>();

foreach (var i in ints.Fork(x => x % 2 == 0, t => acc.Add(t)))
{
    //...
}

// later on we can process the accumulated secondary sequence
process(acc);

这里我们对二级序列进行累积（“假”值），但也可以对二级序列进行实时处理，因此只需枚举一次源。

Answer 4

尽可能使用 LINQ：

public IEnumerable<T> Filter(IEnumerable<T> source, Func<T, bool> criterium, out IEnumerable<T> remaining)
{
    IEnumerable<T> matching = source.Where(criterium);
    remaining = source.Except(matching);

    return matching;
}