使用LINQ将项目移到列表顶部

有没有办法使用LINQ将id = 10的项作为列表中的第一项移动？

项目A-id = 5
项目B-id = 10
项目C-id = 12
项目D-id = 1

在这种情况下，如何优雅地将商品C移到List<T>收藏夹的顶部？

这是我目前拥有的最好的：

var allCountries = repository.GetCountries();
var topitem = allCountries.Single(x => x.id == 592);  
var finalList = new List<Country>();
finalList.Add(topitem);
finalList = finalList.Concat(allCountries.Where(x=> x.id != 592)).ToList();

LINQ在查询集合，在现有查询上创建投影或基于现有集合生成新查询方面很强大。它并不意味着是对现有集合进行内联重新排序的工具。对于这种类型的操作，最好使用方便的类型。

假设您有一个具有类似以下定义的类型

class Item {
  public int Id { get; set; }
  ..
}

然后尝试以下

List<Item> list = GetTheList();
var index = list.FindIndex(x => x.Id == 12);
var item = list[index];
list[index] = list[0];
list[0] = item;

除了已知的顶级商品，您还想订购什么？如果您不在乎，则可以执行以下操作：

var query = allCountries.OrderBy(x => x.id != 592).ToList();

基本上，“ false”先于“ true” ...

诚然，我不知道这在LINQ to SQL等中的作用。您可能需要阻止它在数据库中进行排序：

var query = allCountries.AsEnumerable()
                        .OrderBy(x => x.id != 592)
                        .ToList();

Linq通常可在Enumerables上使用，因此现在基本类型不是集合。因此，为了将商品移至列表顶部，我建议使用类似的内容（如果您需要保留订单）

var idx = myList.FindIndex(x => x.id == 592);
var item = myList[idx];
myList.RemoveAt(idx);
myList.Insert(0, item);

如果您的函数仅返回IEnumerable，则可以使用该ToList()方法先将其转换为List

如果您不保留订单，则可以简单地交换位置0和位置idx的值

var allCountries = repository.GetCountries();
allCountries.OrderByDescending(o => o.id == 12).ThenBy(o => o.id) 

这会将id = 12的对象插入列表的顶部，并将其余部分向下旋转，从而保留顺序。

这是您可能要使用的扩展方法。它将与给定谓词匹配的元素移到顶部，并保持顺序。

public static IEnumerable<T> MoveToTop(IEnumerable<T> list, Func<T, bool> func) {
    return list.Where(func)
               .Concat(list.Where(item => !func(item)));
}

就复杂性而言，我认为它将对集合进行两次传递，使其像插入/删除版本一样成为O（n），但优于Jon Skeet的OrderBy建议。

您可以使用布尔键将“分组依据”分为两组，然后对其进行排序

var finalList= allCountries
                .GroupBy(x => x.id != 592)
                .OrderBy(g => g.Key)
                .SelectMany(g => g.OrderBy(x=> x.id ));

我知道这是一个老问题，但我是这样做的

class Program
{
    static void Main(string[] args)
    {
        var numbers = new int[] { 5, 10, 12, 1 };

        var ordered = numbers.OrderBy(num => num != 10 ? num : -1);

        foreach (var num in ordered)
        {
            Console.WriteLine("number is {0}", num);
        }

        Console.ReadLine();
    }
}

打印：

数字是10
数字是1
数字是5
数字是12

public static IEnumerable<T> ServeFirst<T>(this IEnumerable<T> source, 
    Predicate<T> p)
{
    var list = new List<T>();

    foreach (var s in source)
    {
        if (p(s))
            yield return s;
        else
            list.Add(s);
    }

    foreach (var s in list)
        yield return s;
}

有趣的是，您尝试解决问题时会发现许多方法。

var service = AutogateProcessorService.GetInstance();
var allConfigs = service.GetAll();
allConfigs = allConfigs.OrderBy(c => c.ThreadDescription).ToList();
var systemQueue = allConfigs.First(c => c.AcquirerId == 0);
allConfigs.Remove(systemQueue);
allConfigs.Insert(0, systemQueue);

还可以检查是否找到了没有异常的项目，例如：

var allCountries = repository.GetCountries();
var lookup = allCountries.ToLookup(x => x.id == 592);  
var finalList = lookup[true].Concat(lookup[false]).ToList();
if ( lookup[true].Count() != 1 ) YouAreInTrouble();

我写了一个静态扩展方法来做到这一点。请注意，这不会保留订单，只是将项目换出。如果需要保留订单，则应该轮换而不是简单的交换。

/// <summary>
/// Moves the item to the front of the list if it exists, if it does not it returns false
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="collection"></param>
/// <param name="predicate"></param>
/// <returns></returns>
public static bool MoveToFrontOfListWhere<T>(this List<T> collection, Func<T, bool> predicate)
{
    if (collection == null || collection.Count <= 0) return false;

    int index = -1;
    for (int i = 0; i < collection.Count; i++)
    {
        T element = collection.ElementAt(i);
        if (!predicate(element)) continue;
        index = i;
        break;
    }

    if (index == -1) return false;

    T item = collection[index];
    collection[index] = collection[0];
    collection[0] = item;
    return true;
}