Dominando la palabra clave this en C#

Dominando la palabra clave this en C#

Explora la versátil palabra clave this en C# a través de explicaciones concisas y ejemplos de código reales.

En C#, this se refiere a la instancia actual de una clase. Es indispensable para distinguir entre miembros de instancia y parámetros de método, invocar constructores sobrecargados, pasar el objeto actual a otros métodos y declarar indizadores.

using System;
namespace ThisKeyword {
    class Test {
        int num;
        Test(int num) {
            // this.num se refiere al campo de instancia
            this.num = num;
            Console.WriteLine("object of this: " + this);
        }
        static void Main(string[] args) {
            Test t1 = new Test(4);
            Console.WriteLine("object of t1: " + t1);
            Console.ReadLine();
        }
    }
}

Salida

object of this: ThisKeyword.Test
object of t1: ThisKeyword.Test

Tanto t1 como this se refieren a la misma instancia; por tanto, sus representaciones en cadena coinciden.

---

Desambiguando variables con mismo nombre

Los campos de instancia y parámetros pueden compartir un nombre, pero sin this el compilador trata la referencia como el parámetro, dejando el campo intacto.

using System;
namespace ThisKeyword {
    class Test {
        int num;
        Test(int num) {
            num = num; // asigna parámetro a sí mismo, el campo queda en default (0)
        }
        static void Main(string[] args) {
            Test t1 = new Test(4);
            Console.WriteLine("value of num: " + t1.num);
            Console.ReadLine();
        }
    }
}

Salida

0

La salida es cero porque la asignación no afecta al campo. Usar this resuelve la ambigüedad:

using System;
namespace ThisKeyword {
    class Test {
        int num;
        Test(int num) {
            // this.num se refiere al campo de instancia
            this.num = num;
        }
        static void Main(string[] args) {
            Test t1 = new Test(4);
            Console.WriteLine("value of num: " + t1.num);
            Console.ReadLine();
        }
    }
}

Salida

value of num: 4

---

Encadenamiento de constructores con this

Cuando una clase ofrece múltiples constructores, uno puede llamar a otro para centralizar la lógica de inicialización. Esto se logra con la palabra clave this después de dos puntos en la firma del constructor.

using System;
namespace ThisKeyword {
    class Test {
        Test(int num1, int num2) {
            Console.WriteLine("Constructor with two parameters");
        }
        // invoca el constructor de dos parámetros
        Test(int num) : this(33, 22) {
            Console.WriteLine("Constructor with one parameter");
        }
        public static void Main(string[] args) {
            Test t1 = new Test(11);
            Console.ReadLine();
        }
    }
}

Salida

Constructor with two parameters
Constructor with one parameter

El constructor de un parámetro primero ejecuta el de dos parámetros, luego continúa con su propio cuerpo. Este patrón, conocido como encadenamiento de constructores, mantiene la lógica de inicialización DRY.

---

Pasando la instancia actual a métodos

A veces un método necesita operar sobre el objeto que lo invocó. Usar this como argumento hace la intención explícita.

using System;
namespace ThisKeyword {
    class Test {
        int num1;
        int num2;
        Test() {
            num1 = 22;
            num2 = 33;
        }
        // método que acepta una instancia Test
        void PassParameter(Test t) {
            Console.WriteLine("num1: " + t.num1);
            Console.WriteLine("num2: " + t.num2);
        }
        void Display() {
            // pasa la instancia actual
            PassParameter(this);
        }
        public static void Main(string[] args) {
            Test t1 = new Test();
            t1.Display();
            Console.ReadLine();
        }
    }
}

Salida

num1: 22
num2: 33

Como this representa la instancia que llama, el método puede acceder de forma segura a sus campos privados.

---

Declarando un indizador con this

Los indizadores permiten que los objetos se indexen como arrays. La palabra clave this declara la firma del indizador.

using System;
namespace ThisKeyword {
    class Student {
        private string[] names = new string[3];
        // Declaración del indizador
        public string this[int index] {
            get { return names[index]; }
            set { names[index] = value; }
        }
    }
    class Program {
        public static void Main() {
            Student s = new Student();
            s[0] = "Ram";
            s[1] = "Shyam";
            s[2] = "Gopal";
            for (int i = 0; i < 3; i++) {
                Console.WriteLine(s[i]);
            }
        }
    }
}

Salida

Ram
Shyam
Gopal

El array privado names se accede vía el indizador, manteniendo la encapsulación mientras ofrece sintaxis similar a array.

Para una inmersión más profunda en indizadores, consulta la documentación oficial de Microsoft: Indizador en C#.