Comment trier une Liste<List<string>> selon List<string> nombre de champs?

Comment puis-je trier List<List<string>> selon le nombre de champs?

La liste a obtenu structure comme

a|b|c|d|eeee|rere|ewew|
ewqewq|ewew|
ewew|ewewewewew|

En Sorte que j'aimerais le faire selon les chiffres de blockes (asc/desc)

MODIFIER

la <list<list<string>> is "items" et je accéder à chaque liste par items[0] chacun de

ces éléments[xx] est une liste qui signifie que je les veux pour trier le tableau de

    a|b|c|d|eeee|rere|ewew|
    a|b|c|d|eeee|rere
    a|b|c|d|eeee

InformationsquelleAutor Skuta | 2009-04-06

c#list sorting

9

Si vous n'avez pas besoin de les trier "en place", vous pouvez utiliser LINQ pour vous donner un nouveau triées, liste.
```
var sorted = oldList.OrderBy( l => l.Count );
```
Sinon, vous aurez besoin d'écrire votre propre Logiciel qui prend deux listes et renvoie la commande de par leur taille.
```
public class CountComparer : IComparer<List<string>>
{
    #region IComparer<List<string>> Members

    public int Compare( List<string> x, List<string> y )
    {
        return x.Count.CompareTo( y.Count );
    }

    #endregion
}



oldList.Sort( new CountComparer() );
```
Ou, comme @Josh points, vous pouvez le faire avec une expression lambda.
```
oldList.Sort( (a,b) => a.Count.CompareTo( b.Count ) )
```
De l'OMI, ce dernier fonctionne bien si la comparaison est relativement simple ou utilisé une fois, mais à la classe réelle est peut-être préférable que la comparaison devient de plus en plus complexe ou si vous avez besoin de le répéter à plusieurs endroits.
- oldList.De tri( (a,b) => un.Le comte.CompareTo( b.Count ) ) -ici, ce que je suis censé écrire au lieu de a et de b?
- Rien, a et b sont les détenteurs de place pour l'expression lambda et on assigne des valeurs à partir de la liste externe lorsque la comparaison est invoquée.
InformationsquelleAutor tvanfosson

List<List<string>> list; //filled elsewhere
list.Sort((x,y) => x.Count.CompareTo(y.Count););

InformationsquelleAutor Chris Doggett

1
```
List<List<string>> strings = new List<List<string>>();

//add your strings

strings = new List<List<string>>(from str in strings orderby str.Count select str);
```
Évidemment, vous pouvez adapter ce pour s'adapter à votre scénario, mais ce devrait vous donner une idée générale de la façon de créer une liste triée par le nombre d'éléments à l'intérieur d'une chaîne de caractères dans une autre liste.

InformationsquelleAutor Adam Robinson
1

Vous pouvez trier en utilisant la méthode de tri, par la création de votre propre Compararer ou en lui donnant un délégué de type Comparison<T>.
```
ls.Sort((x, y) => x.Count.CompareTo(y.Count));
```
Voici un exemple montrant comment les comparer à l'aide d'une expression lambda.

Modifier

Une façon très simple d'inverser le tri est à multiplier par la négative -1
```
ls.Sort((x, y) => -1 * x.Count.CompareTo(y.Count));
```
- c'est le tri de ma liste dans de l'ASC de l'ordre, comment puis-je revenir?
- Un autre (très simple) de manière à inverser la inverser x et y sur un côté de la lambda flèche, comme dans (x, y) => y.Count.CompareTo(x.Count).
InformationsquelleAutor JoshBerke

Juste un ajustement mineur, de la vérification de la valeur null tout aussi

        List<List<string>> listOfLists = new List<List<string>>();

        List<string> list1 = new List<string>();
        list1.Add("elem 1 1");
        list1.Add("elem 1 2");
        list1.Add("elem 1 3");

        List<string> list2 = new List<string>();
        list2.Add("elem 2 1");
        list2.Add("elem 2 2");
        list2.Add("elem 2 3");
        list2.Add("elem 2 4");

        listOfLists.Add(list1);
        listOfLists.Add(null); //list can contain nulls
        listOfLists.Add(list2);
        listOfLists.Add(null); //list can contain nulls

Lorsque vous avez null listes dans la liste de listes, vous voudrez peut-être faire leur priorité inférieure à vide listes, par l'interprétation de la valeur null.Count -1, ou PAS

        int nullListElems = -1; 
        //int nullListElems = 0; 

        listOfLists.Sort((l1,l2)=> 
            l1 == null ? 
            nullListElems : 
            l1.Count.CompareTo(
                l2 == null ? 
                nullListElems : 
                l2.Count));

InformationsquelleAutor Sergiu Mindras

Vous devez vous connecter pour publier un commentaire.

Modifier