¿Cómo puedo ordenar IEnumerable<string>
alfabéticamente. es posible?
Editar: ¿Cómo escribiría una solución in situ?
De la misma forma que ordenarías cualquier otro enumerable:
var result = myEnumerable.OrderBy(s => s);
o
var result = from s in myEnumerable
orderby s
select s;
o (ignorando el caso)
var result = myEnumerable.OrderBy(s => s,
StringComparer.CurrentCultureIgnoreCase);
Tenga en cuenta que, como es habitual con LINQ, esto crea un nuevo IEnumerable <T> que, cuando se enumera, devuelve los elementos del IEnumerable <T> original en orden ordenado. No ordena el IEnumerable <T> in situ.
Un IEnumerable <T> es de solo lectura, es decir, solo puede recuperar los elementos de él, pero no puede modificarlo directamente. Si desea ordenar una colección de cadenas en el lugar, primero debe ordenar la colección original que implementa IEnumerable <string>, o convertir una IEnumerable <string> en una colección ordenable:
List<string> myList = myEnumerable.ToList();
myList.Sort();
Basado en tu 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 luego desea agregar más elementos a la lista y mantenerla ordenada)
_components = xml.Descendants("component")
.Select(c => (string)c)
.Distinct()
.ToList();
_components.Add("foo");
_components.Sort();
OrderBy
devuelveIOrderedEnumerable<T>
.IOrderedEnumerable<T>
deriva deIEnumerable<T>
para que pueda usarse comoIEnumerable<T>
, pero extiende el tipo, permitiendo por ejemplo, el uso deThenBy
.Es imposible, pero no lo es.
Básicamente, cualquier método de clasificación lo copiará
IEnumerable
en unList
, clasificará elList
y luego le devolverá la lista ordenada, que es unIEnumerable
archivo y un archivoIList
.Esto significa que pierde la propiedad "continuar infinitamente" de un
IEnumerable
, pero de todos modos no podría ordenar uno así.fuente
fuente
No siempre podemos hacerlo en el lugar, pero detectamos cuando es posible:
Esto usa la siguiente estructura útil:
fuente
listToSort = (src is List<T>) ? (List<T>)src : new List<T>(src);
? ¿Qué hay de tenerlo como?listToSort = (src as List<T>); if (null == listToSort) listToSort = new List<T>(src);