The desired ordering makes no sense (some reasoning would be helpful), but this should do the trick:

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

Depending whether you are interested in the largest item in the list, or the last item in the list:

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

編集：最初に最後のアイテムが欲しいという部分を見逃しました。あなたはこのようにそれを行うことができます：

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

In result I want to put last item to first

first sort the list

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

add an extension method for swaping an elements in the 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;
}

after use it

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

You can acheive this using a single Linq statment.

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

Order it in reverse direction and take the top 1, then order it the "right way round" and take all but the last and union these together. There are quite a few variants of this approach, but the above should work.

This approach should work for arbitrary lists too, without the need to know the max number.

How about

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

This will iterate the list several times so perhaps could be more efficient but doesn't use much code.

If more speed is important you could write a specialised IEnumerable extension that would allow you to sort and return without converting to an intermediate IEnumerable.

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