क्रम में सूची में आइटम कैसे सम्मिलित करें?

Question

क्या कोई मुझे सिखा सकता है कि सी # में क्रम में सूची में आइटम कैसे सम्मिलित करें?

मेरे पास डेटटाइम ऑफसेट ऑब्जेक्ट्स की एक सूची है, और मैं सूची में नए लोगों को सम्मिलित करना चाहता हूं।

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

क्षमा करें, मेरे प्रश्न को अपडेट करने की आवश्यकता है।

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 

क्या कोई भी कृपया डेटटाइम ऑफसेट को ओडरबी() के पैरामीटर के रूप में डालने में मेरी सहायता कर सकता है?

मैं भी

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

की कोशिश की हालांकि, यह इस त्रुटि संदेश देता है,

परोक्ष 'System.Collections.Gerneric.List' के लिए कनवर्ट नहीं कर सकता प्रकार 'System.Linq.IOrderedEnumerable'। एक स्पष्ट रूपांतरण मौजूद (यदि आप एक डाली याद कर रहे हैं?)

Answer 1

संशोधित अपने LINQ, अंत में ToList() जोड़ें:

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

वैकल्पिक रूप से बढ़त के मामलों के लिए एक और चर

var sortedList = from s in .... 

Answer 2

एक विशिष्ट सूचकांक करने के लिए आइटम सम्मिलित करने के लिए

आप का उपयोग कर सकते हैं:

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

संग्रह आप LINQ का उपयोग कर सकते क्रमबद्ध करने के लिए:

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

Answer 3

आप जो सूचकांक चाहते हैं उसे ढूंढने के बाद आप Insert(index,object) का उपयोग कर सकते हैं।

Answer 4

अपनी सूची मान लिया जाये कि पहले से ही आरोही क्रम

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

Answer 5

में क्रमबद्ध हो जाता .NET 4 के साथ आप नए SortedSet<T> अन्यथा आप की-वैल्यू संग्रह SortedList के साथ फंस रहे हैं का उपयोग कर सकते हैं।

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

नोट: SortedSet<T> कक्षा डुप्लिकेट तत्व स्वीकार नहीं करती है। यदि आइटम पहले से ही सेट में है, तो यह विधि झूठी रिटर्न देती है और अपवाद नहीं फेंकता है।

यदि डुप्लीकेट की अनुमति है तो आप List<DateTimeOffset> का उपयोग कर सकते हैं और इसकी Sort विधि का उपयोग कर सकते हैं।

Answer 6

एक @L.B.'s answer का थोड़ा सुधार हुआ संस्करण के लिए हल कर सूची में निर्दिष्ट करें:

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

बहुत सरल, ली में डेटा जोड़ने के बाद सेंट

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

Answer 8

मैं @Noseratio's answer लिया और फिर से काम और साथ @ यह here से Jeppe का जवाब संयुक्त एक समारोह है कि और प्रकार है कि IComparable को लागू नहीं करता है (मैं पथ का एक ObservableCollection के लिए यह आवश्यक) संग्रह के लिए काम करता है पाने के लिए।

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