So sortieren Sie einen IEnumerable <string>

Wie kann ich eine IEnumerable<string>alphabetisch sortieren . Ist das möglich?

Bearbeiten: Wie würde ich eine In-Place-Lösung schreiben?

Auf die gleiche Weise würden Sie jede andere Aufzählung sortieren:

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

oder

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

oder (Fall ignorieren)

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

Beachten Sie, dass wie bei LINQ üblich eine neue IEnumerable <T> erstellt wird, die bei Aufzählung die Elemente der ursprünglichen IEnumerable <T> in sortierter Reihenfolge zurückgibt. Das IEnumerable <T> wird nicht direkt sortiert.

Ein IEnumerable <T> ist schreibgeschützt, dh Sie können nur die Elemente daraus abrufen, aber nicht direkt ändern. Wenn Sie eine Sammlung von Zeichenfolgen direkt sortieren möchten, müssen Sie die ursprüngliche Sammlung sortieren, die IEnumerable <string> implementiert, oder eine IEnumerable <string> zuerst in eine sortierbare Sammlung umwandeln:

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

Basierend auf Ihrem Kommentar:

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

oder

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

oder (wenn Sie später weitere Elemente zur Liste hinzufügen und sortieren möchten)

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

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

Es ist unmöglich, aber es ist nicht.

Grundsätzlich wird jede Sortiermethode Ihre IEnumerablein eine kopieren List, die sortieren Listund Ihnen dann die sortierte Liste zurückgeben, die sowohl eine IEnumerableals auch eine ist IList.

Dies bedeutet, dass Sie die Eigenschaft "unendlich weitermachen" von verlieren IEnumerable, aber dann können Sie eine solche sowieso nicht sortieren.

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

Wir können es nicht immer vor Ort tun, aber wir erkennen, wann es möglich ist:

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

Dies verwendet die folgende praktische Struktur:

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