RetroSearch Browse

Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://www.geeksforgeeks.org/c-sharp/access-modifiers-in-c-sharp/ below:

C# Access Modifiers - GeeksforGeeks

C# Access Modifiers

Last Updated : 15 Jan, 2025

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. These modifiers control the scope and extent of access to classes, methods, properties, and other members within and from external classes or assemblies. By using modifiers we ensure that certain data or functionality is exposed only when necessary otherwise keep it hidden.

Access Modifiers and Accessibility

There are 4 access modifiers (public, protected, internal, private) which define the 6 accessibility levels as follows:

Modifiers

Entire program

Containing Class

Current assembly

Derived Types

Derived Types within Current Assembly

public

Yes

private

No

Yes

No

protected

No

Yes

No

Yes

internal

No

Yes

No

Yes

protected internal

No

Yes

protected private

No

Yes

No

Yes

1. public Modifier

public modifier provides access to the entire program. It 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.

Example:


 using System;

class Student
{
    public int rollNo;
    public string name;

    public Student(int r, string n)
    {
        rollNo = r;
        name = n;
    }

    public int getRollNo()
    {
        return rollNo;
    }

    public string getName()
    {
        return name;
    }
}

class Geeks
{
    static void Main(string[] args)
    {
        Student S = new Student(1, "Geek");

        // accessible through another method       
        Console.WriteLine("Displaying using class members");
        Console.WriteLine("Roll number: {0}", S.rollNo);
        Console.WriteLine("Name: {0}", S.name);

        Console.WriteLine();

        Console.WriteLine("Displaying Using methods");
        Console.WriteLine("Roll number: {0}", S.getRollNo());
        Console.WriteLine("Name: {0}", S.getName());
    }
}

Output

Displaying using class members
Roll number: 1
Name: Geek

Displaying Using methods
Roll number: 1
Name: Geek

2. private modifier

private access modifier limits access to members of a class so that only the class itself can use them. Private members cannot be accessed from outside the class, not even by derived classes.

Example:


 using System;

class Parent 
{	
	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
	}
}

class Geeks 
{
	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());
	}
}

3. protected Modifier

protected access modifier allows members to be accessible within the class and by derived classes (subclasses). It does not allow access from outside the class or its derived classes.

Example:


 using System;

class Student 
{  
    protected string name;
  
    public Student(string studentName)
    {
        name = studentName; 
    }
}

class Geek : Student 
using System;

class Student
{
    protected string name;
  
    public Student(string studentName)
    {
        name = studentName; // Initialize name
    }
}


class Geek : Student
{

    public Geek(string geekName) : base(geekName)
    {

    }

    public string GetName()
    { 
      // Access protected member from base class 
        return name; 
    }
}

class Geeks
{
    static void Main(string[] args)
    {

        Geek obj = new Geek("Geeky");

        // Access the protected member through the derived class method
        Console.WriteLine("The student's name is: {0}",
                          obj.GetName());
    }
}
{
    
    public Geek(string geekName) : base(geekName) 
    { 
     
    }
  
    public string GetName()
    { 
      // Access protected member from base class
        return name; 
    }
}

class Geeks 
{
    static void Main(string[] args)
    {
        
        Geek obj = new Geek("Geeky");
        
        // Access the protected member through the derived class method
        Console.WriteLine("The student's name is: {0}", 
                          obj.GetName());
    }
}

Output

The student's name is: Geeky

4. internal Modifier

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#. It is useful when you want to restrict access to code that should only be used within the same project or library.

Example:


 // Inside the file Geeks.cs
using System;

// 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);
	}
}

class Geeks 
{
	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();
	}
}

Output

Real = 2
Imaginary = 1

5. protected internal

protected internal access modifier combines the features of protected and internal. It allows members to be accessed within the same assembly as well as in derived classes, regardless of whether they are in the same assembly or not.

Example: In the code given below, the Parent class which we create in the same assembly and we create another class named as GFG we access it In GFG from the Parent class. 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.

Program 1: Parent.cs


 // Inside file Parent.cs
using System;

public class Parent
{
    // Declaring 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;
    }
}

Note: This program is in the same folder and the member value of Parent is protected internal and we can access it in the derived class with Parent class's instance.

Program 2: GFG.cs


 // Inside the file GFG.cs 
using System;

namespace GFG {

class Child : Parent {

	
	public static void Main(String[] args)
	{
		// Accessing value in another assembly
		Child obj2 = new Child();

		// Member value is Accessible
		obj2.value = 9;
		Console.WriteLine("Value = " + obj2.value);
	}
}
}

Output:

Value = 9

6. protected private Modifier

protected private access is only granted to the containing class. Any other class inside the current or another assembly is not granted access to these members. This modifier is valid in C# version 7.2 and later.

Example:


 // illustration of 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()
	{
		// access value
		// Inside a derived class

		Console.WriteLine("Value = " + value);
		// value is accessible
	}
}


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());
	}
  }
}

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.

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4