使用 LINQ 获取 IEnumerable 中的上一个和下一个项目

Question

我有一个自定义类型的 IEnumerable。 （我从 SelectMany 获得的）

我在 IEnumerable 中还有一个项目 (myItem)，我希望从 IEnumerable 中获取上一个和下一个项目。

目前，我正在做这样的事情：

var previousItem = myIEnumerable.Reverse().SkipWhile( 
    i => i.UniqueObjectID != myItem.UniqueObjectID).Skip(1).FirstOrDefault();

我可以通过简单地省略 .Reverse 来获取下一个项目。

或者，我可以：

int index = myIEnumerable.ToList().FindIndex( 
    i => i.UniqueObjectID == myItem.UniqueObjectID)

然后使用 .ElementAt(index +/- 1) 获取上一个或下一个项目。

1. 这两个选项之间哪个更好？
2. 还有更好的选择吗？

“更好”包括性能（内存和速度）和可读性的结合；可读性是我最关心的问题。

Answer 1

通过创建一个扩展方法来建立当前元素的上下文，您可以使用如下的 Linq 查询：

var result = myIEnumerable.WithContext()
    .Single(i => i.Current.UniqueObjectID == myItem.UniqueObjectID);
var previous = result.Previous;
var next = result.Next;

扩展将如下所示：

public class ElementWithContext<T>
{
    public T Previous { get; private set; }
    public T Next { get; private set; }
    public T Current { get; private set; }

    public ElementWithContext(T current, T previous, T next)
    {
        Current = current;
        Previous = previous;
        Next = next;
    }
}

public static class LinqExtensions
{
    public static IEnumerable<ElementWithContext<T>> 
        WithContext<T>(this IEnumerable<T> source)
    {
        T previous = default(T);
        T current = source.FirstOrDefault();

        foreach (T next in source.Union(new[] { default(T) }).Skip(1))
        {
            yield return new ElementWithContext<T>(current, previous, next);
            previous = current;
            current = next;
        }
    }
}

Answer 2

您可以将可枚举缓存在列表中，

var myList = myIEnumerable.ToList()

通过索引对其进行迭代

for (int i = 0; i < myList.Count; i++)

，然后当前元素是 myList[i]，前一个元素是 myList[i-1]，并且下一个元素是 myList[i+1]

（不要忘记列表中第一个和最后一个元素的特殊情况。）

Answer 3

你真的把事情复杂化了：

有时，仅仅一个 for 循环会更好地做某事，我认为为你想要做的事情提供一个更清晰的实现/

var myList = myIEnumerable.ToList();

for(i = 0; i < myList.Length; i++)
{
   if(myList[i].UniqueObjectID == myItem.UniqueObjectID) 
   {
      previousItem = myList[(i - 1) % (myList.Length - 1)];
      nextItem = myList[(i + 1) % (myList.Length - 1)];
   }
} 

Answer 4

下面是一个 LINQ 扩展方法，它返回当前项以及上一项和下一项。它产生 ValueTuple< /code>值以避免分配。源被枚举一次。

/// <summary>
/// Projects each element of a sequence into a tuple that includes the previous
/// and the next element.
/// </summary>
public static IEnumerable<(T Previous, T Current, T Next)> WithPreviousAndNext<T>(
    this IEnumerable<T> source, T firstPrevious = default, T lastNext = default)
{
    ArgumentNullException.ThrowIfNull(source);
    (T Previous, T Current, bool HasPrevious) queue = (default, firstPrevious, false);
    foreach (var item in source)
    {
        if (queue.HasPrevious)
            yield return (queue.Previous, queue.Current, item);
        queue = (queue.Current, item, true);
    }
    if (queue.HasPrevious)
        yield return (queue.Previous, queue.Current, lastNext);
}

用法示例：

var source = Enumerable.Range(1, 5);
Console.WriteLine($"Source: {String.Join(", ", source)}");
var result = source.WithPreviousAndNext(firstPrevious: -1, lastNext: -1);
Console.WriteLine($"Result: {String.Join(", ", result)}");

输出：

Source: 1, 2, 3, 4, 5  
Result: (-1, 1, 2), (1, 2, 3), (2, 3, 4), (3, 4, 5), (4, 5, -1)  

要获取特定项目的上一个和下一个，您可以使用 元组解构：

var (previous, current, next) = myIEnumerable
    .WithPreviousAndNext()
    .First(e => e.Current.UniqueObjectID == myItem.UniqueObjectID);

Answer 5

CPU

完全取决于对象在序列中的位置。如果它位于末尾，我预计第二个会更快，超过 2 倍（但只是一个常数因子）。如果它位于开头，第一个会更快，因为您不需要遍历整个列表。

内存

第一个是迭代序列而不保存序列，因此内存占用会非常小。第二种解决方案将占用与列表长度*引用+对象+开销一样多的内存。

Answer 6

我想我会尝试使用 Linq 的 Zip 来回答这个问题。

string[] items = {"nought","one","two","three","four"};

var item = items[2];

var sandwiched =
    items
        .Zip( items.Skip(1), (previous,current) => new { previous, current } )
        .Zip( items.Skip(2), (pair,next) => new { pair.previous, pair.current, next } )     
        .FirstOrDefault( triplet => triplet.current == item );

这将返回一个匿名类型 {previous,current,next}。
不幸的是，这仅适用于索引 1,2 和 3。

string[] items = {"nought","one","two","three","four"};

var item = items[4]; 

var pad1 = Enumerable.Repeat( "", 1 );
var pad2 = Enumerable.Repeat( "", 2 );

var padded = pad1.Concat( items );
var next1 = items.Concat( pad1 );
var next2 = items.Skip(1).Concat( pad2 );

var sandwiched =
    padded
        .Zip( next1, (previous,current) => new { previous, current } )
        .Zip( next2, (pair,next) => new { pair.previous, pair.current, next } )
        .FirstOrDefault( triplet => triplet.current == item );

此版本适用于所有索引。
两个版本都使用 Linq 提供的惰性求值。

Answer 7

这里有一些承诺的扩展方法。这些名称是通用的，可与任何简单类型重用，并且存在查找重载来获取获取下一个或上一个项目所需的项目。我会对解决方案进行基准测试，然后看看在哪里可以挤出周期。

 public static class ExtensionMethods  
{
    public static T Previous<T>(this List<T> list, T item) { 
        var index = list.IndexOf(item) - 1;
        return index > -1 ? list[index] : default(T);
    }
    public static T Next<T>(this List<T> list, T item) {
        var index = list.IndexOf(item) + 1;
        return index < list.Count() ? list[index] : default(T);
    }
    public static T Previous<T>(this List<T> list, Func<T, Boolean> lookup) { 
        var item = list.SingleOrDefault(lookup);
        var index = list.IndexOf(item) - 1;
        return index > -1 ? list[index] : default(T);
    }
    public static T Next<T>(this List<T> list, Func<T,Boolean> lookup) {
        var item = list.SingleOrDefault(lookup);
        var index = list.IndexOf(item) + 1;
        return index < list.Count() ? list[index] : default(T);
    }
    public static T PreviousOrFirst<T>(this List<T> list, T item) { 
        if(list.Count() < 1) 
            throw new Exception("No array items!");

        var previous = list.Previous(item);
        return previous == null ? list.First() : previous;
    }
    public static T NextOrLast<T>(this List<T> list, T item) { 
        if(list.Count() < 1) 
            throw new Exception("No array items!");
        var next = list.Next(item);
        return next == null ? list.Last() : next;
    }
    public static T PreviousOrFirst<T>(this List<T> list, Func<T,Boolean> lookup) { 
        if(list.Count() < 1) 
            throw new Exception("No array items!");
        var previous = list.Previous(lookup);
        return previous == null ? list.First() : previous;
    }
    public static T NextOrLast<T>(this List<T> list, Func<T,Boolean> lookup) { 
        if(list.Count() < 1) 
            throw new Exception("No array items!");
        var next = list.Next(lookup);
        return next == null ? list.Last() : next;
    }
}

你可以像这样使用它们。

var previous = list.Previous(obj);
var next = list.Next(obj);
var previousWithLookup = list.Previous((o) => o.LookupProperty == otherObj.LookupProperty);
var nextWithLookup = list.Next((o) => o.LookupProperty == otherObj.LookupProperty);
var previousOrFirst = list.PreviousOrFirst(obj);
var nextOrLast = list.NextOrLast(ob);
var previousOrFirstWithLookup = list.PreviousOrFirst((o) => o.LookupProperty == otherObj.LookupProperty);
var nextOrLastWithLookup = list.NextOrLast((o) => o.LookupProperty == otherObj.LookupProperty);

Answer 8

我使用以下技术：

var items = new[] { "Bob", "Jon", "Zac" };

var sandwiches = items
                    .Sandwich()
                    .ToList();

产生此结果：

请注意，第一个 Previous 值和最后一个 Next 值均为空。

它使用以下扩展方法：

public static IEnumerable<(T Previous, T Current, T Next)> Sandwich<T>(this IEnumerable<T> source, T beforeFirst = default, T afterLast = default)
{
    var sourceList = source.ToList();

    T previous = beforeFirst;
    T current = sourceList.FirstOrDefault();

    foreach (var next in sourceList.Skip(1))
    {
        yield return (previous, current, next);

        previous = current;
        current = next;
    }

    yield return (previous, current, afterLast);
}

Answer 9

如果您需要 myIEnumerable 中的每个元素，我只需迭代它并保留对前 2 个元素的引用。在循环体中，我将对第二个前一个元素进行处理，当前元素将是其后代，第一个元素将是其祖先。

如果您只需要一个元素，我会选择您的第一种方法。

Answer 10

首先

“更好”包括性能（内存和速度）的组合

一般来说，你不能两者兼得，经验法则是，如果你优化速度，它会消耗内存，如果你优化内存，它会消耗内存你速度。

有一个更好的选项，它在内存和速度方面都表现良好，并且可以以可读的方式使用（我对函数名称不满意，但是，FindItemReturningPreviousItemFoundItemAndNextItem有点满口）。

因此，看起来是时候使用自定义查找扩展方法了，例如 . 。 。

public static IEnumerable<T> FindSandwichedItem<T>(this IEnumerable<T> items, Predicate<T> matchFilling)
{
    if (items == null)
        throw new ArgumentNullException("items");
    if (matchFilling == null)
        throw new ArgumentNullException("matchFilling");

    return FindSandwichedItemImpl(items, matchFilling);
}

private static IEnumerable<T> FindSandwichedItemImpl<T>(IEnumerable<T> items, Predicate<T> matchFilling)
{
    using(var iter = items.GetEnumerator())
    {
        T previous = default(T);
        while(iter.MoveNext())
        {
            if(matchFilling(iter.Current))
            {
                yield return previous;
                yield return iter.Current;
                if (iter.MoveNext())
                    yield return iter.Current;
                else
                    yield return default(T);
                yield break;
            }
            previous = iter.Current;
        }
    }
    // If we get here nothing has been found so return three default values
    yield return default(T); // Previous
    yield return default(T); // Current
    yield return default(T); // Next
}

如果您需要多次引用这些项目，您可以将其结果缓存到列表中，但它会返回找到的项目，前面是前一个项目，后面是后面的项目。例如

var sandwichedItems = myIEnumerable.FindSandwichedItem(item => item.objectId == "MyObjectId").ToList();
var previousItem = sandwichedItems[0];
var myItem = sandwichedItems[1];
var nextItem = sandwichedItems[2];

，如果它是第一个或最后一个项目，则返回的默认值可能需要根据您的要求进行更改。

希望这有帮助。

Answer 11

为了便于阅读，我将 IEnumerable 加载到链接列表中：

var e = Enumerable.Range(0,100);
var itemIKnow = 50;
var linkedList = new LinkedList<int>(e);
var listNode = linkedList.Find(itemIKnow);
var next = listNode.Next.Value; //probably a good idea to check for null
var prev = listNode.Previous.Value; //ditto