C# This Keyword
The this keyword refers to the current instance of a class — the object that is currently being worked on. It gives you a way to refer to the object's own fields, methods, and constructors from inside the class itself.
Why Does this Exist?
Imagine you are writing a method inside a class and your method parameter has the same name as a field. The compiler gets confused about which one you mean. this clears the confusion by explicitly pointing to the field on the current object.
┌──────────────────────────────────────────────────────────────┐
│ NAMING CONFLICT PROBLEM │
├──────────────────────────────────────────────────────────────┤
│ │
│ class Person │
│ { │
│ string name; ← field │
│ │
│ void SetName(string name) ← parameter (same name!) │
│ { │
│ name = name; ← sets param to itself — BUG! │
│ } │
│ } │
│ │
│ FIX: │
│ void SetName(string name) │
│ { │
│ this.name = name; ← this.name = field, name = param│
│ } │
│ │
└──────────────────────────────────────────────────────────────┘
Using this to Refer to Fields
class Car
{
string model;
int year;
public Car(string model, int year)
{
this.model = model; // this.model = field; model = parameter
this.year = year;
}
public void Display()
{
Console.WriteLine(this.model + " (" + this.year + ")");
// 'this.' is optional here since no naming conflict exists
}
}
class Program
{
static void Main()
{
Car c = new Car("Tesla", 2024);
c.Display(); // Tesla (2024)
}
}
Using this to Call Other Methods
Inside a class, you can call other instance methods using this to be explicit. The compiler assumes this even when you do not write it, but some developers include it for clarity.
class Invoice
{
double price;
double taxRate;
public Invoice(double price, double taxRate)
{
this.price = price;
this.taxRate = taxRate;
}
double CalculateTax()
{
return this.price * this.taxRate;
}
public double GetTotal()
{
return this.price + this.CalculateTax(); // calls another method on self
}
}
this as a Parameter
You can pass the current object to another method using this. This is useful when you need to hand the current object as an argument.
class Employee
{
public string Name;
public double Salary;
public Employee(string name, double salary)
{
Name = name;
Salary = salary;
}
public void RegisterWithHR()
{
HRSystem.Register(this); // pass current Employee object to HR
}
}
class HRSystem
{
public static void Register(Employee emp)
{
Console.WriteLine("Registered: " + emp.Name + " at $" + emp.Salary);
}
}
Passing this Diagram
┌──────────────────────────────────────────────────────────────┐
│ │
│ Employee emp = new Employee("Alice", 60000); │
│ │ │
│ ▼ │
│ emp.RegisterWithHR() │
│ │ │
│ ▼ │
│ HRSystem.Register(this) ← 'this' = the emp object │
│ │ │
│ ▼ │
│ HRSystem receives emp and prints its data │
│ │
└──────────────────────────────────────────────────────────────┘
Constructor Chaining with this()
You can call one constructor from another constructor in the same class using this(). This avoids repeating setup code across multiple constructors.
class Rectangle
{
int width;
int height;
string color;
// Main constructor:
public Rectangle(int width, int height, string color)
{
this.width = width;
this.height = height;
this.color = color;
Console.WriteLine($"Rectangle: {width}x{height}, Color: {color}");
}
// Shorter constructor chains to the main one:
public Rectangle(int width, int height)
: this(width, height, "White") // calls main constructor
{
}
// Even shorter — square with default color:
public Rectangle(int size)
: this(size, size) // calls the 2-param constructor
{
}
}
class Program
{
static void Main()
{
new Rectangle(5, 3, "Blue"); // Rectangle: 5x3, Color: Blue
new Rectangle(4, 6); // Rectangle: 4x6, Color: White
new Rectangle(8); // Rectangle: 8x8, Color: White
}
}
Constructor Chain Diagram
┌────────────────────────────────────────────────────────────┐ │ new Rectangle(8) │ │ │ │ │ ▼ calls this(8, 8) │ │ Rectangle(int size) │ │ │ │ │ ▼ calls this(8, 8, "White") │ │ Rectangle(int width, int height) │ │ │ │ │ ▼ executes body │ │ Rectangle(int width, int height, string color) ← runs │ └────────────────────────────────────────────────────────────┘
this in Indexers
The this keyword is required when defining an indexer — it tells C# you are defining index-based access for the class.
class NumberBox
{
int[] data = { 10, 20, 30, 40, 50 };
public int this[int index] // indexer uses 'this'
{
get { return data[index]; }
set { data[index] = value; }
}
}
class Program
{
static void Main()
{
NumberBox box = new NumberBox();
Console.WriteLine(box[2]); // 30 — accessed like an array
box[2] = 99;
Console.WriteLine(box[2]); // 99
}
}
When this Is Not Available
Static members have no instance, so this cannot be used inside static methods or static constructors. Using this inside a static context causes a compiler error.
class Sample
{
int value = 5;
public void InstanceMethod()
{
Console.WriteLine(this.value); // ✅ OK — has an instance
}
public static void StaticMethod()
{
// Console.WriteLine(this.value); // ❌ ERROR — no instance in static
}
}
Quick Summary
┌──────────────────────────────────────────────────────────────┐ │ this.field → refers to instance field (vs parameter) │ │ this.Method() → calls another method on same object │ │ this → pass current object to another method │ │ this(args) → call another constructor in same class │ │ this[index] → define indexer access for a class │ │ │ │ Not available in static methods │ └──────────────────────────────────────────────────────────────┘
The this keyword is small but important. It solves naming conflicts in constructors, enables constructor chaining to reduce repeated setup code, and lets you pass the current object around cleanly. Understanding this is essential for writing well-structured, readable class code.