Maîtriser le mot-clé this en C#

Maîtriser le mot-clé this en C#

Explorez le mot-clé polyvalent this en C# à travers des explications concises et des exemples de code réels.

En C#, this fait référence à l'instance courante d'une classe. Il est indispensable pour distinguer entre membres d'instance et paramètres de méthode, invoquer des constructeurs surchargés, passer l'objet courant à d'autres méthodes et déclarer des indexeurs.

using System;
namespace ThisKeyword {
    class Test {
        int num;
        Test(int num) {
            // this.num fait référence au champ d'instance
            this.num = num;
            Console.WriteLine("objet de this : " + this);
        }
        static void Main(string[] args) {
            Test t1 = new Test(4);
            Console.WriteLine("objet de t1 : " + t1);
            Console.ReadLine();
        }
    }
}

Sortie

objet de this : ThisKeyword.Test
objet de t1 : ThisKeyword.Test

t1 et this font référence à la même instance ; ainsi leurs représentations en chaîne correspondent.

---

Désambiguïsation de variables de même nom

Les champs d'instance et les paramètres peuvent partager un nom, mais sans this le compilateur traite la référence comme le paramètre, laissant le champ inchangé.

using System;
namespace ThisKeyword {
    class Test {
        int num;
        Test(int num) {
            num = num; // assigne le paramètre à lui-même, le champ reste par défaut (0)
        }
        static void Main(string[] args) {
            Test t1 = new Test(4);
            Console.WriteLine("valeur de num : " + t1.num);
            Console.ReadLine();
        }
    }
}

Sortie

0

La sortie est zéro car l'assignation n'affecte pas le champ. L'utilisation de this résout l'ambiguïté :

using System;
namespace ThisKeyword {
    class Test {
        int num;
        Test(int num) {
            // this.num fait référence au champ d'instance
            this.num = num;
        }
        static void Main(string[] args) {
            Test t1 = new Test(4);
            Console.WriteLine("valeur de num : " + t1.num);
            Console.ReadLine();
        }
    }
}

Sortie

valeur de num : 4

---

Chaînage de constructeurs avec this

Quand une classe offre plusieurs constructeurs, l'un peut en appeler un autre pour centraliser la logique d'initialisation. Cela est réalisé avec le mot-clé this après deux-points dans la signature du constructeur.

using System;
namespace ThisKeyword {
    class Test {
        Test(int num1, int num2) {
            Console.WriteLine("Constructeur avec deux paramètres");
        }
        // invoque le constructeur à deux paramètres
        Test(int num) : this(33, 22) {
            Console.WriteLine("Constructeur avec un paramètre");
        }
        public static void Main(string[] args) {
            Test t1 = new Test(11);
            Console.ReadLine();
        }
    }
}

Sortie

Constructeur avec deux paramètres
Constructeur avec un paramètre

Le constructeur à un paramètre exécute d'abord le constructeur à deux paramètres, puis continue avec son propre corps. Ce pattern, connu sous le nom de chaînage de constructeurs, garde la logique d'initialisation DRY (Don't Repeat Yourself).

---

Passage de l'instance courante aux méthodes

Parfois une méthode a besoin d'opérer sur l'objet qui l'a invoquée. Utiliser this comme argument rend l'intention explicite.

using System;
namespace ThisKeyword {
    class Test {
        int num1;
        int num2;
        Test() {
            num1 = 22;
            num2 = 33;
        }
        // méthode qui accepte une instance Test
        void PasserParametre(Test t) {
            Console.WriteLine("num1 : " + t.num1);
            Console.WriteLine("num2 : " + t.num2);
        }
        void Afficher() {
            // passer l'instance courante
            PasserParametre(this);
        }
        public static void Main(string[] args) {
            Test t1 = new Test();
            t1.Afficher();
            Console.ReadLine();
        }
    }
}

Sortie

num1 : 22
num2 : 33

Puisque this représente l'instance appelante, la méthode peut accéder en toute sécurité à ses champs privés.

---

Déclaration d'un indexeur avec this

Les indexeurs permettent aux objets d'être indexés comme des tableaux. Le mot-clé this déclare la signature de l'indexeur.

using System;
namespace ThisKeyword {
    class Etudiant {
        private string[] noms = new string[3];
        // Déclaration de l'indexeur
        public string this[int index] {
            get { return noms[index]; }
            set { noms[index] = value; }
        }
    }
    class Program {
        public static void Main() {
            Etudiant s = new Etudiant();
            s[0] = "Ram";
            s[1] = "Shyam";
            s[2] = "Gopal";
            for (int i = 0; i < 3; i++) {
                Console.WriteLine(s[i]);
            }
        }
    }
}

Sortie

Ram
Shyam
Gopal

Le tableau privé noms est accessible via l'indexeur, gardant l'encapsulation intacte tout en offrant une syntaxe de type tableau.

Pour une analyse plus approfondie des indexeurs, consultez la documentation officielle de Microsoft : Indexeur C#.