Diving Into OOP (Day 5): All About Access Modifiers in C# (C# Modifiers/Sealed/Constants/Readonly Fields)

Introduction

Thanks to my readers for their tremendous support that motivated me to continue this OOP series further.

We have already covered nearly all the aspects of Inheritance and Polymorphism in C#. My article will highlight nearly all the aspects/scenarios of access modifiers in C#. We'll learn by doing a hands-on lab, not just by theory. We'll cover my favourite topic Constants in a very different manner by categorizing the sections in the form of “Labs”. My effort in this article will be to cover each and every concept to the related topic, so that at the end of the article we can confidently say that we understand “All about access modifiers in C#”. Just dive into OOP.

OOP
Image credit: Colocation centre

Prerequisites

I assume that my readers of this article have a very basic knowledge of C#. The reader need only know the definition of access modifiers. Last but not the least as I always wish that my readers should enjoy reading this article.

Roadmap


Let's recall our road map:

Roadmap

Access Modifiers


Let us take the definition from Wikipedia this time:

“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.”

Like the definition says, we can control the accessibility of our class methods and members through access modifiers, let us understand this in detail by taking every access modifier one by one.

Public, Private, Protected at class level

Whenever we create a class we always want to have the scope to decide who can access certain members of the class. In other words, we would sometimes need to restrict access to the class members. The one thumb rule is that members of a class can freely access each other. A method in one class can always access another method of the same class without any restrictions. When we talk about the default behavior, the same class is allowed complete access but no else is provided access to the members of the class. The default access modifier is private for class members.

Point to remember: The default access modifier is private for class members.

Let's do a hands-on lab. Just open your Visual Studio and add a console application in C# named AccessModifiers, you'll get a Program class file by default. In the same file add a new class named Modifiers and add the following code to it:

  1. using System;  
  2.   
  3. namespace AccessModifiers  
  4. {  
  5.     class Modifiers  
  6.     {  
  7.         static void AAA()  
  8.         {  
  9.             Console.WriteLine("Modifiers AAA");  
  10.         }  
  11.   
  12.         public static void BBB()  
  13.         {  
  14.             Console.WriteLine("Modifiers BBB");  
  15.             AAA();  
  16.         }  
  17.     }  
  18.   
  19.      class Program  
  20.     {  
  21.         static void Main(string[] args)  
  22.         {  
  23.             Modifiers.BBB();  
  24.         }  
  25.     }   

So, your Program.cs file becomes like as shown in the code snippet above. We added a class Modifiers and two static methods AAA and BBB. Method BBB is marked as public. We call the method BBB from the Main method.The method is called directly by the class name because it is marked static.

When we run the application, we get the output as follows:

Output

Modifiers BBB
Modifiers AAA

BBB is marked public and so anyone is allowed to call and run it. Method AAA is not marked with any access modifier that automatically makes it private, that is the default. The private modifier has no effect on members of the same class and so method BBB is allowed to call method AAA. Now this concept is called member access.

Modify the Program class and try to access AAA as:

  1. class Program  
  2. {  
  3.     static void Main(string[] args)  
  4.     {  
  5.         Modifiers.AAA();  
  6.         Console.ReadKey();  
  7.     }  

Output

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

So, since the method AAA is private therefore no one else can have access to it except Modifiers class.

Now mark the AAA method as protected, our class looks as in the following.

Modifiers

  1. class Modifiers  
  2. {  
  3.     protected static void AAA()  
  4.     {  
  5.        Console.WriteLine("Modifiers AAA");  
  6.     }  
  7.   
  8.     public static void BBB()  
  9.     {  
  10.         Console.WriteLine("Modifiers BBB");  
  11.         AAA();  
  12.     }  
  13.  } 

Program

  1. class Program  
  2. {  
  3.     static void Main(string[] args)  
  4.     {  
  5.         Modifiers.AAA();  
  6.         Console.ReadKey();  
  7.     }  

Output

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

Again the same output. We cannot access the method AAA even after we introduced a new modifier named protected. But BBB can access the AAA method because it lies in the same class.

Modifiers in Inheritance

Let's add one more class and make a relation of base and derived class to our existing class and add one more method to our base class. So our class structure will look something like the following.

Modifiers Base Class

  1. class ModifiersBase  
  2. {  
  3.     static void AAA()  
  4.     {  
  5.         Console.WriteLine("ModifiersBase AAA");  
  6.     }  
  7.     public static void BBB()  
  8.     {  
  9.        Console.WriteLine("ModifiersBase BBB");  
  10.     }  
  11.     protected static void CCC()  
  12.     {  
  13.         Console.WriteLine("ModifiersBase CCC");  
  14.     }  

Modifiers Derive Class

  1. class ModifiersDerived:ModifiersBase  
  2. {  
  3.    public static void XXX()  
  4.    {  
  5.        AAA();  
  6.        BBB();  
  7.        CCC();  
  8.    }  

Program Class

  1. class Program  
  2. {  
  3.     static void Main(string[] args)  
  4.      {  
  5.          ModifiersDerived.XXX();  
  6.          Console.ReadKey();  
  7.       }  

Output

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

Now in this case we are dealing with a derived class. Whenever we mark a method with the specifier, protected, we are actually telling C# that only derived classes can access that method and no one else can. Therefore in the method XXX we can call CCC because it is marked protected, but it cannot be called from anywhere else including the Main function. The method AAA is made private and can be called only from the class ModifiersBase. If we remove AAA from method XXX, the compiler will give no error.

Therefore now we are aware of three important concepts. Private means only the same class has access to the members, public means everybody has access and protected lies in between where only derived classes have access to the base class method.

All the methods for example reside in a class. The accessibility of that method is decided by the class in which it resides as well as the modifiers on the method. If we are allowed an access to a member, then we say that the member is accessible, else it is inaccessible.

Internal modifier at class level

Let's take one other scenario. Create a class library with a name “AccessModifiersLibrary” in your Visual Studio. Add a class named ClassA in that class library and mark the class as internal, the code will be as shown below.

AccessModifiersLibrary.ClassA

  1. namespace AccessModifiersLibrary  
  2. {  
  3.     internal class ClassA  
  4.     {  
  5.     }  

Now compile the class and leave it. Its DLL will be generated in the ~\AccessModifiersLibrary\bin\Debug folder.

Now in your console application “AccessModifiers” was created earlier. Add the reference of the AccessModifiersLibrary library by adding its compiled DLL as a reference to AccessModifiers.

In Program.cs of the AccessModifiers console application, modify the Program class like shown below.

AccessModifiers.Program

  1. using AccessModifiersLibrary;  
  2.   
  3. namespace AccessModifiers  
  4. {  
  5.     class Program  
  6.     {  
  7.         static void Main(string[] args)  
  8.         {  
  9.             ClassA classA;  
  10.         }  
  11.     }  
  12.   

And compile the code.

Output

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

We encountered this error because the access specifier internal means that we can only access ClassA from AccessModifiersLibrary.dll and not from any other file or code. An internal modifier means that access is limited to the current program only. So try never to create a component and mark the class internal as no one would be able to use it.

And what if we remove the field internal from ClassA, will the code compile? As in the following.

AccessModifiersLibrary.ClassA

  1. namespace AccessModifiersLibrary  
  2. {  
  3.     class ClassA  
  4.     {  
  5.     }  

AccessModifiers.Program

  1. using AccessModifiersLibrary;  
  2.   
  3. namespace AccessModifiers  
  4. {  
  5.     class Program  
  6.     {  
  7.         static void Main(string[] args)  
  8.         {  
  9.             ClassA classA;  
  10.         }  
  11.     }   

Output

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

We again got the same error. We should not forget that by default if no modifier is specified, the class is internal. So our class ClassA is internal by default even if we do not mark it with any access modifier, so the compiler result remains the same.

Had the class ClassA been marked public, everything would have gone smoothly without any error.

Point to remember:
A class marked as internal can only have its access limited to the current assembly only.

Namespaces with modifiers

Just for fun, let's mark the namespace of the AccessModifiers class library as public in the Program class.

Program

  1. public namespace AccessModifiers  
  2. {  
  3.     class Program  
  4.     {  
  5.         static void Main(string[] args)  
  6.         {  
  7.              
  8.         }  
  9.     }  

Compile the application.

Output

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

Point to remember: 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.

Private Class

Let's do one more experiment and mark the class Program as private, so our code becomes:

  1. namespace AccessModifiers  
  2. {  
  3.     private class Program  
  4.     {  
  5.         static void Main(string[] args)  
  6.         {  
  7.              
  8.         }  
  9.     }  

Compile the code.

Output

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

So, point to remember: A class can only be public or internal. It cannot be marked as protected or private. The default is internal for the class.

Access modifiers for the members of the class

Now here is a big statement, that the members of a class can have all the preceding explained access modifiers, but the default modifier is private.

Point to remember: Members of a class can be marked with all the access modifiers and the default access modifier is private.

What if we want to mark a method with two access modifiers?

  1. namespace AccessModifiers  
  2. {  
  3.     public class Program  
  4.     {  
  5.         static void Main(string[] args)  
  6.         {  
  7.         }   
  8.         public private void Method1()  
  9.         {               
  10.         }  
  11.     }  

Compile the code.

Output


Compile time error: More than one protection modifier

Therefore we can't mark a member with more than one access modifier often. But there are such scenarios too, we'll cover them in the next sections. Already defined types like int and object have no accessibility restrictions. They can be used anywhere and everywhere.

Internal class and public method

Create a class library with a class named ClassA marked internal and have a public method MethodClassA(), as in the following:

  1. namespace AccessModifiersLibrary  
  2. {  
  3.     internal class ClassA  
  4.     {  
  5.         public void MethodClassA(){}  
  6.     }  

Add the reference of class library to our console application. Now in Program.cs of the console application, try to access that method MethodClassA of ClassA.

Program

  1. using AccessModifiersLibrary;  
  2.   
  3.  namespace AccessModifiers  
  4. {  
  5.     public class Program  
  6.     {  
  7.         public static void Main(string[] args)  
  8.         {  
  9.             ClassA classA = new ClassA();  
  10.             classA.MethodClassA();  
  11.         }   
  12.     }  

Output

Compile time errors

'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?)

So many errors. The errors are self-explanatory though. Even the method MethodClassA of ClassA is public, it could not be accessed in the Program class due to the protection level of ClassA, in other words internal. The type enclosing the method MethodClassA is internal, so no matter if the method is marked public, we cannot access it in any other assembly.

Public class and private method.

Let's make the class ClassA as public and method as private.

AccessModifiersLibrary.ClassA

  1. namespace AccessModifiersLibrary  
  2. {  
  3.     public class ClassA  
  4.     {  
  5.         private void MethodClassA(){}  
  6.     }  

Program

  1. using AccessModifiersLibrary;  
  2.   
  3.  namespace AccessModifiers  
  4. {  
  5.     public class Program  
  6.     {  
  7.         public static void Main(string[] args)  
  8.         {  
  9.             ClassA classA = new ClassA();  
  10.             classA.MethodClassA();  
  11.         }            
  12.     }  

Output on compilation

'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?)

Now that we have marked our class Public, we still can't access the private method. So for accessing a member of the class, the access modifier of the class as well as the method is very important.

Public class and internal method

Make ClassA as public and MethodClassA as internal.

AccessModifiersLibrary.ClassA

  1. namespace AccessModifiersLibrary  
  2. {  
  3.     public class ClassA  
  4.     {  
  5.         Internal void MethodClassA(){}  
  6.     }  

Program

  1. using AccessModifiersLibrary;  
  2.   
  3.  namespace AccessModifiers  
  4. {  
  5.     public class Program  
  6.     {  
  7.         public static void Main(string[] args)  
  8.         {  
  9.             ClassA classA = new ClassA();  
  10.             classA.MethodClassA();  
  11.         }            
  12.     }  

Output on compilation

'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?)

So an internal marked member means that no one from outside that DLL can access the member.

Protected internal

In the class library make three classes ClassA, ClassB and ClassC and place the code somewhat like this.

  1. namespace AccessModifiersLibrary  
  2. {  
  3.     public class ClassA  
  4.     {  
  5.         protected internal void MethodClassA()  
  6.         {  
  7.   
  8.         }  
  9.     }  
  10.   
  11.     public class ClassB:ClassA  
  12.     {  
  13.         protected internal void MethodClassB()  
  14.         {  
  15.             MethodClassA();  
  16.         }  
  17.     }  
  18.   
  19.     public class ClassC  
  20.     {  
  21.         public void MethodClassC()  
  22.         {  
  23.             ClassA classA=new ClassA();  
  24.             classA.MethodClassA();  
  25.         }  
  26.     }  

And in Program class in our console application, call the MethodClassC of ClassC.

Program

  1. using AccessModifiersLibrary;  
  2.   
  3.  namespace AccessModifiers  
  4. {  
  5.     public class Program  
  6.     {  
  7.         public static void Main(string[] args)  
  8.         {  
  9.             ClassC classC=new ClassC();  
  10.             classC.MethodClassC();  
  11.         }  
  12.     }  

Compiler output: The code successfully compiles with no error.

Protected internal modifier indicates two things, that either the derived class or the class in the same file can have access to that method, therefore in the above mentioned scenario, the derived class ClassB and the class in the same file, in other words ClassC, can access that method of ClassA marked as protected internal.

Point to remember: Protected internal means that the derived class and the class within the same source code file can have access.

Protected member

In our Program.cs in the console application, place the following code:

  1. namespace AccessModifiers  
  2. {  
  3.     class AAA  
  4.     {  
  5.         protected int a;  
  6.         void MethodAAA(AAA aaa,BBB bbb)  
  7.         {  
  8.             aaa.a = 100;  
  9.             bbb.a = 200;  
  10.         }  
  11.     }  
  12.      class BBB:AAA  
  13.      {  
  14.          void MethodBBB(AAA aaa, BBB bbb)  
  15.          {  
  16.              aaa.a = 100;  
  17.              bbb.a = 200;  
  18.          }  
  19.      }  
  20.     public class Program  
  21.     {  
  22.         public static void Main(string[] args)  
  23.         {  
  24.         }  
  25.     }  

Compiler Output

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)

Class AAA contains a protected member, in other words a. But to the same class no modifiers make sense. However as a is protected, in the derived class method MethodBBB, we cannot access it through AAA since aaa.a gives us an error. However bbb which looks like BBB does not give an error. To check this out, comment out the line aaa.a=100 in MethodBBB (). This means that we cannot access the protected members from an object of the base class, but from the objects of a derived class only. This is in spite of the fact that a is a member of AAA, in other words the base class. Even so, we still cannot access it. We also cannot access a from the method Main.

Accessibility Priority in inheritance

Program

  1. namespace AccessModifiers  
  2. {  
  3.     class AAA  
  4.     {  
  5.          
  6.     }  
  7.     public class BBB:AAA  
  8.      {  
  9.          
  10.      }  
  11.     public class Program  
  12.     {  
  13.         public static void Main(string[] args)  
  14.         {  
  15.         }  
  16.     }  

Compiler Output

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

The error again gives us one more point to remember.

Point to remember: between public and internal, public always allows greater access to its members.

The class AAA is by default marked internal and BBB that derives from AAA is made public explicitly. We got an error since the derived class BBB must have an access modifier that allows greater access than the base class access modifier. Here internal seems to be more restrictive than public.

But if we reverse the modifiers to both the classes in other words ClassA marked as public and ClassB internal or default, we eliminate the error.

Point to remember: The base class always allows more accessibility than the derived class.

Another scenario.

Program

  1. namespace AccessModifiers  
  2.   
  3.    class AAA  
  4.    {  
  5.         
  6.    }  
  7.    public class BBB  
  8.     {  
  9.        public AAA MethodB()  
  10.        {  
  11.            AAA aaa= new AAA();  
  12.            return aaa;  
  13.        }  
  14.     }  
  15.    public class Program  
  16.    {  
  17.        public static void Main(string[] args)  
  18.        {  
  19.        }  
  20.    } 

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

Here the accessibility of AAA is internal that is more restrictive than public. The accessibility of method MethodB is public that is more than that of the typeAAA. Now the error occurred because return values of a method must have greater accessibility than that of the method itself, which is not true in this case.

Point to remember: The return values of a method must have greater accessibility than that of the method itself.

Program

  1. namespace AccessModifiers  
  2. {  
  3.     class AAA  
  4.     {  
  5.          
  6.     }     
  7.     public class BBB  
  8.     {  
  9.         public AAA aaa;  
  10.     }  
  11.     public class Program  
  12.     {  
  13.         public static void Main(string[] args)  
  14.         {  
  15.         }  
  16.     }  

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

AccessModifiers
Image credit: moyamoyya.deviantart

Now the rules are the same for everyone. The class AAA or data type aaa is internal. The aaa field is public and that makes it more accessible than AAA that is internal. So we got the error.

Change the code to:
  1. namespace AccessModifiers  
  2. {  
  3.     class AAA  
  4.     {  
  5.          
  6.     }  
  7.     public class BBB  
  8.     {  
  9.          AAA a;  
  10.     }  
  11.     public class Program  
  12.     {  
  13.         public static void Main(string[] args)  
  14.         {  
  15.         }  
  16.     }  

The output compilation results in no error.

We learned a lot about these access modifiers like, public, private, protected, internal and protected internal. We also learned about their priority of access and usage, let's summarize their details in a tabular format for revision. Later we'll move to other types as well.

Tables taken from: msdn

Declared accessibility Meaning
public Access is not restricted.
protected

Access is limited to the containing class or types derived from the containing class.

internal Access is limited to the current assembly.
protected  internal Access is limited to the current assembly or types derived from the containing class.
private Access is limited to the containing type.

“Only one access modifier is allowed for a member or type, except when you use the protected internal combination.

Access modifiers are not allowed on namespaces. Namespaces have no access restrictions.

Depending on the context in which a member declaration occurs, only certain declared accessibilities are permitted. If no access modifier is specified in a member declaration, a default accessibility is used.

Top-level types, that are not nested in other types, can only have internal or public accessibility. The default accessibility for these types is internal.
Nested types, that are members of other types, can have declared accessibilities as indicated in the following table.”

Members of Default member accessibility Allowed declared accessibility of the member
enum Public None
class Private public
protected
internal
private
protected  internal
interface Public None
struct Private public
internal
private

Sealed Classes

“Sealed” is a special class of access modifier in C#. If a class is marked as sealed, no other class can derive from that sealed class . In other words a class marked as sealed can't act as a base class to any other class.

Program

  1. namespace AccessModifiers  
  2. {  
  3.     sealed class AAA  
  4.     {  
  5.          
  6.     }  
  7.     class BBB:AAA  
  8.     {  
  9.            
  10.     }  
  11.     public class Program  
  12.     {  
  13.         public static void Main(string[] args)  
  14.         {  
  15.         }  
  16.     }  

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

Hence proved.

Point to remember: A class marked sealed can't act as a base class for any other class.

sealed
Image credit: Flickr

Access the members of the sealed class.

Program

  1. using System;  
  2.   
  3. namespace AccessModifiers  
  4. {  
  5.     sealed class AAA  
  6.     {  
  7.         public int x = 100;  
  8.         public void MethodA()  
  9.         {  
  10.             Console.WriteLine("Method A in sealed class");  
  11.         }  
  12.   
  13.     }  
  14.     public class Program  
  15.     {  
  16.         public static void Main(string[] args)  
  17.         {  
  18.             AAA aaa=new AAA();  
  19.             Console.WriteLine(aaa.x);  
  20.             aaa.MethodA();  
  21.             Console.ReadKey();  
  22.         }  
  23.     }  

Compiler Output

100

Method A in sealed class

So, as we discussed, the only difference between a sealed and a non-sealed class is that the sealed class cannot be derived from. A sealed class can contain variables, methods and properties like a normal class does.

Point to remember: Since we cannot derive from sealed classes, the code from the sealed classes cannot be overridden.

Constants

Lab 1

Our Program class in the console application is as follows.

Program

  1. public class Program  
  2.  {  
  3.      private const int x = 100;  
  4.      public static void Main(string[] args)  
  5.      {  
  6.          Console.WriteLine(x);  
  7.          Console.ReadKey();  
  8.      }  
  9.  } 

Output: 100

We see, a constant maked variable or a const variable behaves like a member variable in C#. We can provide it an initial value and can use it anywhere we want.

Point to remember: 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.

Lab 2

  1.  using System;  
  2.   
  3. namespace AccessModifiers  
  4. {  
  5.     public class Program  
  6.     {  
  7.         private const int x = y + 100;  
  8.         private const int y = z - 10;  
  9.         private const int z = 300;  
  10.   
  11.         public static void Main(string[] args)  
  12.         {  
  13.            System.Console.WriteLine("{0} {1} {2}",x,y,z);  
  14.             Console.ReadKey();  
  15.         }  
  16.     }  

Can you guess the output? What ? Is it a compiler error?

Output

390 290 300
Output

Shocked? A constant field can no doubt depend upon another constant. C# is very smart to realize that to calculate the value of variable x marked const, it first needs to know the value of y variable. y's value depends upon another const variable z, whose value is set to 300. Thus C# first evaluates z to 300 then y becomes 290, in other words z -1 and finally x takes on the value of y, in other words 290 + 100 resulting in 390.

Lab 3

Program

  1. using System;  
  2.   
  3. namespace AccessModifiers  
  4. {  
  5.     public class Program  
  6.     {  
  7.         private const int x = y + 100;  
  8.         private const int y = z - 10;  
  9.         private const int z = x;  
  10.   
  11.         public static void Main(string[] args)  
  12.         {  
  13.            System.Console.WriteLine("{0} {1} {2}",x,y,z);  
  14.             Console.ReadKey();  
  15.         }  
  16.     }  

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

We just assigned z=x from our previous code and it resulted in an error. The value of const x depends upon y  and y in turn depends upon the value of z, but we see the value z depends upon x since x is assigned directly to z, it results in a circular dependency.

Point to remember: Like classes const variables cannot be circular, in other words they cannot depend on each other.

Lab 4

A const is a variable whose value once assigned cannot be modified, but its value is determined at compile time only.

  1.  using System;  
  2.   
  3. namespace AccessModifiers  
  4. {  
  5.     public class Program  
  6.     {  
  7.         public const ClassA classA=new ClassA();  
  8.         public static void Main(string[] args)  
  9.         {  
  10.         }  
  11.     }  
  12.   
  13.    public class ClassA  
  14.     {  
  15.           
  16.     }  

Output

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.

Point to remember: A const field of a reference type other than string can only be initialized with null.

If we assign the value to null in the Program class as in the following:

  1. using System;  
  2.   
  3. namespace AccessModifiers  
  4. {  
  5.     public class Program  
  6.     {  
  7.         public const ClassA classA=null;  
  8.         public static void Main(string[] args)  
  9.         {  
  10.         }  
  11.    }   
  12.    public class ClassA  
  13.     {  
  14.           
  15.     }  

Then the error will vanish. The error disappears since we now initialize classA to an object that has a value that can be determined at compile time, null. We can never change the value of classA, so it will always be null. Normally we do not have consts as a classA reference type since they have a value only at runtime.

Point to remember: One can only initialize a const variable to a compile-time value, in other words a value available to the compiler while it is executing.

new() actually gets executed at runtime and therefore does not get a value at compile time. So this results in an error.

Lab 5

Class A

  1. public class ClassA  
  2. {  
  3.      public const int aaa = 10;  

Program

  1. public class Program  
  2. {  
  3.     public static void Main(string[] args)  
  4.     {  
  5.         ClassA classA=new ClassA();  
  6.         Console.WriteLine(classA.aaa);  
  7.         Console.ReadKey();  
  8.     }  

Output

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

Point to remember: A constant by default is static and we can't use the instance reference, in other words a name to reference a const. A const must be static since no one will be allowed to make any changes to a const variable.

Just mark the const as static.

  1. using System;  
  2.   
  3. namespace AccessModifiers  
  4. {  
  5.     public class ClassA  
  6.     {  
  7.         public static const int aaa = 10;  
  8.     }  
  9.   
  10.     public class Program  
  11.     {  
  12.         public static void Main(string[] args)  
  13.         {  
  14.             ClassA classA=new ClassA();  
  15.             Console.WriteLine(classA.aaa);  
  16.             Console.ReadKey();  
  17.         }  
  18.     }       

Output

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

C# tells us frankly that a field already static by default cannot be marked as static.

Point to remember: A const variable cannot be marked as static.

Lab 6

  1. using System;  
  2.   
  3. namespace AccessModifiers  
  4. {  
  5.     public class ClassA  
  6.     {  
  7.         public const int xxx = 10;  
  8.     }  
  9.   
  10.     public class ClassB:ClassA  
  11.     {  
  12.         public const int xxx = 100;  
  13.     }  
  14.   
  15.     public class Program  
  16.     {  
  17.         public static void Main(string[] args)  
  18.         {  
  19.             Console.WriteLine(ClassA.xxx);  
  20.             Console.WriteLine(ClassB.xxx);  
  21.             Console.ReadKey();  
  22.         }  
  23.     }       

Output

10
100

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

We can always create a const with the same name in the derived class as another const in the base class. The const variable of class ClassB xxx will hide the const xxx in class ClassA for the class ClassB only.

Static Fields

Point to remember: A variable in C# can never have an uninitialized value.

Let's discuss this in detail.

Lab 1

Program

  1. using System;  
  2.   
  3. namespace AccessModifiers  
  4. {  
  5.     public class Program  
  6.     {  
  7.         private static int x;  
  8.         private static Boolean y;   
  9.         public static void Main(string[] args)  
  10.         {  
  11.             Console.WriteLine(x);  
  12.             Console.WriteLine(y);  
  13.             Console.ReadKey();  
  14.         }  
  15.     }    

Output

0
False

Point to remember: 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 to False.

Lab 2


Program

  1. using System;  
  2.   
  3. namespace AccessModifiers  
  4. {  
  5.     public class Program  
  6.     {  
  7.         private  int x;  
  8.         private  Boolean y;   
  9.         public static void Main(string[] args)  
  10.         {  
  11.             Program program=new Program();  
  12.             Console.WriteLine(program.x);  
  13.             Console.WriteLine(program.y);  
  14.             Console.ReadKey();  
  15.         }  
  16.     }       

Output

0
False

Point to remember:
An instance variable is always initialized at the time of creation of its instance.

An instance variable is always initialized at the time of creation of its instance. The keyword new will create an instance of the class Program. It will allocate memory for each of the non-static, in other words instance variables, and then initialize each of them to their default values as well.

Lab 3

Program

  1. using System;  
  2.   
  3. namespace AccessModifiers  
  4. {  
  5.     public class Program  
  6.     {  
  7.         private static int x = y + 10;  
  8.         private static int y = x + 5;   
  9.         public static void Main(string[] args)  
  10.         {  
  11.             Console.WriteLine(Program.x);  
  12.             Console.WriteLine(Program.y);  
  13.             Console.ReadKey();  
  14.         }  
  15.     }       

Output

10
15

The output is self explanatory. C# always initializes static variables to their initial value after creating them. Variables x and y are therefore given a default of zero value. C# now realizes that these variables declared need to be assigned some values. C# does not read all the lines at once but only one at a time. It will now read the first line and since the variable y has a value of 0, x will get a value of 10. Then at the next line, y is the value of x + 5. The variable x has a value of 10 and so y now becomes 15. Since C# does not see both lines at the same time, it does not notice the circularity of the preceding definition.

Lab 4

Program

  1. using System;  
  2.   
  3. namespace AccessModifiers  
  4. {  
  5.     public class Program  
  6.     {  
  7.          int x = y + 10;  
  8.          int y = x + 5;   
  9.         public static void Main(string[] args)  
  10.         {  
  11.              
  12.         }  
  13.     }       

Output

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'

The lab we did in Lab 3 does not work for instance variables since the rules of an instance variable are quite different than that of static variables. The initializer of an instance variable must be determined at the time of creation of the instance. The variable y does not have a value at this point in time. It can't refer to variables of the same object at the time of creation. So we can refer to no instance members to initialize an instance member.

Readonly Fields

Readonly fields are one of the most interesting topics of OOP in C#.

Lab 1

Program

  1. using System;  
  2.   
  3. namespace AccessModifiers  
  4. {  
  5.     public class Program  
  6.     {  
  7.         public static readonly int x = 100;  
  8.   
  9.         public static void Main(string[] args)  
  10.         {  
  11.             Console.WriteLine(x);  
  12.             Console.ReadKey();  
  13.         }  
  14.     }  

Output

100

Wow, we get no error, but remember not to use a non-static variable inside a static method else we'll get an error.

Lab 2

Program

  1. using System;  
  2.   
  3. namespace AccessModifiers  
  4. {  
  5.     public class Program  
  6.     {  
  7.         public static readonly int x = 100;  
  8.   
  9.         public static void Main(string[] args)  
  10.         {  
  11.             x = 200;  
  12.             Console.WriteLine(x);  
  13.             Console.ReadKey();  
  14.         }  
  15.     }     

Output

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

We cannot change the value of a readonly field except in a constructor.

Point to remember: A static readonly field cannot be assigned to (except in a static constructor or a variable initializer)

Lab 3

Program

  1. using System;  
  2.   
  3. namespace AccessModifiers  
  4. {  
  5.     public class Program  
  6.     {  
  7.         public static readonly int x;  
  8.   
  9.         public static void Main(string[] args)  
  10.         {  
  11.         }  
  12.     }  

Here we find one difference between const and readonly, unlike const, readonly fields need not need to be initialized at the time of creation.

Lab 4

Program

  1. using System;  
  2.   
  3. namespace AccessModifiers  
  4. {  
  5.     public class Program  
  6.     {  
  7.         public static readonly int x;  
  8.   
  9.         static Program()  
  10.         {  
  11.             x = 100;  
  12.             Console.WriteLine("Inside Constructor");  
  13.         }  
  14.   
  15.         public static void Main(string[] args)  
  16.         {  
  17.             Console.WriteLine(x);  
  18.             Console.ReadKey();  
  19.         }  
  20.     }  

Output

Inside Constructor
100

One more major difference between const and readonly is seen here. A static readonly variable can be initialized in the constructor as well, like we saw in the above mentioned example.

Lab 5

Program

  1. using System;  
  2.   
  3. namespace AccessModifiers  
  4. {  
  5.     public class ClassA  
  6.     {           
  7.     }  
  8.     public class Program  
  9.     {         
  10.         public readonly ClassA classA=new ClassA();  
  11.         public static void Main(string[] args)  
  12.         {  
  13.         }  
  14.     }  

We have already seen this example in the const section. The same code gave an error with const does not give an error with readonly fields. So we can say that readonly is a more generic const and it makes our programs more readable as we refer to a name and not a number. Is 10 more intuitive or priceofcookie easier to understand? The compiler would for efficiency convert all const's and readonly fields to the actual values.

Lab 6

Program

  1. using System;  
  2.   
  3. namespace AccessModifiers  
  4. {  
  5.     public class ClassA  
  6.     {  
  7.         public int readonly x= 100;  
  8.     }  
  9.     public class Program  
  10.     {  
  11.       public static void Main(string[] args)  
  12.         {  
  13.         }  
  14.     }  

Output

Compile time error

Member modifier 'readonly' must precede the member type and name

Invalid token '=' in class, struct, or interface member declaration

Wherever we need to place multiple modifiers, remind yourself that there are rules that decide the order of access modifiers, that comes first. Now here the readonly modifier precedes the data type int, we already discussed in the very start of the article. This is just a rule that must always be remembered.

Lab 7

Program

  1. using System;  
  2.   
  3. namespace AccessModifiers  
  4. {  
  5.     public class ClassA  
  6.     {  
  7.         public readonly int x= 100;  
  8.   
  9.         void Method1(ref int y)  
  10.         {  
  11.               
  12.         }  
  13.   
  14.         void Method2()  
  15.         {  
  16.             Method1(ref x);  
  17.         }  
  18.     }  
  19.     public class Program  
  20.     {  
  21.         
  22.         public static void Main(string[] args)  
  23.         {  
  24.         }  
  25.     }  

Output

Compile time error

A readonly field cannot be ed 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 that 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

Let's recall all the points that we must remember.

  1. The default access modifier is private for class members.
  2. A class marked as internal can only 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 is internal 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, in other words 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, in other words 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, in other words a name to reference a const. A const must be static since 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

With this article we completed nearly all the scenarios of access modifiers. We did many hands-on labs to clarify the concepts. I hope my readers now know by heart about these basic concepts and will never forget them. In my future article, in other words the last article of this series, we'll be discussing Properties and Indexers in C#.

Keep coding and enjoy reading

Conclusion

Also do not forget to rate/comment/like my article if it helped you by any means, this helps me to get motivated and encourages me to write more and more.

Read more

For more technical articles you can reach out to CodeTeddy

My other series of articles,

Happy coding !