Recupera i valori dagli elementi successivi e precedenti nell'elenco ordinato C#

Question

Ho una lista ordinata che passerà in due elementi e confronterà i due. Esiste una funzione nella classe SortedList in C# che eseguirà una successiva e una precedente? Ho avuto qualche aiuto con un .Skip, ma dato che le chiavi sarebbero variabili, come funzionerebbe? Tutto quello che devo fare è prendere il primo elemento e il secondo elemento, quindi saltare al terzo e al quarto, al quinto e al sesto, ecc. Vorrei che fosse semplice come ".next.next" di LinkedList.

double velocity = positionList.Values.Skip(1); 

Edit: La positionList è di tipo

<double, HandCoordinate> 
    HandCoordinate = {double, double, double} 

fa questo aiuto?

Grazie!

Answer 1

List<int> ints = new List<int>(); 
    ints.Add(1); 
    ints.Add(2); 
    ints.Add(3); 
    ints.Add(4); 
    for (int i = 0; i < ints.Count; i += 2) 
    { 
    var pair = ints.Skip(i).Take(2); 
    var first = pair.First(); 
    var last = pair.Last(); 
    } 

Nota: questo dovrebbe funzionare, irrilevante del tipo in teoria. A meno che il tipo sia un formato drasticamente diverso.

senza Skip().

var pair = new { First = ints[i], Second = ints[i += 1] }; 

Answer 2

La domanda non è chiara. Suppongo che tu debba ottenere coppie di cose da una lista?

E 'abbastanza facile scrivere un metodo di estensione che presenterà una sequenza di coppie di elementi da un oggetto IEnumerable:

using System; 
using System.Collections.Generic; 

namespace Demo 
{ 
    internal static class Program 
    { 
     public static void Main() 
     { 
      double[] test = new double[] {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; 

      foreach (var pair in test.AsPairs()) // This is how you use it. 
      { 
       Console.WriteLine("({0}, {1})", pair.Item1, pair.Item2); 
       // Or simply: Console.WriteLine(pair); 
      } 
     } 
    } 

    public static class EnumerableExt 
    { 
     public static IEnumerable<Tuple<T, T>> AsPairs<T>(this IEnumerable<T> sequence) 
     { 
      bool isFirst = true; 
      T first = default(T); 

      foreach (var item in sequence) 
      { 
       if (isFirst) 
       { 
        first = item; 
        isFirst = false; 
       } 
       else 
       { 
        isFirst = true; 
        yield return new Tuple<T, T>(first, item); 
       } 
      } 
     } 
    } 
} 

Answer 3

I inherites classe SortedList IEnumerator, in modo da poter utilizzare:

SortedList list = ... 
var listEnumerator = ((IEnumerable)list).GetEnumerator(); 
Pair<MyType> pair = null 
do 
{ 
    pair = Pair.Next<MyType>(listEnumerator); 
    ... 
} 
while(pair != null) 

...

class Pair<T> 
{ 
    public T First {get; set;} 
    public T Second {get; set;} 

    public static Pair<T> Next<T>(IEnumerator enumerator) 
    { 
     var first = enumerator.Current; 
     if(enumerator.MoveNext()) 
     { 
      return new Pair<T> 
       { 
        First = (T)first, 
        Second = (T)enumerator.Current, 
       } 
     } 
     return null; 
    } 
}