Получить предыдущий и следующий элемент в IEnumerable с помощью LINQ

Для удобства чтения я бы загрузил 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

Создавая метод расширения для установления контекста к текущему элементу, вы можете использовать запрос 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;
        }
    }
}

Вы можете кэшировать перечисляемое в списке

var myList = myIEnumerable.ToList()

Перебираем его по индексу

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

Тогда текущий элемент - myList[i], предыдущий элемент - myList[i-1], а следующий элемент - myList[i+1]

(Не забывайте о частных случаях первого и последнего элементов в списке.)

Процессор

Полностью зависит от того, где находится объект в последовательности. Если он расположен в конце, я ожидал бы, что второй будет быстрее с более чем фактором 2 (но только постоянным фактором). Если он расположен в начале, то первый будет быстрее, потому что вы не проходите весь список.

Память

Первый-это повторение последовательности без сохранения последовательности, поэтому попадание в память будет очень маленьким. Второе решение займет столько же времени. память как длина списка * ссылки + объекты + накладные расходы.

Вы действительно слишком усложняете вещи:

Иногда просто цикл 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)];
   }
} 

Я подумал, что попробую ответить на этот вопрос, используя Zip из Linq.

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 );

Это вернет анонимный тип {предыдущий, текущий, следующий}. К сожалению, это будет работать только для индексов 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.

Если вам это нужно для каждого элемента в myIEnumerable, я бы просто перебирал его, сохраняя ссылки на 2 предыдущих элемента. В теле цикла я бы сделал обработку для второго предыдущего элемента, и ток был бы его потомком, а первый предыдущий-его предком.

Если вам это нужно только для одного элемента, я бы выбрал ваш первый подход.