[C#] Comment effectuer un tri selon une partie de chaine ?

Version imprimable

23/02/2006, 12h43
david71

[C#] Comment effectuer un tri selon une partie de chaine ?

Salut,

Voilà j'ai un problème de tri en C# que je ne sais pas comment résoudre.

Je souhaite faire un tri par ordre croissant de chaîne contenue dans une autre chaîne.

La liste est par exemple la suivante :

120123456
120030454
121004564

Je souhaite faire un tri sur les éléments en gras donc avoir en retour la liste suivante :

121004564
120030454
120123456

Vous avez des suggestions ?
Merci d'avance pour toute information complémentaire.
23/02/2006, 13h22
Sphax

Salut,

Oui tu peux implémenter ton propre objet de comparaison (il doit implémenter l'interface IComparer je crois). tu pourras l'utiliser pour trier un ArrayList de tes chaines sur la condition que tu veux.
23/02/2006, 15h32
Maniak

Cherche ArrayList.Sort dans MSDN

Y a même un exemple avec tout ce qu'il faut, sauf les Substring.

Exemple testé sur Console :

1. une classe specifique pour ton type de chaine

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
 
public class MaChaine
{
    private string racine;
    private string suite;
 
    public MaChaine(string root, string value)
    {
        this.racine = root;
        this.suite = value;
    }
    public string Root 
    {
        get { return this.racine;}
        set { this.racine = value;}
    }
    public string Value
    {
        get { return this.suite;}
        set { this.suite = value;}
    }
    public override string ToString()
    { return (this.racine + this.suite);}
}

2. La collection correspondante et le IComparer

Code:

1
2
3
4
5
6
7
8
9
10
11
 
public class MesChaines : List<MaChaine>
{
    public void Sort()
    { base.Sort(new MaChaineComparer());}
}
public class MaChaineComparer : IComparer<MaChaine>
{
    public int Compare(MaChaine maChaine1, MaChaine maChaine2)
    { return (maChaine1.Value.CompareTo(maChaine2.Value));}
}

3. Le test Console

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public class Main
{
    static void Main()
    { TestSubSort();}
 
    private static void TestSubSort()
    {
        MesChaines liste = new MesChaines();
        liste.Add(new MaChaine("120", "123456"));
        liste.Add(new MaChaine("120", "030454"));
        liste.Add(new MaChaine("121", "004564"));
        foreach (MaChaine s in liste)
        { Console.WriteLine(s.ToString());}
        Console.WriteLine("*********");
        liste.Sort();
        foreach (MaChaine s in liste)
        { Console.WriteLine(s.ToString());}
        Console.ReadLine();
    }
}

Citation:

Envoyé par Resultat

120123456
120030454
121004564
*********
121004564
120030454
120123456

Pour la 1.1, tu dois suivre la même idée mais sans les fonctionnalités des generics, que tu devras contourner ou implementer toi même

Si je puis me permettre d'être lourd, il y a un *poil* plus simple/court :)

En 1.1 :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
	public class Application
	{
		private static void Main()
		{
			TestSubSort2();
		}
 
		private static void TestSubSort2()
		{
			string[] strings = { "120123456", "120030454", "121004564" };
			WriteStrings( strings );
			Console.WriteLine( "*********" );
 
			Array.Sort( strings, new SubstringComparer() );
 
			WriteStrings( strings );
		}
 
		private static void WriteStrings( string[] strings )
		{
			foreach ( string item in strings )
			{
				Console.WriteLine( item );
			}
		}
 
		private class SubstringComparer : IComparer
		{
			public int Compare( object x, object y )
			{
				string left = x as string;
				string right = y as string;
 
				return left.Substring( 3 ).CompareTo( right.Substring( 3 ) );
			}
		}

(version bourrin sans vérifier que la longueur des chaînes doit être > 3)

En 2.0, on vire SubstringComparer, et on remplace Array.Sort(...) par :

Code:

1
2
3
4
5
			Array.Sort(
				strings, delegate( string x, string y )
				         	{
				         		return x.Substring( 3 ).CompareTo( y.Substring( 3 ) );
				         	} );

Maintenant si les chaînes en question ont vraiment besoin d'être traitées comme deux chaînes composées, matérialiser ça par une classe spécialisée est recommandé. Mais si c'est juste pour le tri, pas besoin de trop se compliquer la vie non plus :)

OK, merci ton exemple marche, mais pas avec les chaînes suivantes à trier :

Code:

1
2
 
string[] strings = { "12000751234560273123456780010316", "1200075123456027312345678001W316","12000132809720341000050520010136", "12000132809720341000050520020135","12001750204750482047500830030925" };

Avec :

Code:

1
2
3
4
5
6
7
8
9
10
11
 
private class SubstringComparer : IComparer 
		{ 
			public int Compare( object x, object y ) 
			{ 
				string left = x as string;
				string right = y as string;				
 
				return left.Substring(7,18).CompareTo(right.Substring(7,18)); 
			} 
		}

L'ordre n'est pas bon. Quelqu'un voit pourquoi ?
Merci d'avance.

Oups, je me suis trompé dans les positions de la sous chaine 8O .
Bon en fait ça marche ainsi :

Code:

1
2
3
4
5
6
7
8
9
10
11
 
private class SubstringComparer : IComparer 
      { 
         public int Compare( object x, object y ) 
         { 
            string left = x as string; 
            string right = y as string;             
 
            return left.Substring(17,8).CompareTo(right.Substring(17,8)); 
         } 
      }