ASP.NET Access Modifiers ?

The main purpose of using access specifiers is to provide security to the applications.   Access Modifiers (Access Specifiers) describes as the scope of accessibility of an Object and its members. All C# types and type members have an accessibility level. We can control the scope of the member object of a class using access specifiers. We are using access modifiers for providing security of our applications. When we specify the accessibility of a type or member we have to declare it by using any of the access modifiers provided by C# language.

           when we use Access Specifiers in C# they help the other class members to know how they can access the methods or variables declared/defined inside another class.

C# supports five types of access specifiers to tell the extent of visibility of a class member. They are:-

• public,
• private,
• protected,
• internal or friend,
• protected internal or protected friend

Public:

Public is the most common access specifier in C#. It can be access from anywhere that means there is no restriction on accessibility. The scope of the accessibility is inside class as well as outside. The type or member can be accessed by any other code in the same assembly or another assembly that references it.

Let's check an example for this..
----------------------------------------------------------------

using System;
namespace HelloWorldTest
{
class hello
{
public int iNumumber;
}
class MyMainClass
{
static void Main(string[] args)
{
hello HelloObjectTest=new hello(); 
HelloObjectTest. iNumumber =10;

 /* since variable iNum1 is public it can be accessed in other classes also*/

Console.WriteLine(HelloObjectTest. iNumumber); 
} 
} 
}

----------------------------------------------------------------

private :

The scope of the accessibility is limited only inside the classes or struct in which they are declared. The private members cannot be accessed outside the class and it is the least permissive access level.
Let's check an example for this..
----------------------------------------------------------------

using System;
namespace HelloWorld
{
class hello
{
public int iNum1;
private int iNum2;

public hello()
{
iNum1=0;
iNum2=10;
}
}

class MyMainClass
{
static void Main(string[] args)
{
hello HelloObject=new hello(); 
//CORRECT METHOD
HelloObject.iNum1=10; //Here since variable iNum1 is public it can be accessed in other classes also

//WRONG METHOD
HelloObject.iNum2=20; /*This line will return an Error since the access to this variable is Private. So it cannot be accessed outside the class*/

Console.WriteLine(HelloObject.iNum1); 
} 
} 
}

----------------------------------------------------------------

protected :

The scope of accessibility is limited within the class or struct and the class derived (Inherited )from this class.

Let's check an example for this..
----------------------------------------------------------------

using System;
namespace HelloWorld
{
class hello
{
public int iNum1;
protected int iNum2;
}

class world : hello
{
public int AddDetails()
{
iNum1=20;
iNum2=10;

return iNum1+iNum2;
} 
}

class MyMainClass
{
static void Main(string[] args)
{
world worldObject=new world(); 

worldObject.iNum1=50; //Line 1 No Error

worldObject.iNum2=10; //Line 2 Error

Console.WriteLine(worldObject.AddDetails().ToString());

} 
} 
}

----------------------------------------------------------------
internal :

The internal access modifiers can access within the program that contain its declarations and also access within the same assembly level but not from another assembly.

protected internal :

Protected internal is the same access levels of both protected and internal. It can access anywhere in the same assembly and in the same class also the classes inherited from the same class.

ets now understand the above with an example:
----------------------------------------------------------------

using System;
class Student
{
private string sAddress;
protected string sPhNo;
protected internal long iZipCode;
void Hello()
{
Console.WriteLine(“Hello World!”);
}
internal void Hello2()
{
Console.WriteLine(“Hello Student!”);
}
public void SetAddress()
{
Console.WriteLine(“Enter your Address:”)
sAddress = Console.ReadLine();
}
public void SetPhNo()
{
Console.WriteLine(“Enter your Phone Number:”)
sPhNo = Console.ReadLine();
}
public void SetZipCode()
{
Console.WriteLine(“Enter the Zip Code: “);
iZipCode =Convert.ToInt64(Console.ReadLine());
}
public void DisplayStudent()
{
Console.WriteLine(“The Address is: {0}”, sAddress);
}
}
class Display
{
static void Main(string[] args)
{
Student John = new Student();
Console.WriteLine(John.sPhNo); //Error: Protected members cannot be accessed 
John.SetAddress(); //public members can be accessed outside the class definition 
John.SetPhNo(); //public members can be accessed outside the class definition 
Console.WriteLine(John.iZipCode); //error: protected internal members cannot be accessed outside the class definition 
John.SetZipCode(); //public members can be accessed outside the class definition 
John.DisplayStudent(); // public members can be accessed outside the class definition 
Console.WriteLine(John.sAddress); //error: private members cannot be accessed outside the class definition
John.Hello(); //error: private members cannot be accessed outside the class definition 
John.Hello2(); //displays Hello student!
Console.ReadLine();
}
}
----------------------------------------------------------------