Odzyskaj wartości z następnego i poprzedniego elementu na liście posortowanej C#

Question

Mam posortowaną listę, która przejdzie w dwóch elementach i porówna dwa. Czy istnieje funkcja klasy SortedList w języku C#, która będzie robić następny i poprzedni? Mam pomoc przy .Skip, ale skoro klucze będą zmienne, jak by to działało? Wszystko, co muszę zrobić, to wziąć pierwszy element i drugi element, a następnie przejść do trzeciego i czwartego, piątego i szóstego itd. Chciałbym, żeby było tak proste jak "Linkednex".

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

Edycja: positionList jest typu

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

Czy to pomoże?

Dzięki!

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

Uwaga: Powinno to zadziałać, bez znaczenia dla typu teorii. O ile typ nie jest drastycznie innym formatem.

Bez Skip().

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

Answer 2

Pytanie jest nieco niejasne. Zakładam, że potrzebujesz pary rzeczy z listy?

Jest dość łatwo napisać metodę rozszerzenia, które zaprezentuje sekwencję par elementów z 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

W inherites klasa SortedList IEnumerator, więc można go używać:

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