Discussion :

[Gat-]

Bonjour tlm,

Je souhaiterai savoir s'il est possible d'ajouter une méthode de tri à un tableau d'objet.
Je m'explique, imaginons une classe Person et un tableau de Person que je nommerai people :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class Person {
    protected string name;
    protected int age;
 
    public Person() {}
    public Person(string n, int a) { ... }
}
class MyTest {
    public static void test() {
        // Génération de 100 personnes avec la classe Env.
        Person[] people = Env.StaticGeneratePerson(100);
        people.SortByName(); // Tri par nom.
        people.SortByAge();  // Tri par age.
    }
}

Ce que je voudrais, c'est savoir comment et où implémenter les méthodes SortByName() et SortByAge().
J'ai tenté d'ajouter ces méthodes dans la classe Person mais lorsque l'objet people appelle ces méthodes : erreur !

Est-ce que ce que je souhaite faire est possible ? comment ?

Merci d'avance.

[Chubyone]

Le mieux est sans doute de créer une classe PersonCollection qui est une colection de personne. A l'intérieur tu ajoute des méthode de tri.

Regarce vers System.collections, utilises les interface pour te simplifier la tache

[Gat-]

Merci beaucoup Chubyone, j'avance à grand pas.

La seule solution que j'ai trouvé, c'est de créer des classes pour trier par nom et par age :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class PersonSortByName : IComparer {
    public int Compare(object x, object y) {
        Person p1 = (Person)x;
        Person p2 = (Person)y;
        return (p1.name.CompareTo(p2.name));
    }
}
public class PersonSortByAge : IComparer {
    public int Compare(object x, object y) {
        Person p1 = (Person)x;
        Person p2 = (Person)y;
        return (p1.age.CompareTo(p2.age));
    }
}

Ensuite je stocke les Person de l'objet people dans un ArrayList.
Et enfin, je trie grâce à la méthode Sort de l'objet ArrayList :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
class MyTest {
    public static void test() {
        Person[] people = Env.StaticGeneratePerson(100);
        ArrayList myList = new ArrayList();
        foreach (Person p in people) {
            myList.Add(p);
        }
        myList.Sort(new PersonSortByName()); // Tri par nom.
        myList.Sort(new PersonSortByAge());  // Tri par age.
    }
}

Je trouve ce traitement assez lourd, surtout le remplissage de l'objet myList (foreach ...).
Dans cet exemple je crée 100 objets mais dans mon appli je crée un tableau de plusieurs milliers d'objets.
Alors je trouve que ce n'est pas très optimiser de stocker les données dans un tableau.
Puis de reboucler pour stocker les données dans un ArrayList.
Si je pouvais faire en sorte que la méthode qui crée les d'objets renvoie un ArrayList ça aurait été top.
Malheureusement, elle existe depuis Jérusalem et est utilisée partout dans appli
Donc si j'y touche, les collègues me jettent par la fenêtre

Ya-t-il une autre solution ?

[scifire]

Salut.
Je te propose une solution possible que je trouve assez flexible. Elle utilise un tableau et pas une collection - (Array.Sort()) et si tu ajoutes encore une propriete ( bool sex; - une enumeration Homme/Femme sera mieux ) il faut juste ajouter un case dans la methode CompareImplementation.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
 
    class Program
    {
        static void Main(string[] args)
        {
            Person[] people = GenerateRandomPersons(100);
 
            PersonCollection pc = new PersonCollection();
            pc.People = people;
 
            pc.SortExpression = "Name";
            pc.Sort();
            pc.Show();
 
            pc.Sort("Age");
            pc.Show();
        }
 
        private static Person[] GenerateRandomPersons(int total)
        {
            Random r = new Random();
            Person[] persons = new Person[total];
 
            for (int i = 0; i < total; i++)
            {
                persons[i] = new Person(r.Next(100).ToString(), r.Next(100));
            }
 
            return persons;
        }
    }
 
    class Person
    {
        private string name;
 
        public string Name
        {
            get { return name; }
            set { name = value; }
        }
 
        private int age;
 
        public int Age
        {
            get { return age; }
            set { age = value; }
        }
 
        public Person(string name, int age)
        {
            this.name = name;
            this.age = age;
        }
 
        public override string ToString()
        {
            return Name.PadLeft(2) + ":" + Age.ToString().PadLeft(2);
        }
    }
 
    class PersonCollection
    {
        private Person[] people;
 
        public Person[] People
        {
            get { return people; }
            set { people = value; }
        }
 
        /// <summary>
        /// Define default sort expression - "Name"
        /// </summary>
        private string sortExpression = "Name";
 
        public string SortExpression
        {
            get { return sortExpression; }
            set { sortExpression = value; }
        }
 
        /// <summary>
        /// Sort by the default sort expression
        /// </summary>
        public void Sort()
        {
            ValidateSortExpression(this.SortExpression);
            Array.Sort(people, new Comparison<Person>(CompareImplementation));
        }
 
        /// <summary>
        /// Sort by the specified sort expression without changing the collection sort expression.
        /// </summary>
        /// <param name="sortExpression"></param>
        public void Sort(string sortExpression)
        {
            string oldExpression = this.SortExpression;
 
            this.SortExpression = sortExpression;
 
            ValidateSortExpression(sortExpression);
            Array.Sort(people, new Comparison<Person>(CompareImplementation));
 
            this.SortExpression = oldExpression;
        }
 
        private void ValidateSortExpression(string expression)
        {
            if (string.IsNullOrEmpty(expression))
            {
                throw new ArgumentException("This property cannot by null or empty.", "SortExpression");
            }
        }
 
        private int CompareImplementation(Person a, Person b)
        {
            int cmpResult = 0;
 
            switch (this.SortExpression)
            {
                case "Name":
                    cmpResult = a.Name.CompareTo(b.Name);
                    break;
                case "Age":
                    cmpResult = a.Age.CompareTo(b.Age);
                    break;
                default:
                    throw new Exception(string.Format("Unsupported sortexpression - {0}", this.SortExpression));
            }
 
            return cmpResult;
        }
 
        public void Show()
        {
            foreach (Person p in this.People)
            {
                Console.WriteLine(p);
            }
            Console.WriteLine();
        }
    }

A+

[Gat-]

MERCI BEAUCOUP ! C'est top !