Access Modifiers in C#

Access Modifiers are keywords that define the accessibility of a member, class or datatype in a program. These are mainly used to restrict unwanted data manipulation by external programs or classes. There are 4 access modifiers (public, protected, internal, private) which defines the 6 accessibility levels as follows:

  • public
  • protected
  • internal
  • protected internal
  • private
  • private protected

The Accessibility table of these modifiers is given below:



public protected internal protected internal private private protected
Entire program Yes No No No No No
Containing class Yes Yes Yes Yes Yes Yes
Current assembly Yes No Yes Yes No No
Derived types Yes Yes No Yes No No
Derived types within current assembly Yes Yes No Yes No Yes

public Accessibility Level

Access is granted to the entire program. This means that another method or another assembly which contains the class reference can access these members or types. This access modifier has the most permissive access level in comparison to all other access modifiers.

Syntax:

public TypeName

Example: Here, we declare a class Student which consists of two class members rollNo and name which are public. These members can access from anywhere throughout the code in the current and another assembly in the program. The methods getRollNo and getName are also declared as public.

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# Program to show the use of
// public Access Modifier
using System;
  
namespace publicAccessModifier {
  
class Student {
  
    // Declaring members rollNo
    // and name as public
    public int rollNo;
    public string name;
  
    // Constructor
    public Student(int r, string n)
    {
        rollNo = r;
        name = n;
    }
  
    // methods getRollNo and getName
    // also declared as public
    public int getRollNo()
    {
        return rollNo;
    }
    public string getName()
    {
        return name;
    }
}
  
class Program { 
    
    // Main Method
    static void Main(string[] args)
    {
        // Creating object of the class Student
        Student S = new Student(1, "Astrid");
  
        // Displaying details directly
        // using the class members
        // accessible through another method
        Console.WriteLine("Roll number: {0}", S.rollNo);
        Console.WriteLine("Name: {0}", S.name);
  
        Console.WriteLine();
  
        // Displaying details using 
        // member method also public
        Console.WriteLine("Roll number: {0}", S.getRollNo());
        Console.WriteLine("Name: {0}", S.getName());
    }
}
}

chevron_right


Output:

Roll number: 1
Name: Astrid

Roll number: 1
Name: Astrid

protected Accessibility Level

Access is limited to the class that contains the member and derived types of this class. It means a class which is the subclass of the containing class anywhere in the program can access the protected members.

Syntax:

protected TypeName

Example: In the code given below, the class Y inherits from X, therefore, any protected members of X can be accessed from Y but the values cannot be modified.

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# Program to show the use of 
// protected Access Modifier
using System;
  
namespace protectedAccessModifier {
  
class X {
  
    // Member x declared
    // as protected
    protected int x;
  
    public X()
    {
        x = 10;
    }
}
  
// class Y inherits the 
// class X
class Y : X {
  
    // Members of Y can access 'x'
    public int getX()
    {
        return x;
    }
}
  
class Program {
  
    static void Main(string[] args)
    {
        X obj1 = new X();
        Y obj2 = new Y();
  
        // Displaying the value of x
        Console.WriteLine("Value of x is : {0}", obj2.getX());
    }
}
}

chevron_right


Output:

Value of x is : 10

internal Accessibility Level

Access is limited to only the current Assembly, that is any class or type declared as internal is accessible anywhere inside the same namespace. It is the default access modifier in C#.

Syntax:


internal TypeName

Example: In the code given below, The class Complex is a part of internalAccessModifier namespace and is accessible throughout it.

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# Program to show use of
// internal access modifier
// Inside the file Program.cs
using System;
  
namespace internalAccessModifier {
  
// Declare class Complex as internal
internal class Complex {
  
    int real;
    int img;
  
    public void setData(int r, int i)
    {
        real = r;
        img = i;
    }
  
    public void displayData()
    {
        Console.WriteLine("Real = {0}", real);
        Console.WriteLine("Imaginary = {0}", img);
    }
}
  
// Driver Class
class Program {
  
    // Main Method
    static void Main(string[] args)
    {
        // Instantiate the class Complex
        // in separate class but within 
        // the same assembly
        Complex c = new Complex();
  
        // Accessible in class Program
        c.setData(2, 1);
        c.displayData();
    }
}
}

chevron_right


Output:

Real = 2
Imaginary = 1

Note: In the same code if you add another file, the class Complex will not be accessible in that namespace and compiler gives an error.

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# program inside file xyz.cs
// seperate nampespace named xyz
using System;
  
namespace xyz {
  
class text {
  
    // Will give an error during compilation
    Complex c1 = new Complex();
    c1.setData(2, 3);
}
}

chevron_right


Output:

error CS1519

protected internal Accessibility Level

Access is limited to the current assembly or the derived types of the containing class. It means access is granted to any class which is derived from the containing class within or outside the current Assembly.

Syntax:

protected internal TypeName

Example: In the code given below, the member ‘value‘ is declared as protected internal therefore it is accessible throughout the class Parent and also in any other class in the same assembly like ABC. It is also accessible inside another class derived from Parent, namely Child which is inside another assembly.

filter_none

edit
close

play_arrow

link
brightness_4
code

// Inside file parent.cs
using System;
  
public class Parent {
  
    // Declaring member as protected internal
    protected internal int value;
}
  
class ABC {
  
    // Trying to access 
    // value in another class
    public void testAccess()
    {
        // Member value is Accessible
        Parent obj1 = new Parent();
        obj1.value = 12;
    }
}

chevron_right


filter_none

edit
close

play_arrow

link
brightness_4
code

// Inside file GFg.cs
using System;
  
namespace GFG {
  
class Child : Parent {
  
    // Main Method
    public static void Main(String[] args)
    {
        // Accessing value in another assembly
        Child obj3 = new Child();
  
        // Member value is Accessible
        obj3.value = 9;
        Console.WriteLine("Value = " + obj3.value);
    }
}
}

chevron_right


Output:

Value = 9

private Accessibility Level

Access is only granted to the containing class. Any other class inside the current or another assembly is not granted access to these members.

Syntax:


private TypeName

Example: In this code we declare the member value of class Parent as private therefore its access is restricted to only the containing class. We try to access value inside of a derived class named Child but the compiler throws an error {error CS0122: ‘PrivateAccessModifier.Parent.value’ is inaccessible due to its protection level}. Similarly, inside main {which is a method in another class}. obj.value will throw the above error. So we can use public member methods that can set or get values of private members.

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# Program to show use of 
// the private access modifier
using System;
  
namespace PrivateAccessModifier {
  
class Parent {
  
    // Member is declared as private
    private int value;
  
    // value is Accessible 
    // only inside the class
    public void setValue(int v)
    {
        value = v;
    }
  
    public int getValue()
    {
        return value;
    }
}
class Child : Parent {
  
    public void showValue()
    {
        // Trying to access value
        // Inside a derived class
        // Console.WriteLine( "Value = " + value );
        // Gives an error
    }
}
  
// Driver Class
class Program {
  
    static void Main(string[] args)
    {
        Parent obj = new Parent();
  
        // obj.value = 5;
        // Also gives an error
  
        // Use public functions to assign
        // and use value of the member 'value'
        obj.setValue(4);
        Console.WriteLine("Value = " + obj.getValue());
    }
}
}

chevron_right


Output:

Value = 4

private protected Accessibility Level

Access is granted to the containing class and its derived types present in the current assembly. This modifier is valid in C# version 7.2 and later.

Syntax:

private protected TypeName

Example: This code is same as the code above but since the Access modifier for member value is ‘private protected’ it is now accessible inside the derived class or Parent namely Child. Any derived class that maybe present in another assembly will not be able to access these private protected members.

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# Program to show use of 
// the private protected 
// Accessibility Level
using System;
  
namespace PrivateProtectedAccessModifier {
  
class Parent {
  
    // Member is declared as private protected
    private protected int value;
  
    // value is Accessible only inside the class
    public void setValue(int v)
    {
        value = v;
    }
    public int getValue()
    {
        return value;
    }
}
  
class Child : Parent {
  
    public void showValue()
    {
        // Trying to access value
        // Inside a derived class
  
        Console.WriteLine("Value = " + value);
        // value is accesible
    }
}
  
// Driver Code
class Program {
  
    // Main Method
    static void Main(string[] args)
    {
        Parent obj = new Parent();
  
        // obj.value = 5;
        // Also gives an error
  
        // Use public functions to assign
        // and use value of the member 'value'
        obj.setValue(4);
        Console.WriteLine("Value = " + obj.getValue());
    }
}
}

chevron_right


Output:

Value = 4

Important Points:

  • Namespaces doesn’t allow the access modifiers as they have no access restrictions.
  • The user is allowed to use only one accessibility at a time except the private protected and protected internal.
  • The default accessibility for the top-level types(that are not nested in other types, can only have public or internal accessibility) is internal.
  • If no access modifier is specified for a member declaration, then the default accessibility is used based on the context.


My Personal Notes arrow_drop_up

Student at Padre Conceicao College of Engineering, Goa Computer Engineering

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.




Article Tags :

2


Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.