Cómo ordenar una <cadena> IEnumerable

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

Es imposible, pero no lo es.

Básicamente, cualquier método de clasificación lo copiará IEnumerableen un List, clasificará el Listy luego le devolverá la lista ordenada, que es un IEnumerablearchivo y un archivo IList.

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

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

No siempre podemos hacerlo en el lugar, pero detectamos 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);
}

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