Diving into OOP (Day 5): All About C# Access Modifiers (Public/Private/Protected/Internal/Sealed/Constants/Static and Readonly Fields)

Introduction

Pre-requisites

Roadmap

1. Diving in OOP (Day 1): Polymorphism and Inheritance(Early Binding/Compile Time Polymorphism)
2. Diving in OOP (Day 2): Polymorphism and Inheritance (Inheritance)
3. Diving in OOP (Day 3): Polymorphism and Inheritance (Dynamic Binding/Run Time Polymorphism)
4. Diving in OOP (Day 4): Polymorphism and Inheritance (All about Abstarct classes in C#)
5. Diving in OOP (Day 5): All about access modifiers in C# (Public/Private/Protected/Internal/Sealed/Constants/Readonly Fields)
6. Diving in OOP (Day 6): Understanding Enum in C# (A Practical Approach)
7. Diving into OOP (Day 7): Properties in C# (A Practical Approach)
8. Diving into OOP (Day 8): Indexers in C# (A Practical Approach)
9. Diving into OOP (Day 9): Understanding Events in C# (An Insight)

Access Modifiers

“Access modifiers (or access specifiers) are keywords in object-oriented languages that set the accessibility of classes, methods, and other members. Access modifiers are a specific part of programming language syntax used to facilitate the encapsulation of components.”

Public, Private, Protected at Class Level

 Collapse | Copy Code

using System;

namespace AccessModifiers
{
class Modifiers
{
static void AAA()
{
Console.WriteLine(“Modifiers AAA”);
}

public static void BBB()
{
Console.WriteLine(“Modifiers BBB”);
AAA();
}
}

class Program
{
static void Main(string[] args)
{
Modifiers.BBB();
}
}
}

Output

 Collapse | Copy Code

Modifiers BBB
Modifiers AAA

 Collapse | Copy Code

class Program
    {
static void Main(string[] args)
        {
            Modifiers.AAA();
            Console.ReadKey();
        }
    }

Output

 Collapse | Copy Code

'AccessModifiers.Modifiers.AAA()' is inaccessible due to its protection level

 Collapse | Copy Code

class Modifiers
    {
protected static void AAA()
        {
            Console.WriteLine("Modifiers AAA");
        }

public static void BBB()
{
Console.WriteLine(“Modifiers BBB”);
AAA();
}
}

Program

 Collapse | Copy Code

class Program
    {
static void Main(string[] args)
        {
            Modifiers.AAA();
            Console.ReadKey();
        }
    }

Output

 Collapse | Copy Code

'AccessModifiers.Modifiers.AAA()' is inaccessible due to its protection level

Modifiers in Inheritance

Modifiers Base Class

 Collapse | Copy Code

class ModifiersBase
    {
static void AAA()
        {
            Console.WriteLine("ModifiersBase AAA");
        }
public static void BBB()
        {
            Console.WriteLine("ModifiersBase BBB");
        }
protected static void CCC()
        {
            Console.WriteLine("ModifiersBase CCC");
        }
    }

Modifiers Derive Class

 Collapse | Copy Code

class ModifiersDerived:ModifiersBase
    {
public static void XXX()
        {
            AAA();
            BBB();
            CCC();
        }
    }

Program Class

 Collapse | Copy Code

class Program
    {
static void Main(string[] args)
        {
            ModifiersDerived.XXX();
            Console.ReadKey();
        }
    }

Output

 Collapse | Copy Code

'AccessModifiers.ModifiersBase.AAA()' is inaccessible due to its protection level

Internal Modifier at Class Level

 Collapse | Copy Code

AccessModifiersLibrary.ClassA:

namespace AccessModifiersLibrary
{
internal class ClassA
{
}
}

AccessModifiers.Program

 Collapse | Copy Code

using AccessModifiersLibrary;

namespace AccessModifiers
{
class Program
{
static void Main(string[] args)
{
ClassA classA;
}
}
}

Output

 Collapse | Copy Code

Compile time error: 'AccessModifiersLibrary.ClassA' is inaccessible due to its protection level

AccessModifiersLibrary.ClassA

 Collapse | Copy Code

namespace AccessModifiersLibrary
{
class ClassA
    {
    }
}

AccessModifiers.Program

 Collapse | Copy Code

using AccessModifiersLibrary;

namespace AccessModifiers
{
class Program
{
static void Main(string[] args)
{
ClassA classA;
}
}
}

Output

 Collapse | Copy Code

Compile time error: 'AccessModifiersLibrary.ClassA' is inaccessible due to its protection level

Namespaces with Modifiers

Program

 Collapse | Copy Code

public namespace AccessModifiers
{
class Program
    {
static void Main(string[] args)
        {

}
}
}

Output

 Collapse | Copy Code

Compile time error: A namespace declaration cannot have modifiers or attributes

Private Class

 Collapse | Copy Code

namespace AccessModifiers
{
private class Program
    {
static void Main(string[] args)
        {

}
}
}

Output

 Collapse | Copy Code

Compile time error: Elements defined in a namespace cannot be explicitly declared as private, protected, or protected internal

 Collapse | Copy Code

namespace AccessModifiers
{
public class Program
    {
static void Main(string[] args)
        {
        }

public private void Method1()
{

}
}
}

Output

 Collapse | Copy Code

Compile time error: More than one protection modifier

Internal Class and Public Method

 Collapse | Copy Code

namespace AccessModifiersLibrary
{
internal class ClassA
    {
public void MethodClassA(){}
    }
}

Program

 Collapse | Copy Code

using AccessModifiersLibrary;

namespace AccessModifiers
{
public class Program
{
public static void Main(string[] args)
{
ClassA classA = new ClassA();
classA.MethodClassA();
}
}
}

Output

 Collapse | Copy Code

'AccessModifiersLibrary.ClassA' is inaccessible due to its protection level
The type 'AccessModifiersLibrary.ClassA' has no constructors defined
'AccessModifiersLibrary.ClassA' is inaccessible due to its protection level
'AccessModifiersLibrary.ClassA' does not contain a definition for 'MethodClassA' and
no extension method 'MethodClassA' accepting a first argument of type 'AccessModifiersLibrary.ClassA'
could be found (are you missing a using directive or an assembly reference?)

Public Class and Private Method

 Collapse | Copy Code

AccessModifiersLibrary.ClassA:

namespace AccessModifiersLibrary
{
public class ClassA
{
private void MethodClassA(){}
}
}

Program

 Collapse | Copy Code

using AccessModifiersLibrary;

namespace AccessModifiers
{
public class Program
{
public static void Main(string[] args)
{
ClassA classA = new ClassA();
classA.MethodClassA();
}
}
}

Output on compilation

 Collapse | Copy Code

'AccessModifiersLibrary.ClassA' does not contain a definition
for 'MethodClassA' and no extension method 'MethodClassA' accepting a first argument
of type 'AccessModifiersLibrary.ClassA' could be found (are you missing a using directive or an assembly reference?)

Public Class and Internal Method

 Collapse | Copy Code

AccessModifiersLibrary.ClassA:

namespace AccessModifiersLibrary
{
public class ClassA
{
Internal void MethodClassA(){}
}
}

Program

 Collapse | Copy Code

using AccessModifiersLibrary;

namespace AccessModifiers
{
public class Program
{
public static void Main(string[] args)
{
ClassA classA = new ClassA();
classA.MethodClassA();
}
}
}

Output on compilation

 Collapse | Copy Code

'AccessModifiersLibrary.ClassA' does not contain a definition for 'MethodClassA' and no extension
method 'MethodClassA' accepting a first argument of type 'AccessModifiersLibrary.ClassA' could be
found (are you missing a using directive or an assembly reference?)

Protected Internal

 Collapse | Copy Code

namespace AccessModifiersLibrary
{
public class ClassA
    {
protected internal void MethodClassA()
        {

}
}

public class ClassB:ClassA
{
protected internal void MethodClassB()
{
MethodClassA();
}
}

public class ClassC
{
public void MethodClassC()
{
ClassA classA=new ClassA();
classA.MethodClassA();
}
}
}

Program

 Collapse | Copy Code

using AccessModifiersLibrary;

namespace AccessModifiers
{
public class Program
{
public static void Main(string[] args)
{
ClassC classC=new ClassC();
classC.MethodClassC();
}
}
}

Compiler output

 Collapse | Copy Code

The code successfully compiles with no error.

Protected Member

 Collapse | Copy Code

namespace AccessModifiers
{
class AAA
    {
protected int a;
void MethodAAA(AAA aaa,BBB bbb)
        {
            aaa.a = 100;
            bbb.a = 200;
        }
    }
class BBB:AAA
     {
void MethodBBB(AAA aaa, BBB bbb)
         {
             aaa.a = 100;
             bbb.a = 200;
         }
     }
public class Program
    {
public static void Main(string[] args)
        {
        }
    }
}

Compiler Output

 Collapse | Copy Code

Cannot access protected member 'AccessModifiers.AAA.a' via a qualifier of type 'AccessModifiers.AAA';
the qualifier must be of type 'AccessModifiers.BBB' (or derived from it)

Accessibility Priority in Inheritance

Program

 Collapse | Copy Code

namespace AccessModifiers
{
class AAA
    {

}
public class BBB:AAA
{

}
public class Program
{
public static void Main(string[] args)
{
}
}
}

Compiler Output

 Collapse | Copy Code

Compile time error: Inconsistent accessibility: base class 'AccessModifiers.AAA' is less accessible than class 'AccessModifiers.BBB'

Program

 Collapse | Copy Code

namespace AccessModifiers
{
class AAA
    {

}
public class BBB
{
public AAA MethodB()
{
AAA aaa= new AAA();
return aaa;
}
}
public class Program
{
public static void Main(string[] args)
{
}
}
}

Compiler output

 Collapse | Copy Code

Inconsistent accessibility: return type 'AccessModifiers.AAA' is less accessible than method 'AccessModifiers.BBB.MethodB()'

Program

 Collapse | Copy Code

namespace AccessModifiers
{
class AAA
    {

}
public class BBB
{
public AAA aaa;
}
public class Program
{
public static void Main(string[] args)
{
}
}
}

Compiler Output

 Collapse | Copy Code

Inconsistent accessibility: field type 'AccessModifiers.AAA' is less accessible than field 'AccessModifiers.BBB.aaa'

 Collapse | Copy Code

namespace AccessModifiers
{
class AAA
    {

}
public class BBB
{
AAA a;
}
public class Program
{
public static void Main(string[] args)
{
}
}
}

Sealed Classes

Program

 Collapse | Copy Code

namespace AccessModifiers
{
sealed class AAA
    {

}
class BBB:AAA
{

}
public class Program
{
public static void Main(string[] args)
{
}
}
}

Compiler Output

 Collapse | Copy Code

'AccessModifiers.BBB': cannot derive from sealed type 'AccessModifiers.AAA'

Program

 Collapse | Copy Code

using System;

namespace AccessModifiers
{
sealed class AAA
{
public int x = 100;
public void MethodA()
{
Console.WriteLine(“Method A in sealed class”);
}
}
public class Program
{
public static void Main(string[] args)
{
AAA aaa=new AAA();
Console.WriteLine(aaa.x);
aaa.MethodA();
Console.ReadKey();
}
}
}

Compiler Output

 Collapse | Copy Code

100
Method A in sealed class

Constants

Lab1

Program

 Collapse | Copy Code

public class Program
    {
private const int x = 100;
public static void Main(string[] args)
        {
            Console.WriteLine(x);
            Console.ReadKey();
        }
    }

Output

 Collapse | Copy Code

100

Lab2

 Collapse | Copy Code

using System;

namespace AccessModifiers
{
public class Program
{
private const int x = y + 100;
private const int y = z – 10;
private const int z = 300;

public static void Main(string[] args)
{
System.Console.WriteLine(“{0} {1} {2}”,x,y,z);
Console.ReadKey();
}
}
}

Output

 Collapse | Copy Code

390 290 300

Lab3

Program

 Collapse | Copy Code

using System;

namespace AccessModifiers
{
public class Program
{
private const int x = y + 100;
private const int y = z – 10;
private const int z = x;

public static void Main(string[] args)
{
System.Console.WriteLine(“{0} {1} {2}”,x,y,z);
Console.ReadKey();
}
}
}

Output

 Collapse | Copy Code

The evaluation of the constant value for 'AccessModifiers.Program.x' involves a circular definition

Lab4

 Collapse | Copy Code

using System;

namespace AccessModifiers
{
public class Program
{
public const ClassA classA=new ClassA();
public static void Main(string[] args)
{
}
}

public class ClassA
{

}
}

Output

 Collapse | Copy Code

Compile time error: 'AccessModifiers.Program.classA' is of type 'AccessModifiers.ClassA'.
A const field of a reference type other than string can only be initialized with null.

 Collapse | Copy Code

using System;

namespace AccessModifiers
{
public class Program
{
public const ClassA classA=null;
public static void Main(string[] args)
{
}
}

public class ClassA
{

}
}

Lab5

ClassA

 Collapse | Copy Code

public class ClassA
    {
public const int aaa = 10;
    }

Program

 Collapse | Copy Code

public class Program
    {
public static void Main(string[] args)
        {
            ClassA classA=new ClassA();
            Console.WriteLine(classA.aaa);
            Console.ReadKey();
        }
    }

Output

 Collapse | Copy Code

Compile time error: Member 'AccessModifiers.ClassA.aaa'
cannot be accessed with an instance reference; qualify it with a type name instead

 Collapse | Copy Code

using System;

namespace AccessModifiers
{
public class ClassA
{
public static const int aaa = 10;
}

public class Program
{
public static void Main(string[] args)
{
ClassA classA=new ClassA();
Console.WriteLine(classA.aaa);
Console.ReadKey();
}
}
}

Output

 Collapse | Copy Code

Compile time error: The constant 'AccessModifiers.ClassA.aaa' cannot be marked static

Lab6

 Collapse | Copy Code

using System;

namespace AccessModifiers
{
public class ClassA
{
public const int xxx = 10;
}

public class ClassB:ClassA
{
public const int xxx = 100;
}

public class Program
{
public static void Main(string[] args)
{
Console.WriteLine(ClassA.xxx);
Console.WriteLine(ClassB.xxx);
Console.ReadKey();
}
}
}

Output

 Collapse | Copy Code

10
100
Compiler Warning: 'AccessModifiers.ClassB.xxx' hides inherited
member 'AccessModifiers.ClassA.xxx'. Use the new keyword if hiding was intended.

Static Fields

Lab1

Program

 Collapse | Copy Code

using System;

namespace AccessModifiers
{
public class Program
{
private static int x;
private static Boolean y;
public static void Main(string[] args)
{
Console.WriteLine(x);
Console.WriteLine(y);
Console.ReadKey();
}
}
}

Output

 Collapse | Copy Code

0
False

Lab2

Program

 Collapse | Copy Code

using System;

namespace AccessModifiers
{
public class Program
{
private int x;
private Boolean y;
public static void Main(string[] args)
{
Program program=new Program();
Console.WriteLine(program.x);
Console.WriteLine(program.y);
Console.ReadKey();
}
}
}

Output

 Collapse | Copy Code

0
False

Lab3

Program

 Collapse | Copy Code

using System;

namespace AccessModifiers
{
public class Program
{
private static int x = y + 10;
private static int y = x + 5;
public static void Main(string[] args)
{
Console.WriteLine(Program.x);
Console.WriteLine(Program.y);
Console.ReadKey();
}
}
}

Output

 Collapse | Copy Code

10
15

Lab4

Program

 Collapse | Copy Code

using System;

namespace AccessModifiers
{
public class Program
{
int x = y + 10;
int y = x + 5;
public static void Main(string[] args)
{

}
}
}

Output

 Collapse | Copy Code

Compile time error:

A field initializer cannot reference the non-static field, method, or property ‘AccessModifiers.Program.y’
A field initializer cannot reference the non-static field, method, or property ‘AccessModifiers.Program.x’

Readonly Fields

Lab1

Program

 Collapse | Copy Code

using System;

namespace AccessModifiers
{
public class Program
{
public static readonly int x = 100;

public static void Main(string[] args)
{
Console.WriteLine(x);
Console.ReadKey();
}
}
}

Output

 Collapse | Copy Code

100

Lab2

Program

 Collapse | Copy Code

using System;

namespace AccessModifiers
{
public class Program
{
public static readonly int x = 100;

public static void Main(string[] args)
{
x = 200;
Console.WriteLine(x);
Console.ReadKey();
}
}
}

Output

 Collapse | Copy Code

Compile time error: A static readonly field cannot be assigned to
(except in a static constructor or a variable initializer).

Lab3

Program

 Collapse | Copy Code

using System;

namespace AccessModifiers
{
public class Program
{
public static readonly int x;

public static void Main(string[] args)
{
}
}
}

Lab4

Program

 Collapse | Copy Code

using System;

namespace AccessModifiers
{
public class Program
{
public static readonly int x;

static Program()
{
x = 100;
Console.WriteLine(“Inside Constructor”);
}

public static void Main(string[] args)
{
Console.WriteLine(x);
Console.ReadKey();
}
}
}

Output

 Collapse | Copy Code

Inside Constructor
100

Lab5

Program

 Collapse | Copy Code

using System;

namespace AccessModifiers
{
public class ClassA
{

}
public class Program
{

public readonly ClassA classA=new ClassA();
public static void Main(string[] args)
{
}
}
}

Lab6

Program

 Collapse | Copy Code

using System;

namespace AccessModifiers
{
public class ClassA
{
public int readonly x= 100;
}
public class Program
{
public static void Main(string[] args)
{
}
}
}

Output

 Collapse | Copy Code

Compile time error:

Member modifier ‘readonly’ must precede the member type and name
Invalid token ‘=’ in class, struct, or interface member declaration

Lab7

Program

 Collapse | Copy Code

using System;

namespace AccessModifiers
{
public class ClassA
{
public readonly int x= 100;

void Method1(ref int y)
{

}

void Method2()
{
Method1(ref x);
}
}
public class Program
{

public static void Main(string[] args)
{
}
}
}

Output

 Collapse | Copy Code

Compile time error:

A readonly field cannot be passed ref or out (except in a constructor)
A readonly field can’t be changed by anyone except a constructor.
The method Method1 expects a ref parameter which if we have forgotten allows you
to change the value of the original. Therefore C# does not permit a readonly
as a parameter to a method that accepts a ref or an out parameters.

Summary

1. The default access modifier is private for class members.
2. A class marked as internal can have its access limited to the current assembly only.
3. Namespaces as we see by default can have no accessibility specifiers at all. They are by default public and we cannot add any other access modifier including public again too.
4. A class can only be public or internal. It cannot be marked as protected or private. The default isinternal for the class.
5. Members of a class can be marked with all the access modifiers, and the default access modifier is private.
6. Protected internal means that the derived class and the class within the same source code file can have access.
7. Between public and internal, public always allows greater access to its members.
8. Base class always allows more accessibility than the derived class.
9. The return values of a method must have greater accessibility than that of the method itself.
10. A class marked sealed can’t act as a base class to any other class.
11. Since we cannot derive from sealed classes, the code from the sealed classes cannot be overridden.
12. We need to initialize the const variable at the time we create it. We are not allowed to initialize it later in our code or program.
13. Like classes, const variables cannot be circular, i.e., they cannot depend on each other.
14. A const field of a reference type other than string can only be initialized with null.
15. One can only initialize a const variable to a compile time value, i.e., a value available to the compiler while it is executing.
16. A constant by default is static and we can’t use the instance reference, i.e., a name to reference a const. Aconst has to be static as no one will be allowed to make any changes to a const variable.
17. A const variable cannot be marked as static.
18. A variable in C# can never have an uninitialized value.
19. Static variables are always initialized when the class is loaded first. An int is given a default value of zero and a bool is given a default of False.
20. An instance variable is always initialized at the time of creation of its instance.
21. A static readonly field cannot be assigned to (except in a static constructor or a variable initializer).

Conclusion

Keep coding and enjoy reading. 

Read more:

• C# and ASP.NET Questions (All in one)
• MVC Interview Questions
• C# and ASP.NET Interview Questions and Answers
• Web Services and Windows Services Interview Questions

Other Series

My other series of articles:

• Learning MVC
• Learning WebAPIs in .Net

For more informative articles visit my Blog.