¿Cómo puedo obtener cada enésimo elemento de una List <T>?

Estoy usando .NET 3.5 y me gustaría poder obtener todos los * n* elementos de una lista. No me preocupa si se logra usando una expresión lambda o LINQ.

Editar

Parece que esta pregunta provocó bastante debate (lo cual es bueno, ¿no?). Lo principal que he aprendido es que cuando crees que sabes todas las formas de hacer algo (incluso tan simple como esto), ¡piénsalo de nuevo!

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

Sé que es "de la vieja escuela", pero ¿por qué no usar un bucle for con stepping = n?

Suena como

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

haría el truco. No veo la necesidad de usar Linq o expresiones lambda.

EDITAR:

Hazlo

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

y escribes a la manera de LINQish

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

2da edición :

Para hacerlo aún más LINQish

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

Puede usar la sobrecarga Where que pasa el índice junto con el elemento

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

En bucle

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

No estoy seguro de si es posible hacerlo con una expresión LINQ, pero sé que puede usar el Wheremétodo de extensión para hacerlo. Por ejemplo, para obtener cada quinto artículo:

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

Esto obtendrá el primer elemento y cada quinto a partir de ahí. Si desea comenzar en el quinto elemento en lugar del primero, compare con 4 en lugar de comparar con 0.

Creo que si proporciona una extensión linq, debería poder operar en la interfaz menos específica, por lo tanto, en IEnumerable. Por supuesto, si está preparado para la velocidad, especialmente para N grandes, puede proporcionar una sobrecarga para el acceso indexado. Este último elimina la necesidad de iterar sobre grandes cantidades de datos no necesarios y será mucho más rápido que la cláusula Where. Proporcionar ambas sobrecargas permite al compilador seleccionar la variante más adecuada.

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

salida

En mi humilde opinión, ninguna respuesta es correcta. Todas las soluciones comienzan desde 0. Pero quiero tener el n-ésimo elemento real

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 Me gusta esto, porque el código del cliente es muy legible y el compilador elige la implementación más eficiente. Me basaría en esto reduciendo los requisitos IReadOnlyList<T>y guardando la División para LINQ de alto rendimiento:

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