Obtenir précédent et suivant dans un IEnumerable à l'aide de LINQ

Tout d'abord

"Mieux" comprend une combinaison de la performance (mémoire et de la vitesse)

En général, vous ne pouvez pas avoir les deux, la règle de base est que, si vous optimiser pour la vitesse, il vous en coûtera la mémoire, si vous optimiser pour mémoire, il vous en coûtera de vitesse.

Il existe une meilleure solution, qui fonctionne bien sur à la fois la mémoire et la vitesse des fronts, et peut être utilisé d'une manière lisible (je ne suis pas heureux avec le nom de la fonction, cependant, FindItemReturningPreviousItemFoundItemAndNextItem est un peu de la taille d'une bouchée).

Donc, on dirait qu'il est temps pour une mesure de trouver la méthode d'extension, quelque chose comme . . .

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
}

Vous pouvez mettre en cache le résultat de cette liste si vous avez besoin de se référer à des articles plus d'une fois, mais il renvoie l'élément trouvé, précédée de la rubrique précédente, suivie par l'élément suivant. par exemple,

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

Les valeurs par défaut de revenir si c'est le premier ou le dernier élément peut être nécessaire de changer en fonction de vos besoins.

Espère que cette aide.

Par la création d'une extension de la méthode pour l'établissement d'un contexte à l'élément en cours vous pouvez utiliser une requête Linq comme ceci:

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

L'extension serait quelque chose comme ceci:

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

CPU

Dépend entièrement de l'endroit où l'objet est dans la séquence. Si elle est située à la fin j'attendrais la deuxième à être plus rapide avec plus d'un facteur 2 (mais seulement un facteur constant). Si elle est située au début de la première sera plus rapide parce que vous n'avez pas à parcourir toute la liste.

Mémoire

La première est une itération de la séquence sans enregistrer la séquence de sorte que la mémoire de hit sera très petite. La deuxième solution sera de prendre autant de mémoire que la longueur de la liste * références + objets + les frais généraux.

J'ai pensé que je voudrais essayer de répondre à cette aide Zip de 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 );

Cela renvoie un type anonyme {précédente,le courant,la prochaine}.
Malheureusement, cela ne fonctionne que pour les indices 1, 2 et 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 );

Cette version fonctionnera pour tous les index.
À la fois utiliser la version d'évaluation différée de courtoisie de Linq.