Advertisement

---

Top

< Prev

Next >

C# language provides us a keyword named this, which can be used to -
• Access the currently executing object of a class.
• Access the instance variables of the currently executing object.
• Calling the methods associated with the currently executing object.
• To resolve the shadowing issue, when a local variable has the same name as an instance variable.

Using this keyword to access the currently executing object.


We can access the currently executing object of a class by using this keyword, which in this case can also be called this reference.



//C# Example of this keyword 


using System;

class A
{
//Defining the method Message()
public void Message()
{
	Console.WriteLine("Hello from A");

	//Printing this keyword prints the name of the class of the currently executing object.
	Console.WriteLine(this);
}

public static void Main(String[] ar)
{
	//Creating an object of class A
	A ob = new A();

	//Calling the method Message() by using the object of class A
	ob.Message();
}
}





Output




Hello from A
A


We have created an object of class A and have called its method Message() on this object. Because this refers to the currently executing object, hence by printing this, we have got the name of the class this currently executing object belongs to.






Accessing the instance variables through this keyword.


If we can access an object by using this keyword, then we can also easily access the instance variables associated with an object by using this keyword. Let us see how.



//C# Example of this keyword 


using System;

class A
{
//Instance variables
int a = 10;
char c = 'A';
float f = 12.3f;

//Defining the method Message()
public void Message()
{
	Console.WriteLine("The value of the instance variables of the currently executing object: ");

	//Using this keyword to access the instance variables of the currently executing object.
	Console.WriteLine(this.a);
	Console.WriteLine(this.c);
	Console.WriteLine(this.f);
}

public static void Main(String[] ar)
{
	//Creating an object of class A
	A ob = new A();

	//Calling the method Message() by using the object of class A
	ob.Message();
}
}





Output -




The value of the instance variables of the currently executing object:
10
A
12.3


Because this refers to the currently executing object, therefore, by using this keyword, we have accessed the values of instance variables of the currently executing object.




Advertisement






Calling a method using this keyword.


As we can access an object of a class by using this keyword, therefore, by using an object, we can even access the methods associated with it. Let us see an example.



//C# Example of this keyword 


using System;

class A
{

//Defining the Message() message
public void Message()
{
	//Using this keyword to call the Hello() method
	//associated with the currently executing object.
	this.Hello();
}

//Defining the Hello() method
public void Hello()
{
	Console.WriteLine("Bonjour");
	Console.WriteLine("Hello");
	Console.WriteLine("Namaste");
}


public static void Main(String[] ar)
{
	//Creating an object of class A
	A ob = new A();

	//Calling the method Message() by using the object of class A
	ob.Message();
}
}





Output is




Bonjour
Hello
Namaste


In the preceding code, we have called the Hello() method of an object of class A, by using this keyword.






The shadowing issue without using this keyword.


The issue of shadowing is caused when a local variable overshadows an instance variable because it has the same name. Let us first see the problem of shadowing with an example.



//C# Example of shadowing issue


using System;

class A
{
//Instance variable
int a = 20;		    

//Defining the method SetA()
//Which should update the value of the instance variable, a.
//But its local variable has the same name, a,
//As instance variable of the class A, so it won't happen
public void UpdateA(int a) 
{
	a = a;
}

//Defining the Main() method
public static void Main(String[] ar)
{
	//Creating an object of class A
	A ob = new A();
	
	//Accessing the value of instance variable, a, before calling the UpdateA() method
	Console.WriteLine("Before calling UpdateA(), the value in instance variable, a: "+ ob.a);

	//Calling the UpdateA() method and passing it 100
	//to set the value of the instance variable, a
	ob.UpdateA(100);   

	//Accessing the value of instance variable, a, after calling the UpdateA() method
	Console.WriteLine("After calling UpdateA(), the value in instance variable, a: "+ ob.a);
}
}





Output is




Before calling UpdateA(), the value in instance variable, a: 20
After calling UpdateA(), the value in instance variable, a: 20





Program Analysis



• The UpdateA() method of our class is used to update the value of its instance variable, a.
• This method takes an int value in its local variable named, a, similar to the name of instance variable, a.
• Method call: UpdateA(10), passes the value 10 to the local variable, a, of the method.
• As the local variable of UpdateA() method and instance variable have the same name, a, therefore, a=a puts 10 in the local variable, a, and the instance variable, a, is not accessed at all.

Note : This issue is known as shadowing because a local variable, which has a same name as an instance variable, overshadows the instance variable.







Using this keyword to resolve the shadowing issue.

In the next example, we will use this keyword to resolve the issue of shadowing.

//C# Example of this keyword used to resolvd the shadowing issue

using System;

class A
{
//Instance variable
int a = 20;		    

//Defining the method SetA()
//Which should update the value of the instance variable, a.
//But its local variable has the same name, a,
//As instance variable of the class A, so it won't happen
public void UpdateA(int a) 
{
	//Accessing an instance variable with this keyword, 
	//to differ it from a local variable with the same name
	this.a = a; 
}

//Defining the Main() method
public static void Main(String[] ar)
{
	//Creating an object of class A
	A ob = new A();
	
	//Accessing the value of instance variable, a, before calling the UpdateA() method
	Console.WriteLine("Before calling UpdateA(), the value in instance variable, a: "+ ob.a);

	//Calling the UpdateA() method and passing it 100
	//to set the value of the instance variable, a
	ob.UpdateA(100);   

	//Accessing the value of instance variable, a, after calling the UpdateA() method
	Console.WriteLine("After calling UpdateA(), the value in instance variable, a: "+ ob.a);
}
}

Output-

Before calling UpdateA(), the value in instance variable, a: 20
After calling UpdateA(), the value in instance variable, a: 100

As you can see in our last example that within the UpdateA() method, we have used this keyword to access the instance variable, a, which has helped us to distinguish its name from the local variable a, and thereby resolving the issue of shadowing.

Please share this article -

< Prev

Next >

< C# Method Return Types

C# Static Keyword >

Advertisement