Understanding Access Modifiers in .NET Core

Access Modifiers In C#

Access modifiers in C# specify the scope of accessibility of a member of a class or type of the class itself. For example, a public class is accessible to everyone without any restrictions, while an internal class may be accessible to the assembly only.

Why use Access Modifiers?

Access modifiers are an integral part of object-oriented programming. Access modifiers are used to implement encapsulation of OOP. Access modifiers allow you to define who does or doesn't have access to certain features.

Six different types of Access Modifiers

In C# there are 6 different types of Access Modifiers.

Modifier	Description
public	There are no restrictions on accessing public members.
private	Access is limited to within the class definition. This is the default access modifier type if none is formally specified
protected	Access is limited to within the class definition and any class that inherits from the class
internal	Access is limited exclusively to classes defined within the current project assembly
protected internal	Access is limited to the current assembly and types derived from the containing class. All members in the current project and all members in the derived class can access the variables.
private protected	Access is limited to the containing class or types derived from the containing class within the current assembly.

using System;
namespace AccessModifiers
{
    class Program
    {
        class AccessMod
        {
            public int num1;
        }

        static void Main(string[] args)
        {
            AccessMod ob1 = new AccessMod();
            // Direct access to public members
            ob1.num1 = 100;
            Console.WriteLine("Number one value in main {0}", ob1.num1);
            Console.ReadLine();
        }
    }
}

Public Modifier

The public keyword is an access modifier for types and type members. Public access is the most permissive access level.

There are no restrictions on accessing public members.

Accessibility

Can be accessed by objects of the class
Can be accessed by derived classes

Example. In the following example, num1 is direct access.

Private Modifier

Private access is the least permissive access level.

Private members are accessible only within the body of the class or the struct in which they are declared.

Accessibility

Cannot be accessed by an object
Cannot be accessed by derived classes

Example. In the following example, num2 is not accessible outside the class.

using System;
namespace AccessModifiers
{
    class Program
    {
        class AccessMod
        {
            public int num1;
            private int num2;
        }
        static void Main(string[] args)
        {
            AccessMod ob1 = new AccessMod();
            // Direct access to public members
            ob1.num1 = 100;
            // Access to private member is not permitted
            // ob1.num2 = 20; // This line will cause a compilation error
            Console.WriteLine("Number one value in main {0}", ob1.num1);
            Console.ReadLine();
        }
    }
}

The above program will give compilation error, as access to private is not permissible. In the figure below, you can see the private member num2 is unavailable.

Num

Protected Modifier

A protected member is accessible from within the class in which it is declared, and from within any class derived from the class that declared this member.

A protected member of a base class is accessible in a derived class only if the access takes place through the derived class type.

Accessibility

Cannot be accessed by an object

By derived classes

using System;
namespace AccessModifiers
{
    class Program
    {
        class Base
        {
            protected int num1;
        }
        class Derived : Base
        {
            public int num2;
            static void Main(string[] args)
            {
                // Base ob1 = new Base(); // This line will cause a compilation error
                Derived ob2 = new Derived();
                ob2.num1 = 20; // Access to protected member as it is inherited by the Derived class
                ob2.num2 = 90;
                Console.WriteLine("Number2 value {0}", ob2.num2);
                Console.WriteLine("Number1 value which is protected {0}", ob2.num1);
                Console.ReadLine();
            }
        }
    }
}

In the above program we try to access the protected members in the main it is not available as shown in the picture below num1 is not listed in Intellisense.

Equal

Internal Modifier

The internal keyword is an access modifier for types and type members. We can declare a class as internal or its member as internal. Internal members are accessible only within files in the same assembly (.dll).

In other words, access is limited exclusively to classes defined within the current project assembly.

Accessibility

In some assemblies (public)

Can be accessed by objects of the class
Can be accessed by derived classes

In other assembly (internal)

Cannot be accessed by an object
Cannot be accessed by derived classes

Protected Internal Modifier

The protected internal accessibility means protected OR internal, not protected AND internal.

In other words, a protected internal member is accessible from any class in the same assembly, including derived classes.

The protected internal access modifier seems to be confusing but is a union of protected and internal in terms of providing access but not restricting. It allows:

Inherited types, even though they belong to a different assembly, have access to the protected internal members.
Types that reside in the same assembly, even if they are not derived from the type, also have access to the protected internal members.

Default Access

A default access level is used if no access modifier is specified in a member declaration. The following list defines the default access modifier for certain C# types:

Enum: The default and only access modifier supported is public.
Class: The default access for a class is private. It may be explicitly defined using any of the access modifiers.
Interface: The default and only access modifier supported is public.
Struct: The default access is private with public and internal support as well.

The default access may suffice for a given situation, but you should specify the access modifier you want to use to ensure proper application behavior.

Note. Interface and enumeration members are always public and no access modifiers are allowed.

Conclusion

I hope that this article would have helped you in understanding accessibility modifiers. Your feedback and constructive contributions are welcome.