Access Modifiers in C# with Examples

What are Access Modifiers in C#?

Access modifiers in C# are particular keywords that determine how accessible various elements, such as classes, fields, properties, and methods, are within a C# program. They manage the visibility of these elements to other parts of the code, ensuring proper encapsulation and restricting access to specific components.

Use Cases

• Encapsulation: Access modifiers enable encapsulation by hiding internal details and exposing only necessary functionalities to the outside world. This ensures controlled access and proper data protection.
• Information Hiding: Access modifiers support information hiding, concealing sensitive or implementation-specific class details, and providing a public interface for interaction.
• Security and Privacy: Access modifiers maintain data and method security and privacy within a class. Private members hide sensitive information, accessible only within the class.
• Inheritance and Polymorphism: Access modifiers, like protected and protected internal, allow derived classes to access specific base class members, promoting code reuse and inheritance.

Types and Levels of Access Modifiers in C#

• Public (public): The most permissive access modifier. Members marked as public are accessible from anywhere in the codebase, including other classes and assemblies.
• Private (private): The most restrictive access modifier. Members marked as private are accessible only within the class where they are defined.
• Protected (protected): Members marked as protected are accessible within the class where they are defined and any classes derived from that class.
• Internal (internal): Members marked as internal are accessible within the same assembly (project) but not from outside assemblies.
• Protected Internal (protected internal): Members marked as protected internal are accessible within the same assembly and any classes derived from that class, whether they are inside or outside the assembly.
• Private Protected (private protected): Members marked as private protected are accessible within the class where they are defined and any classes derived from that class, but only within the same assembly.

To understand all the access modifiers Deeply, let's use a real-world example of a Social Media Platform to explain the access modifiers in C#. In this analogy, we'll consider a user account on the platform as our code element.

Public Access Modifier

Imagine the user's profile picture* on the social media platform. When a user sets their profile picture to be public, it means anyone can view the picture. Similarly, in C#, a member marked as public is accessible from anywhere in the codebase.

Syntax: public TypeName

Accessibility: Accessible from anywhere, within the same assembly or other assemblies.

Example:

Output:

Explanation:

The SocialMediaAccount class has a public property ProfilePictureUrl to store the URL of the user's profile picture, making it accessible from anywhere in the program. It also has a public method ViewProfilePicture() that prints the profile picture URL to the console when called. In the Main method, we create an instance of SocialMediaAccount, set the profile picture URL, and then call the ViewProfilePicture method to display the URL.

Private Access Modifier

In C#, a member marked as private is accessible only within the class where it's defined. let's consider the user's account password. Only the user themselves (inside the class) should have access to their password.

Syntax: private TypeName

Accessibility: Accessible only within the same class or struct.

Example:

Output

Explanation

The SocialMediaAccount class has a private property Password to store the user's account password, making it accessible only within the class where it is defined. The class also has a public method SetPassword to set a new password and another public method ViewPassword to view the password. In the Main method, we create an instance of SocialMediaAccount, set a new password using the SetPassword method, and then try to view the password directly (which won't work due to the private access modifier).

Protected Access Modifier

In C#, a member marked as protected is accessible within the class where it's defined and any classes derived from that class. Continuing with the social media analogy, let's say the user's list of friends is marked as protected. It is accessible to the user's close friends (derived classes).

Syntax: protected TypeName

Accessibility: Accessible within the same class or struct and its derived classes.

Example:

Output

Explanation

The SocialMediaAccount class has a protected property Friends to store the user's friends, making it accessible within the class and its derived classes. The class also has a public method AddFriend to add a new friend to the Friends list and another public method ViewFriendsList to view the list of friends . In the Main method, we create an instance of SocialMediaAccount, add friends using the AddFriend method, and then try to directly access and modify the Friends list (which won't work due to the protected access modifier).

Internal Access Modifier:

In C#, a member marked as internal is accessible within the same assembly, but not from outside assemblies Moving on, consider the user's status update, which is marked as internal. This means that only users (classes) within the same social media platform (assembly) can see the status updates.

Syntax: internal TypeName

Accessibility: Accessible within the same assembly but not from other assemblies.

Example:

Output

Explanation

The SocialMediaAccount class is marked as internal, so it is accessible only within the same assembly (not shown in this code example, but imagine it is in a separate project or assembly). The class has an internal property StatusUpdate to store the user's status update, making it accessible within the same assembly. The class also has a public method PostStatusUpdate to post a new status update and another public method ViewStatusUpdate to view the posted status update. In the Main method, we create an instance of SocialMediaAccount, post a status update using the PostStatusUpdate method, and then try to directly access and modify the StatusUpdate property (which won't work due to the internal access modifier).

Protected Internal Access Modifier:

In C#, a member marked as protected internal is accessible within the same assembly, and any classes derived from that class, regardless of whether they are inside or outside the assembly. let's consider the user's contact number, which is marked as protected internal. This means that the contact number is accessible to the user's close friends (derived classes) who are part of the same social media platform (assembly).

Syntax: protected internal TypeName

Accessibility: Accessible within the same assembly and from derived classes, even if they are in a different assembly.

Example:

Output

Explanation

The SocialMediaAccount class has a protected internal property ContactNumber to store the user's contact number, making it accessible within the same assembly and its derived classes. The class also has a public method SetContactNumber to set the contact number and another public method ViewContactNumber (for demonstration purposes only) to view the contact number (not typically used in production code). In the Main method, we create an instance of SocialMediaAccount, set a contact number using the SetContactNumber method, and then try to directly access and modify the ContactNumber property (which won't work due to the protected internal access modifier).

Private Protected Access Modifier

In C#, the private protected access modifier allows members to be accessed within the class and its derived classes, but only within the same assembly. It provides a way to share members among related classes in the assembly while preventing access from outside the class hierarchy, even in other assemblies.

Syntax: private protected TypeName

Accessibility: Members with the private protected access modifier are accessible within the same class and its derived classes in the same assembly. They are not accessible outside the class hierarchy, even in other assemblies.

Example:

output

Explanation

In this example, the SocialMediaAccount class has a private protected property named PersonalMessages, accessible within the class and its derived class DerivedAccount in the same assembly. The SendPersonalMessage method sets the PersonalMessages property, and the ViewPersonalMessages method allows viewing its value.

In Main, we create an instance of SocialMediaAccount and use SendPersonalMessage to set a personal message. Then, we create an instance of DerivedAccount, derived from SocialMediaAccount, and use UpdatePersonalMessage to update PersonalMessages. Both operations work as expected due to the private protected accessibility.

Finally, we call ViewPersonalMessages to view personal messages. The output confirms that private protected restricts access to within the class hierarchy and the same assembly.

By using this analogy, we can understand how each access modifier works in C# based on the accessibility of different aspects of a user's social media account. It helps us visualize and remember the differences between each access modifier more effectively.