Comment sortinger un IEnumerable

De la même façon que vous sortingez les autres énumérables:

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

ou

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

ou (en ignorant le cas)

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

Notez que, comme d’habitude avec LINQ, cela crée un nouveau IEnumerable qui, lorsqu’il est énuméré, renvoie les éléments de l’original IEnumerable dans l’ordre sortingé. Il ne sortinge pas le IEnumerable en place.

Un IEnumerable est en lecture seule, c’est-à-dire que vous ne pouvez en extraire que les éléments, mais que vous ne pouvez pas le modifier directement. Si vous souhaitez sortinger une collection de chaînes sur place, vous devez sortinger la collection d’origine qui implémente IEnumerable ou transformer d’abord une chaîne IEnumerable en une collection sortingable:

 List myList = myEnumerable.ToList(); myList.Sort(); 

Basé sur votre commentaire:

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

ou

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

ou (si vous souhaitez append ultérieurement d’autres éléments à la liste et la conserver)

 _components = xml.Descendants("component") .Select(c => (ssortingng)c) .Distinct() .ToList(); _components.Add("foo"); _components.Sort(); 

C’est impossible, mais ce n’est pas le cas.

Fondamentalement, toute méthode de sorting va copier votre IEnumerable dans une List , sortinger la List , puis vous renvoyer la liste sortingée, qui est un IEnumerable et un IList .

Cela signifie que vous perdez la propriété “continue infiniment” d’un IEnumerable , mais vous ne pouvez pas en sortinger un comme ça de toute façon.

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

Nous ne pouvons pas toujours le faire sur place, mais nous détectons quand c’est possible:

 IEnumerable SortInPlaceIfCan(IEnumerable src, IComparer cmp) { List listToSort = (src is List) ? (List)src : new List(src); listToSort.Sort(cmp); return listToSort; } IEnumerable SortInPlaceIfCan(IEnumerable src, Comparison cmp) { return SortInPlaceIfCan(src, new FuncComparer(cmp)); } IEnumerable SortInPlaceIfCan(IEnumerable src) { return SortInPlaceIfCan(src, Comparer.Default); } 

Cela utilise la structure pratique suivante:

 internal struct FuncComparer : IComparer { private readonly Comparison _cmp; public FuncComparer(Comparison cmp) { _cmp = cmp; } public int Compare(T x, T y) { return _cmp(x, y); } }