Cómo ordenar un IEnumerable <string>

Question

Cómo puedo ordenar un IEnumerable<string> alfabéticamente. es posible?

Editar: ¿Cómo escribiría una solución en el lugar?

Answer 1

La misma forma en que ordenar cualquier otra enumerables:

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

o

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

o (ignorando caso)

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

Tenga en cuenta que, como es habitual en LINQ , esto crea un nuevo IEnumerable <T> que, cuando se enumera, devuelve los elementos de el IEnumerable original <T> en orden ordenado. No ordena el IEnumerable <T> en contexto.

---

un IEnumerable <T> es de sólo lectura, es decir, sólo se puede recuperar los elementos de ella, pero no puede modificar directamente. Si desea ordenar una colección de cadenas en el lugar, lo que necesita para ordenar la colección original que implementa IEnumerable <cadena>, o convertir un IEnumerable <cadena> en una colección puede ordenar primero:

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

---

basado en su comentario:

_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 (si desea agregar más adelante más elementos a la lista y mantenerla ordenada)

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

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

Answer 2

Es imposible, pero no lo es.

Básicamente, cualquier método para ordenar va a copiar su IEnumerable en un List, ordenar la List y luego regresar a que la lista ordenada, que es un IEnumerable así como un IList.

Esto significa que pierde la propiedad "continuar infinitamente" de un IEnumerable, pero no puede ordenar uno así de todos modos.

Answer 3

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

Answer 4

No siempre podemos hacerlo en el lugar, pero detectar cuando es posible:

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

Este utiliza la siguiente estructura útil:

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