Использование LINQ для получения 100 лучших и 100 худших?

var sorted = list.OrderBy(i => i.Value);
var top100 = sorted.Take(100);
var last100 = sorted.Reverse().Take(100);
var result = top100.Concat(last100).OrderBy(i => i.Value2);

Я не знаю, хотите ли вы Concat или Union в конце. Concat объединит все записи обоих списков, даже если есть похожие записи, что может быть в том случае, если исходный список содержит менее 200 записей. Union будет добавлять только материалы из last100, которых еще нет в top100.

Некоторые вещи, которые не ясны, но которые следует учитывать:

• Если список представляет собой IQueryable для базы данных, возможно, целесообразно использовать ToArray() или ToList(), например

  var sorted = list.OrderBy(i => i.Value).ToArray();
  

  с начала. Таким образом, выполняется только один запрос к базе данных, а остальные выполняются в памяти.

• Метод Reverse не оптимизирован так, как я надеялся, но это не должно быть проблемой, так как упорядочивание списка — это реальное дело. Для справки, метод пропуска, описанный в других ответах здесь, вероятно, немного быстрее, но ему необходимо знать количество элементов в списке.

• Если бы список был бы LinkedList или другим классом, реализующим IList, метод Reverse можно было бы сделать оптимизированным способом.

Вы можете использовать метод расширения следующим образом:

public static IEnumerable<T> TakeFirstAndLast<T>(this IEnumerable<T> source, int count)
{
    var first = new List<T>();
    var last = new LinkedList<T>();
    foreach (var item in source)
    {
        if (first.Count < count)
            first.Add(item);
        if (last.Count >= count)
            last.RemoveFirst();
        last.AddLast(item);
    }

    return first.Concat(last);
}

(Я использую LinkedList<T> для last, потому что он может удалять элементы в O(1))

Вы можете использовать его следующим образом:

.Orderby(i => i.Value1)
.TakeFirstAndLast(100)
.Orderby(i => i.Value2);

Обратите внимание, что он не обрабатывает случай, когда элементов меньше 200: в этом случае вы получите дубликаты. При необходимости их можно удалить с помощью Distinct.

Возьмите верхние 100 и нижние 100 отдельно и объедините их:

var tempresults = yourenumerable.OrderBy(i => i.Value1);
var results = tempresults.Take(100);
results = results.Union(tempresults.Skip(tempresults.Count() - 100).Take(100))
                 .OrderBy(i => i.Value2);

Вы можете сделать это с помощью одного оператора, также используя этот .Where перегружается, если у вас есть доступное количество элементов:

var elements = ...

var count = elements.Length; // or .Count for list

var result = elements
    .OrderBy(i => i.Value1)
    .Where((v, i) => i < 100 || i >= count - 100)
    .OrderBy(i => i.Value2)
    .ToArray();             // evaluate

Вот как это работает:

| first 100 elements | middle elements | last 100 elements |
        i < 100        i < count - 100    i >= count - 100

Вы можете написать свой собственный метод расширения, например Take(), Skip() и другие методы класса Enumerable. Он будет принимать количество элементов и общую длину в списке в качестве входных данных. Затем он вернет первый и последний N элементы из последовательности.

var result = yourList.OrderBy(x => x.Value1)
                     .GetLastAndFirst(100, yourList.Length)
                     .OrderBy(x => x.Value2)
                     .ToList();

Вот метод расширения:

public static class SOExtensions
{
    public static IEnumerable<T> GetLastAndFirst<T>(
        this IEnumerable<T> seq, int number, int totalLength
    )
    {
        if (totalLength < number*2) 
            throw new Exception("List length must be >= (number * 2)");

        using (var en = seq.GetEnumerator())
        {
            int i = 0;

            while (en.MoveNext())
            {
                i++;
                if (i <= number || i >= totalLength - number) 
                     yield return en.Current;
            }
        }
    }
}