Come ordinare un oggetto IEnumerable <string>

Question

Come ordinare un IEnumerable<string> in ordine alfabetico. È possibile?

Modifica: come scrivere una soluzione sul posto?

Answer 1

Lo stesso modo che ci ordinare qualsiasi altro enumerabile:

var result = myEnumerable.OrderBy(s => s); 

o

var result = from s in myEnumerable 
      orderby s 
      select s; 

o (caso ignorando)

var result = myEnumerable.OrderBy(s => s, 
            StringComparer.CurrentCultureIgnoreCase); 

Nota che, come al solito con LINQ , questo crea un nuovo IEnumerable <T> che, quando enumerato, restituisce gli elementi di l'originale IEnumerable <T> in ordine ordinato. Non ordina l'IEnumerable <T> sul posto.

---

un IEnumerable <T> è di sola lettura, cioè, è possibile recuperare solo gli elementi da esso, ma non può modificare direttamente. Se si desidera ordinare una collezione di stringhe in-luogo, è necessario risolvere la collezione originale che implementa IEnumerable <stringa>, o girare un < stringa IEnumerable > in una collezione ordinabile prima:

List<string> myList = myEnumerable.ToList(); 
myList.Sort(); 

---

sulla base della sua commento:

_components = (from c in xml.Descendants("component") 
       let value = (string)c 
       orderby value 
       select value 
      ) 
       .Distinct() 
       .ToList(); 

o

_components = xml.Descendants("component") 
       .Select(c => (string)c) 
       .Distinct() 
       .OrderBy(v => v) 
       .ToList(); 

o (se si desidera aggiungere in seguito altri elementi alla lista e tenerlo allineati)

_components = xml.Descendants("component") 
       .Select(c => (string)c) 
       .Distinct() 
       .ToList(); 

_components.Add("foo"); 
_components.Sort(); 

Answer 2

E 'impossibile, ma non lo è.

In sostanza, qualsiasi metodo di ordinamento sta per copiare il IEnumerable in un List, ordinare la List e poi tornare a voi la lista ordinata, che è un IEnumerable così come un IList.

Ciò significa che si perde la proprietà "continua all'infinito" di uno IEnumerable, ma in questo caso non è possibile selezionarne uno simile.

Answer 3

myEnumerable = myEnumerable.OrderBy(s => s); 

Answer 4

Non possiamo sempre farlo sul posto, ma noi di rilevare quando è possibile:

IEnumerable<T> SortInPlaceIfCan(IEnumerable<T> src, IComparer<T> cmp) 
{ 
    List<T> listToSort = (src is List<T>) ? (List<T>)src : new List<T>(src); 
    listToSort.Sort(cmp); 
    return listToSort; 
} 
IEnumerable<T> SortInPlaceIfCan(IEnumerable<T> src, Comparison<T> cmp) 
{ 
    return SortInPlaceIfCan(src, new FuncComparer<T>(cmp)); 
} 
IEnumerable<T> SortInPlaceIfCan(IEnumerable<T> src) 
{ 
    return SortInPlaceIfCan(src, Comparer<T>.Default); 
} 

Questo utilizza la seguente struct a portata di mano:

internal struct FuncComparer<T> : IComparer<T> 
{ 
    private readonly Comparison<T> _cmp; 
    public FuncComparer(Comparison<T> cmp) 
    { 
     _cmp = cmp; 
    } 
    public int Compare(T x, T y) 
    { 
     return _cmp(x, y); 
    } 
}