Come posso ottenere ogni ennesimo articolo da un List <T>?

Sto usando .NET 3.5 e vorrei essere in grado di ottenere ogni * n* esimo elemento da un elenco. Non mi interessa sapere se è stato ottenuto utilizzando un'espressione lambda o LINQ.

modificare

Sembra che questa domanda abbia provocato un bel po 'di dibattito (che è una buona cosa, giusto?). La cosa principale che ho imparato è che quando pensi di conoscere tutti i modi per fare qualcosa (anche semplice come questo), ripensaci!

return list.Where((x, i) => i % nStep == 0);

So che è "vecchia scuola", ma perché non usare semplicemente un ciclo for con stepping = n?

Sembra

IEnumerator<T> GetNth<T>(List<T> list, int n) {
  for (int i=0; i<list.Count; i+=n)
    yield return list[i]
}

farebbe il trucco. Non vedo la necessità di utilizzare Linq o espressioni lambda.

MODIFICARE:

Fallo

public static class MyListExtensions {
  public static IEnumerable<T> GetNth<T>(this List<T> list, int n) {
    for (int i=0; i<list.Count; i+=n)
      yield return list[i];
  }
}

e scrivi in ​​modo LINQish

from var element in MyList.GetNth(10) select element;

2a modifica :

Per renderlo ancora più LINQish

from var i in Range(0, ((myList.Length-1)/n)+1) select list[n*i];

È possibile utilizzare l'overload Where che passa l'indice insieme all'elemento

var everyFourth = list.Where((x,i) => i % 4 == 0);

Per Loop

for(int i = 0; i < list.Count; i += n)
    //Nth Item..

Non sono sicuro che sia possibile farlo con un'espressione LINQ, ma so che puoi usare il Wheremetodo di estensione per farlo. Ad esempio, per ottenere ogni quinto articolo:

List<T> list = originalList.Where((t,i) => (i % 5) == 0).ToList();

Questo otterrà il primo oggetto e ogni quinto da lì. Se vuoi iniziare dal quinto elemento invece del primo, confronta con 4 invece di confrontare con 0.

Penso che se fornisci un'estensione per linq, dovresti essere in grado di operare sull'interfaccia meno specifica, quindi su IEnumerable. Ovviamente, se sei pronto per la velocità soprattutto per N grandi, potresti fornire un sovraccarico per l'accesso indicizzato. Quest'ultimo elimina la necessità di iterare su grandi quantità di dati non necessari e sarà molto più veloce della clausola Where. Fornire entrambi gli overload consente al compilatore di selezionare la variante più adatta.

public static class LinqExtensions
{
    public static IEnumerable<T> GetNth<T>(this IEnumerable<T> list, int n)
    {
        if (n < 0)
            throw new ArgumentOutOfRangeException("n");
        if (n > 0)
        {
            int c = 0;
            foreach (var e in list)
            {
                if (c % n == 0)
                    yield return e;
                c++;
            }
        }
    }
    public static IEnumerable<T> GetNth<T>(this IList<T> list, int n)
    {
        if (n < 0)
            throw new ArgumentOutOfRangeException("n");
        if (n > 0)
            for (int c = 0; c < list.Count; c += n)
                yield return list[c];
    }
}

private static readonly string[] sequence = "1,2,3,4,5,6,7,8,9,10,11,12,13,14,15".Split(',');

static void Main(string[] args)
{
    var every4thElement = sequence
      .Where((p, index) => index % 4 == 0);

    foreach (string p in every4thElement)
    {
        Console.WriteLine("{0}", p);
    }

    Console.ReadKey();
}

produzione

Imho nessuna risposta è giusta. Tutte le soluzioni iniziano da 0. Ma voglio avere l'ennesimo elemento reale

public static IEnumerable<T> GetNth<T>(this IList<T> list, int n)
{
    for (int i = n - 1; i < list.Count; i += n)
        yield return list[i];
}

@belucha Mi piace, perché il codice client è molto leggibile e il compilatore sceglie l'implementazione più efficiente. Vorrei basarmi su questo riducendo i requisiti IReadOnlyList<T>e per salvare la divisione per LINQ ad alte prestazioni:

    public static IEnumerable<T> GetNth<T>(this IEnumerable<T> list, int n) {
        if (n <= 0) throw new ArgumentOutOfRangeException(nameof(n), n, null);
        int i = n;
        foreach (var e in list) {
            if (++i < n) { //save Division
                continue;
            }
            i = 0;
            yield return e;
        }
    }

    public static IEnumerable<T> GetNth<T>(this IReadOnlyList<T> list, int n
        , int offset = 0) { //use IReadOnlyList<T>
        if (n <= 0) throw new ArgumentOutOfRangeException(nameof(n), n, null);
        for (var i = offset; i < list.Count; i += n) {
            yield return list[i];
        }
    }