IEnumerable <Object>特定数据排序

Question

我有一个对象，包含属性ID值在101和199之间。如何订购它像199,101,102 ... 198？

结果我想把最后一项放在第一位。

Answer 1

所需的排序是没有意义的（一些的推理是有帮助的），但是这应该做的伎俩：

int maxID = items.Max(x => x.ID); // If you want the Last item instead of the one 
            // with the greatest ID, you can use 
            // items.Last().ID instead. 
var strangelyOrderedItems = items 
    .OrderBy(x => x.ID == maxID ? 0 : 1) 
    .ThenBy(x => x.ID); 

Answer 2

编辑：错过了关于你想要最后一个项目的部分。你可以做这样的：

var objectList = new List<DataObject>(); 
var lastob = objectList.Last(); 
objectList.Remove(lastob); 
var newList = new List<DataObject>(); 
newList.Add(lastob); 
newList.AddRange(objectList.OrderBy(o => o.Id).ToList()); 

如果你是在谈论一个正常的排序，你可以通过方法这样使用LINQ的命令：
objectList = objectList.OrderBy(ob => ob.ID).ToList();

Answer 3

在结果，我想最后一个项目放到第一

第一排序列表

List<int> values = new List<int>{100, 56, 89..}; 
var result = values.OrderBy(x=>x); 

添加扩展方法，用于在使用后swaping一个元件在List<T>

static void Swap<T>(this List<T> list, int index1, int index2) 
{ 
    T temp = list[index1]; 
    list[index1] = list[index2]; 
    list[index2] = temp; 
} 

它

result .Swap(0, result.Count -1); 

Answer 4

var myList = new List<MyObject>(); 
//initialize the list 
var ordered = myList.OrderBy(c => c.Id); //or use OrderByDescending if you want reverse order 

Answer 5

你可以用一个Linq表达来实现这一点。

var ordering = testData 
    .OrderByDescending(t => t.Id) 
    .Take(1) 
    .Union(testData.OrderBy(t => t.Id).Take(testData.Count() - 1)); 

定购反方向，并采取顶部1，则责令其“正确的方式轮”，并采取一切，但最后和工会这些结合在一起。这种方法有很多变种，但上述方法应该可行。

此方法也适用于任意列表，无需知道最大数量。

Answer 6

如何

var orderedItems = items.OrderBy(x => x.Id) 
var orderedItemsLastFirst = 
    orderedItems.Reverse().Take(1).Concat(orderedItems.Skip(1)); 

这将重复几遍这个单子所以也许可以更有效，但不会使用太多的代码。

如果更多的速度很重要，您可以编写一个专门的IEnumerable扩展，它允许您在不转换为中间IEnumerable的情况下进行排序和返回。

Answer 7

取决于你是否有兴趣在列表中的最大项目，或者在列表中的最后一个项目：

internal sealed class Object : IComparable<Object> 
{ 
    private readonly int mID; 
    public int ID { get { return mID; } } 
    public Object(int pID) { mID = pID; } 

    public static implicit operator int(Object pObject) { return pObject.mID; } 
    public static implicit operator Object(int pInt) { return new Object(pInt); } 

    public int CompareTo(Object pOther) { return mID - pOther.mID; } 
    public override string ToString() { return string.Format("{0}", mID); } 
} 


List<Object> myList = new List<Object> { 1, 2, 6, 5, 4, 3 }; 

// the last item first 
List<Object> last = new List<Object> { myList.Last() }; 
List<Object> lastFirst = 
    last.Concat(myList.Except(last).OrderBy(x => x)).ToList(); 

lastFirst.ForEach(Console.Write); 
Console.WriteLine(); 
// outputs: 312456  

// or 

// the largest item first 
List<Object> max = new List<Object> { myList.Max() }; 
List<Object> maxFirst = 
    max.Concat(myList.Except(max).OrderBy(x => x)).ToList(); 

maxFirst.ForEach(Console.Write); 
Console.WriteLine(); 
// outputs: 612345