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