De multe ori in practica stocam diverse date in array-uri. Pe aceste date, pastrate in array-uri avem nevoie sa executam diverse operatii. Printre operatiile cel mai des folosite – cel putin de mine – sunt operatii de sortate. Fie ca avem liste de persoane, liste de produse, liste de stringuri, la un moment dat va trebui sa le asezam (afisam) intr-o anumita ordine.

In urma cu ceva timp am scris despre asta – .Net IComparer – se defineste un CustomComparer care implementeaza interfata IComparer, bla, bla… Nu vreau sa reiau ceea ce am scris in articolul precedent aici. Acum vreau sa dau o alta metoda de a face respectiva sortare, care foloseste tot un iComparer, insa scrierea e mai scurta.

Presupunand ca avem un array de obiecte de tip Person[] oameni = new Person[]{ …. }; putem sa il sortam scriind un comparer inline la modul urmator:

     Array.Sort(oameni, delegate(Person p1, Person p2)
     {
          return p1.Age.CompareTo(p2.Age);
     });

care va sorta lista (array-ul) respectiv dupa varsta persoanelor. E mai simplu, mi se pare mie, ca si scriere decat in articolul anterior?

Codul complet este urmatorul:

---

Clasa Person este definita astfel:

    public class Person
    {
        private string firstName;
        private string lastName;
        private uint age;

        public Person(string fName, string lName, uint age)
        {
            firstName = fName;
            LastName = lName;
            this.age = age;
        }

        public string FirstName
        {
            get { return firstName; }
            set { firstName = value; }
        }

        public string LastName
        {
            get { return lastName; }
            set { lastName = value; }
        }

        public uint Age
        {
            get { return age; }
            set { age = value; }
        }

        public override string ToString()
        {
            return string.Format("{0} {1} - {2}", FirstName, LastName, Age);
        }
    }

Iar in metoda Main creem un array de persoane, pe care il afisam nesortat, il sortam si il afisam inca odata pentru a vedea efetul sortari:

    class Program
    {
        static void Main(string[] args)
        {
            Person[] oameni = new Person[]{
                new Person("Ion", "Popescu", 22),
                new Person("Geo", "Ionescu", 15),
                new Person("Pop", "Vasilescu", 32),
                new Person("Ady", "Georgescu", 28),
                new Person("Ron", "Niculescu", 18),
                new Person("Pan", "Petrescu", 22)
            };

            Array.ForEach<Person>(oameni, p => Console.WriteLine(p));
            //for (int i = 0; i < oameni.Length; i++)
            //    Console.WriteLine(oameni[i]);

            Console.WriteLine("\n\nDupa sortare:\n");
            Array.Sort(oameni, delegate(Person p1, Person p2)
            {
                return p1.Age.CompareTo(p2.Age);
            });

            Array.ForEach<Person>(oameni, p => Console.WriteLine(p));
            //for (int i = 0; i < oameni.Length; i++)
            //    Console.WriteLine(oameni[i]);

            Console.ReadKey();
        }
    }

Acest cod afiseaza:

Ion Popescu - 22
Geo Ionescu - 15
Pop Vasilescu - 32
Ady Georgescu - 28
Ron Niculescu - 18
Pan Petrescu - 22

Dupa sortare:
Geo Ionescu - 15
Ron Niculescu - 18
Pan Petrescu - 22
Ion Popescu - 22
Ady Georgescu - 28
Pop Vasilescu - 32

As vrea sa subliniez modul mai simplu, ca scriere, de afisare a elementelor array-ului:
In loc de:

     for (int i = 0; i < oameni.Length; i++)
         Console.WriteLine(oameni[i]);

am scris mai simplu (sau mai putin):

      Array.ForEach<Person>(oameni, p => Console.WriteLine(p));

Array.ForEach<(Of <(T>)>) primeste doi parametri:

public static void ForEach<T>(
    T[] array,
    Action<T> action
)

: arrayul pe care lucram si un delegate Action<(Of <(T>)>) Delegate unde specificam actiunea pe care o executam asupra fiecarui element din Array.