¿Cómo insertar un elemento en la lista en orden?

Question

¿Alguien podría enseñarme cómo insertar elementos en la lista en orden en C#?

Tengo una lista de objetos DateTimeOffset, y quiero insertar nuevos en la lista en orden.

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

lo siento, necesito actualizar mi pregunta.

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 

Podría alguien por favor me ayude a poner DateTimeOffset como el parámetro de .OrderBy()?

También probé

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

Sin embargo, devuelve este mensaje de error,

No se puede convertir implícitamente el tipo 'System.Linq.IOrderedEnumerable' a 'System.Collections.Gerneric.List'. Una conversión explícita existe (¿falta una fundición?)

Answer 1

? Modifica LINQ, añadir ToList() al final:

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

asignar Como alternativa, la lista ordenada a otra variable

var sortedList = from s in .... 

Answer 2

Para insertar elemento a un índice específico

que puede utilizar:

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

Para ordenar la colección se puede utilizar LINQ:

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

Answer 3

Puede buscar Insert(index,object) después de encontrar el índice que desea.

Answer 4

Asumiendo que su lista ya está ordenada en orden ascendente

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

Answer 5

Con .NET 4 se puede utilizar la nueva SortedSet<T> de lo contrario se pegan con la recogida de llaves valor SortedList.

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

Nota: La clase SortedSet<T> no acepta elementos duplicados. Si el artículo ya está en el conjunto, este método devuelve falso y no lanza una excepción.

Si se permiten duplicados, puede usar un List<DateTimeOffset> y usar su método Sort.

Answer 6

Una versión ligeramente mejorada del @L.B.'s answer para casos extremos:

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

Answer 7

muy simple, después de agregar datos en li st

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

Answer 8

Tomé @Noseratio's answer y vuelta a trabajar y lo combinó con @ respuesta de Jeppe de here para obtener una función que funciona para colecciones (lo necesitaba para un ObservableCollection de Caminos) y el tipo que no implementa 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); 
     } 
    }