How to insert item into list in order?

问题:

I have a List of DateTimeOffset objects, and I want to insert new ones into the list in order.

List<DateTimeOffset> TimeList = ...
// determine the order before insert or add the new item

Sorry, need to update my question.

List<customizedClass> ItemList = ...
//customizedClass contains DateTimeOffset object and other strings, int, etc.

ItemList.Sort();    // this won't work until set data comparison with DateTimeOffset
ItemList.OrderBy(); // this won't work until set data comparison with DateTimeOffset

Also, how to put DateTimeOffset as the parameter of .OrderBy()?

I have also tried:

ItemList = from s in ItemList
           orderby s.PublishDate descending    // .PublishDate is type DateTime
           select s;

However, it returns this error message,

Cannot implicitly convert type 'System.Linq.IOrderedEnumerable' to 'System.Collections.Gerneric.List'. An explicit conversion exist (are you missing a cast?)

回答1:

Modify your LINQ, add ToList() at the end:

ItemList = (from s in ItemList
            orderby s.PublishDate descending   
            select s).ToList();

Alternatively assign the sorted list to another variable

var sortedList = from s in ....

回答2:

Assuming your list is already sorted in ascending order

var index = TimeList.BinarySearch(dateTimeOffset);
if (index < 0) index = ~index;
TimeList.Insert(index, dateTimeOffset);

回答3:

A slightly improved version of @L.B.'s answer for edge cases:

public static class ListExt
{
    public static void AddSorted<T>(this List<T> @this, T item) where T: IComparable<T>
    {
        if (@this.Count == 0)
        {
            @this.Add(item);
            return;
        }
        if (@this[@this.Count-1].CompareTo(item) <= 0)
        {
            @this.Add(item);
            return;
        }
        if (@this[0].CompareTo(item) >= 0)
        {
            @this.Insert(0, item);
            return;
        }
        int index = @this.BinarySearch(item);
        if (index < 0) 
            index = ~index;
        @this.Insert(index, item);
    }
}

回答4:

With .NET 4 you can use the new SortedSet<T> otherwise you're stuck with the key-value collection SortedList.

SortedSet<DateTimeOffset> TimeList = new SortedSet<DateTimeOffset>();
// add DateTimeOffsets here, they will be sorted initially

Note: The SortedSet<T> class does not accept duplicate elements. If item is already in the set, this method returns false and does not throw an exception.

If duplicates are allowed you can use a List<DateTimeOffset> and use it's Sort method.

回答5:

To insert item to a specific index

you can use:

DateTimeOffset dto;

 // Current time
 dto = DateTimeOffset.Now;

//This will insert the item at first position
TimeList.Insert(0,dto);

//This will insert the item at last position
TimeList.Add(dto);

To sort the collection you can use linq:

//This will sort the collection in ascending order
List<DateTimeOffset> SortedCollection=from dt in TimeList select dt order by dt;

回答6:

very simple, after adding data into list

list.OrderBy(a => a.ColumnName).ToList();

回答7:

You can use Insert(index,object) after finding index you want.

回答8:

I took @Noseratio's answer and reworked and combined it with @Jeppe's answer from here to get a function that works for Collections (I needed it for an ObservableCollection of Paths) and type that does not implement IComparable.

    /// <summary>
    /// Inserts a new value into a sorted collection.
    /// </summary>
    /// <typeparam name="T">The type of collection values, where the type implements IComparable of itself</typeparam>
    /// <param name="collection">The source collection</param>
    /// <param name="item">The item being inserted</param>
    public static void InsertSorted<T>(this Collection<T> collection, T item) where T : IComparable<T>
    {
      InsertSorted(collection, item, Comparer<T>.Create((x, y) => x.CompareTo(y)));
    }

    /// <summary>
    /// Inserts a new value into a sorted collection.
    /// </summary>
    /// <typeparam name="T">The type of collection values</typeparam>
    /// <param name="collection">The source collection</param>
    /// <param name="item">The item being inserted</param>
    /// <param name="ComparerFunction">An IComparer to comparer T values, e.g. Comparer&lt;T&gt;.Create((x, y) =&gt; (x.Property &lt; y.Property) ? -1 : (x.Property &gt; y.Property) ? 1 : 0)</param>
    public static void InsertSorted<T>(this Collection<T> collection, T item, IComparer<T> ComparerFunction)
    {
      if (collection.Count == 0)
      {
        // Simple add
        collection.Add(item);
      }
      else if (ComparerFunction.Compare(item, collection[collection.Count - 1]) >= 0)
      {
        // Add to the end as the item being added is greater than the last item by comparison.
        collection.Add(item);
      }
      else if (ComparerFunction.Compare(item, collection[0]) <= 0)
      {
        // Add to the front as the item being added is less than the first item by comparison.
        collection.Insert(0, item);
      }
      else
      {
        // Otherwise, search for the place to insert.
        int index = Array.BinarySearch(collection.ToArray(), item, ComparerFunction);
        if (index < 0)
        {
          // The zero-based index of item if item is found; 
          // otherwise, a negative number that is the bitwise complement of the index of the next element that is larger than item or, if there is no larger element, the bitwise complement of Count.
          index = ~index;
        }
        collection.Insert(index, item);
      }
    }