Cách sắp xếp <string> IEnumerable

Làm thế nào tôi có thể sắp xếp một IEnumerable<string>thứ tự bảng chữ cái. Điều này có khả thi không?

Chỉnh sửa: Làm thế nào tôi sẽ viết một giải pháp tại chỗ?

Giống như cách bạn sắp xếp bất kỳ kiểu liệt kê nào khác:

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

hoặc là

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

hoặc (bỏ qua chữ hoa chữ thường)

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

Lưu ý rằng, như thường lệ với LINQ, điều này tạo ra một IEnumerable <T> mới, khi được liệt kê, trả về các phần tử của IEnumerable <T> ban đầu theo thứ tự được sắp xếp. Nó không sắp xếp IEnumerable <T> tại chỗ.

IEnumerable <T> ở chế độ chỉ đọc, nghĩa là bạn chỉ có thể truy xuất các phần tử từ nó chứ không thể sửa đổi trực tiếp. Nếu bạn muốn sắp xếp một tập hợp các chuỗi tại chỗ, bạn cần phải sắp xếp tập hợp ban đầu thực hiện IEnumerable <string> hoặc biến IEnumerable <string> thành một tập hợp có thể sắp xếp trước:

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

Dựa trên nhận xét của bạn:

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

hoặc là

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

hoặc (nếu bạn muốn sau này thêm nhiều mục hơn vào danh sách và giữ nó được sắp xếp)

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

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

Nó là không thể, nhưng nó không phải là.

Về cơ bản, bất kỳ phương pháp sắp xếp nào cũng sẽ sao chép của bạn IEnumerablevào một List, sắp xếp Listvà sau đó trả lại cho bạn danh sách đã sắp xếp, là một IEnumerablecũng như một IList.

Điều này có nghĩa là bạn mất thuộc tính "tiếp tục vô hạn" của một thuộc tính IEnumerable, nhưng dù sao thì bạn cũng không thể sắp xếp một thuộc tính như vậy.

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

Không phải lúc nào chúng tôi cũng có thể làm điều đó tại chỗ, nhưng chúng tôi phát hiện ra khi có thể:

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

Điều này sử dụng cấu trúc hữu ích sau:

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