Como posso obter cada enésimo item de um List <T>?

Estou usando o .NET 3.5 e gostaria de obter cada * n* o item de uma lista. Não estou preocupado em saber se isso é alcançado usando uma expressão lambda ou LINQ.

Editar

Parece que essa pergunta provocou bastante debate (o que é bom, certo?). A principal coisa que aprendi é que, quando você acha que sabe todas as maneiras de fazer algo (mesmo tão simples quanto isso), pense novamente!

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

Eu sei que é "old school", mas por que não usar um loop for com stepping = n?

Soa como

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

faria o truque. Não vejo necessidade de usar expressões Linq ou lambda.

EDITAR:

Faça

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 você escreve de maneira LINQish

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

2ª Edição :

Para torná-lo ainda mais LINQish

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

Você pode usar a sobrecarga de Where, que passa o índice junto com o elemento

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

For Loop

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

Não tenho certeza se é possível fazer com uma expressão LINQ, mas sei que você pode usar o Wheremétodo de extensão para fazer isso. Por exemplo, para obter cada quinto item:

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

Isso obterá o primeiro item e a cada cinco a partir daí. Se você quiser começar no quinto item em vez do primeiro, compare com 4 em vez de comparar com 0.

Eu acho que se você fornecer uma extensão linq, deverá ser capaz de operar na interface menos específica, portanto, em IEnumerable. Obviamente, se você deseja velocidade especialmente para N grandes, pode sobrecarregar o acesso indexado. O último elimina a necessidade de iterar sobre grandes quantidades de dados desnecessários e será muito mais rápido do que a cláusula Where. Fornecer ambas as sobrecargas permite que o compilador selecione a variante mais adequada.

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

resultado

Imho nenhuma resposta está certa. Todas as soluções começam em 0. Mas eu quero ter o ené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 Eu gosto disso, porque o código do cliente é muito legível e o compilador escolhe a implementação mais eficiente. Eu construiria sobre isso reduzindo os requisitos IReadOnlyList<T>e para salvar a Divisão para LINQ de alto desempenho:

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