The document discusses access modifiers in C# classes. It explains that by default, class members are private and can only be accessed within the class. The public modifier allows any code to access the member. The protected modifier allows access from derived classes only. The internal modifier allows access within the same assembly only. Access modifiers control the visibility and accessibility of classes, members, and nested types.

1. 8
Modifiers
Access Modifiers
Public, Private, Protected and Internal
Whenever a class is created by us we want to have the ability to decide who can access certain
members of the class. In other words, we would like to restrict access to the members of the class.
The basic rule is that members of a class can freely access each other. There is no way one can
prevent a function of a particular class from executing another function in the same class. By
default though, the same class is allowed complete access but no one else is granted access to the
members of the class. The default access modifier is private.
a.cs
class zzz
{
public static void Main()
{
yyy.pqr();
}
}
class yyy
{
static void abc()
{
System.Console.WriteLine(“yyy abc”);
}
public static void pqr()
{
System.Console.WriteLine(“yyy pqr”);
abc();
}
}
Output
yyy pqr
yyy abc
Pqr is public and hence anyone is allowed to execute it. abc has no access modifier which makes
it private, which is anyway the default. The private modifier has no effect on members of the
same class and hence pqr is allowed to call abc. This concept is called member access.

2. a.cs
class zzz
{
public static void Main()
{
yyy.abc();
}
}
class yyy
{
static void abc()
{
System.Console.WriteLine(“yyy abc”);
}
public static void pqr()
{
System.Console.WriteLine(“yyy pqr”);
abc(); } }
Compiler Error
a.cs(5,1): error CS0122: ‘yyy.abc()’ is inaccessible due to its protection level
abc is private an no one but members of yyy can access it.
a.cs
class zzz
{
public static void Main()
{
yyy.abc();
}
}
class yyy
{
protected static void abc()
{
System.Console.WriteLine(“yyy abc”);
}
public static void pqr()
{
System.Console.WriteLine(“yyy pqr”);
abc();
}}
Compiler Error
a.cs(5,1): error CS0122: ‘yyy.abc()’ is inaccessible due to its protection level
We have now introduced one more access modifier, protected, which also does not let you access
a class from outside. However pqr is allowed to access abc as access modifiers do not effect the
same class as mentioned earlier.
a.cs
class zzz

3. {
public static void Main()
{
xxx.aaa();
}
}
class yyy
{
static void abc()
{
System.Console.WriteLine(“yyy abc”);
}
public static void pqr()
{
System.Console.WriteLine(“yyy pqr”);
}
protected static void xyz()
{
System.Console.WriteLine(“yyy xyz”);
}
}
class xxx : yyy
{
public static void aaa()
{
abc();
pqr();
xyz();
}
}
Compiler Error
a.cs(27,1): error CS0122: ‘yyy.abc()’ is inaccessible due to its protection level
We are now dealing with derived classes. When we flag a function with the modifier, protected,
we are informing C# that only derived classes can access the function. Nobody else can. Thus in
function aaa we can call xyz as it is flagged protected, but it cannot be called from anywhere else
including Main. The function abc is private and can be called only from the class yyy. Comment
out abc(); in aaa and csc will show you no errors.
To sum up, we have learnt three concepts. Private means only the same class has access, public
means everyone has access and protected lies in between where only derived classes have access.
All functions for example reside in a class. The accessibility of that function is decided by the
class in which it resides as well as the modifiers on the function. If we are allowed access to a
member, we say that the member is accessible, else inaccessible.
b.cs
internal class yyy
{
}
csc /t:library b.cs

4. This command will produce a library b.dll with one class yyy.
a.cs
class zzz
{
public static void Main()
{
yyy a;
}
}
>csc a.cs /r:b.dll
Compiler Error
a.cs(5,1): error CS0122: ‘yyy’ is inaccessible due to its protection level
We get the above error as the modifier internal means that we can only access yyy from b.dll and
not from any other file or program. Never create a component and flag the class internal as no one
would be able to use it. Internal means access limited to this program only.
Also writing csc a.cs b.cs would not give us any error.
a.cs
public namespace vijay
{
class zzz
{
public static void Main()
{
}
}
}
Compiler Error
a.cs(1,8): error CS1518: Expected class, delegate, enum, interface, or struct
Namespaces by default can have no accessibility modifiers at all. They are public by default and
we cannot add any other access modifier including public again.
a.cs
private class zzz
{
}
Compiler Error
a.cs(1,1): error CS1527: Namespace elements cannot be explicitly declared as private or
protected
A class can only be public or internal. It cannot be marked as protected or private. The default is
internal.
b.cs
class yyy
{

5. }
csc b.cs /t:library
Compiler Error
fatal error CS2022: Options ‘/out’ and ‘/target’ must appear before source file names
Mistake, done on purpose. At times we will forget to tell you that some compiler options like /t
and /out must appear before the names of the source files.
>csc /t:library b.cs
a.cs
class zzz
{
public static void Main()
{
yyy a;
}
}
>csc a.cs /r:b.dll
Compiler Error
a.cs(5,1): error CS0122: ‘yyy’ is inaccessible due to its protection level
Thus if we want other programs/files to access classes created by us, we must not forget that by
default they are marked as internal as explained earlier.
Members of a class can have all the modifiers described above and default to private.
a.cs
class zzz
{
public static void Main()
{
}
public private void abc()
{
}
}
Compiler Error
a.cs(6,8): error CS0107: More than one protection modifier
You are not allowed more than one access modifier most of the time. The exceptions, we will
soon take care off. Predefined types like int, object have no accessibility restrictions. They can be
used anywhere and everywhere.
b.cs
class yyy
{
public void abc()

6. {
}
}
csc /t:library b.cs
a.cs
class zzz
{
public static void Main()
{
yyy a = new yyy();
a.abc();
}
}
Compiler Error
a.cs(5,1): error CS0122: 'yyy' is inaccessible due to its protection level
a.cs(6,1): error CS0246: The type or namespace name 'a' could not be found (are you
missing a using directive or an assembly reference?)
As the class yyy has not been specified by an access modifier, it is by default internal. Even
though abc is public, the type enclosing it i.e. yyy is internal and hence no member of yyy can be
accessed from outside b.cs. Thus the access modifiers of the class and the members is important.
b.cs
public class yyy
{
void abc()
{
}
}
>csc /t:library b.cs
a.cs
class zzz
{
public static void Main()
{
yyy a = new yyy();
a.abc();
}
}
Compiler Error
a.cs(6,1): error CS0122: ‘yyy.abc()’ is inaccessible due to its protection level
Here yyy is accessible as the modifier is public but the function abc is private and hence cannot
be accessed by anyone but the class.
From now on we will only display a.cs and b.cs as the command line executions of the compiler
will remain the same. a.cs remains the same for this program.

7. b.cs
public class yyy
{
internal void abc()
{
}
}
Compiler Error
a.cs(6,1): error CS0122: ‘yyy.abc()’ is inaccessible due to its protection level
Internal means no one from outside the dll can access the function.
a.cs
class zzz
{
public static void Main()
{
ppp a = new ppp();
a.aaa();
}
}
b.cs
public class yyy
{
protected internal void abc()
{
}
}
public class xxx : yyy
{
void pqr()
{
abc();
}
}
public class ppp
{
public void aaa()
{
yyy a = new yyy();
a.abc();
}
}
No error occurs as protected internal means two things. It is either derived classes or classes in
the same file that can access abc. Therefore derived class xxx can use it as well as class ppp.
What we are trying to get at here is that the containing type decides first the accessibility and then
the member modifiers also comes in. Making the class internal and then the members public will
in no way allow classes in others files access it.

8. a.cs
class zzz
{
public static void Main()
{
}
}
class yyy
{
protected int x;
void abc( yyy a , xxx b)
{
a.x = 1;
b.x = 2;
}
}
class xxx : yyy
{
void pqr( yyy a , xxx b)
{
a.x = 1;
b.x = 2;
}}
Compiler Error
a.cs(20,1): error CS1540: Cannot access protected member ‘yyy.x’ via a qualifier of type
‘yyy’; the qualifier must be of type ‘xxx’ (or derived from it)
Class yyy contains a protected member x. To the same class no modifiers make sense. However
as x is protected, in the derived class function pqr, we cannot access it through yyy as a.x gives us
an error. However b which looks like xxx does not give an error. To check this out, comment out
the line a.x=1 in pqr(). This means that we can access the protected members not from an object
of the base class, but from the derived class objects only. This is in spite of the fact that x is a
member of yyy, the base class. Even so, we still cannot access it. Also we cannot access x from
the function Main.
a.cs
class zzz
{
public static void Main()
{
}
}
class yyy
{
}
public class xxx : yyy
{
}
Compiler Error
a.cs(10,14): error CS0060: Inconsistent accessibility: base class ‘yyy’ is less accessible
than class ‘xxx’

9. Between internal and public, public allows greater access to its members. The class yyy is by
default internal and xxx which derives from yyy is explicitly made public. We get an error as the
derived class yyy has to have an access modifier which allows greater access than the base class
access modifier. Here internal is more restrictive than public.
a.cs
class zzz
{
public static void Main()
{
}
}
public class yyy
{
}
class xxx : yyy
{
}
If we reverse the modifiers, i.e. we make yyy public and xxx the derived class internal we get no
error. The base class allows more accessibility than the derived class.
a.cs
class zzz
{
public static void Main()
{
}
}
class yyy
{
}
public class xxx
{
public yyy f()
{
return new yyy();
}
}
Compiler Error
a.cs(12,12): error CS0050: Inconsistent accessibility: return type ‘yyy’ is less accessible
than method ‘xxx.f()’
The accessibility of yyy is internal which is more restrictive than public. The accessibility of
function f is public which is more than that of the type yyy. The error occurred as return values
must have greater accessibility than that of the method, which is not true in this case.
a.cs
class zzz
{
public static void Main()
{
}

10. }
class yyy
{
}
public class xxx
{
public yyy a;
}
Compiler Error
a.cs(12,12): error CS0052: Inconsistent accessibility: field type ‘yyy’ is less accessible
than field ‘xxx.a’
Rules are rules – they remain the same everywhere. The class yyy or data type yyy is internal. a,
an object/field is public which makes it more accessible than yyy which is internal. Hence the
error.
a.cs
class zzz
{
public static void Main()
{
}
}
class yyy
{
}
public class xxx
{
yyy a;
}
Now we get no error as a has been made private which gives it a lower accessibility than yyy
which is internal. Logic is that whatever you create must be more accessible than what you create
from.
Sealed Classes
Sealed is another modifier that applies to classes. aaa is a sealed class. No class can derive from
aaa. In another words aaa cannot act as a base class for any class.
a.cs
public class zzz
{
public static void Main()
{
}
}
sealed class aaa
{
}
class bbb : aaa

11. {
}
Compiler Error
a.cs(10,7): error CS0509: ‘bbb’ : cannot inherit from sealed class ‘aaa’
a.cs
public class zzz
{
public static void Main()
{
aaa a = new aaa();
System.Console.WriteLine(a.i);
a.abc();
}
}
sealed class aaa
{
public int i = 9;
public void abc()
{
System.Console.WriteLine(“hi”);
}
}
Output
9
hi
The only difference between a sealed class and a non-sealed class is that a sealed class cannot be
derived from. Otherwise there is no difference at all. It can contain the same variables, functions
etc as a normal class does . A sealed class lets us create classes which no one can derive from.
Thus the code in such classes cannot be overridden. Also as the compiler knows this, certain run
time optimizations can be performed on a sealed class
Constants
a.cs
public class zzz
{
const int i = 10;
public static void Main() {
System.Console.WriteLine(i);
}
}
Output
10
A constant or const variable behaves as a variable. We give it an initial value and can use it
wherever we can use a variable.

12. a.cs
public class zzz
{
const int i = 10;
public static void Main()
{
i++;
System.Console.WriteLine(i);
i = 30;
}
}
Compiler Error
a.cs(6,1): error CS0131: The left-hand side of an assignment must be a variable, property
or indexer
a.cs(8,1): error CS0131: The left-hand side of an assignment must be a variable, property
or indexer
Unlike a variable, we are not allowed to change the value of a const. The change is an assignment
statement.
a.cs
public class zzz
{
const int i ;
public static void Main()
{
i = 30;
System.Console.WriteLine(i);
}
}
Compiler Error
a.cs(3,13): error CS0145: A const field requires a value to be provided
We have to initialize the const variable at the time of creation. We are not allowed to initialize it
later in our program.
a.cs
public class zzz
{
const int i = j + 4;
const int j = k - 1;
const int k = 3;
public static void Main()
{
System.Console.WriteLine(“{0} {1} {2}”,i,j,k);
}
}
Output
623

13. A constant can depend upon another constant. C# is smart enough to realize that to calculate the
value of const i, it first needs to know the value of j. j’s value depends upon another const k,
whose value is 3. Thus C# first evaluates k to 3 then j becomes 2 i.e. k -1 and finally i takes on
the value of j i.e. 2 + 4 resulting in 6.
Like classes const’s cannot be circular i.e., they cannot depend upon each other.
a.cs
public class zzz
{
const int i = j + 4;
const int j = k - 1;
const int k = i;
public static void Main()
{
System.Console.WriteLine(“{0} {1} {2}”,i,j,k);
}
}
Compiler Error
a.cs(3,11): error CS0110: The evaluation of the constant value for ‘zzz.i’ involves a
circular definition
The value of the const i depends upon j which in turn depends upon k, which is equal to i. This
becomes a circular definition. A const is a variable whose value cannot be changed but whose
initial value is compile time determined.
a.cs
public class zzz
{
public const aa a = new aa();
public static void Main()
{
}
}
public class aa
{
}
Compiler Error
a.cs(3,17): error CS0133: The expression being assigned to ‘zzz.a’ must be constant
a.cs
public class zzz
{
public const aa a = null;
public static void Main()
{
}
}
public class aa
{
}

14. The error vanishes as we are now initializing a to an object which has a value that can be
determined at compile time. We cannot ever change the value of a, so it will always be null.
Normally we do not have consts as a reference type as they have value only at runtime.
As mentioned earlier we can only initialize a const to a compile time value i.e. a value available
to the compiler while it is executing. new unfortunately gets executed at runtime and therefore
has no value at compile time. This gives us an error.
a.cs
class zzz
{
public static void Main()
{
yyy y = new yyy();
System.Console.WriteLine(y.i);
}
}
class yyy {
public const int i = 3;
}
Compiler Error
a.cs(6,26): error CS0176: Static member 'yyy.i' cannot be accessed with an instance
reference; qualify it with a type name instead
A constant is static by default and we cannot use the instance reference i.e. a name to reference a
const. A const has to be static as no one is allowed to make any changes to a const.
a.cs
class zzz
{
public static void Main()
{
}
}
class yyy
{
public static const int i = 3;
}
Compiler Error
a.cs(9,25): error CS0504: The constant ‘yyy.i’ cannot be marked static
C# does not want us to repeat the obvious over and over again. Just like humans, programming
language too have their own quirks. Some other time, perhaps, C# may permit us to write a static
before an entity that is already static by default.
a.cs
class zzz
{
public static void Main()
{
System.Console.WriteLine(yyy.i + “ “ + xxx.i);

15. }
}
class yyy
{
public const int i = 3;
}
class xxx : yyy
{
public const int i = 30; }
Compiler Warning
a.cs(14,18): warning CS0108: The keyword new is required on ‘xxx.i’ because it hides
inherited member ‘yyy.i’
Output
3 30
We can create a const with the same name as another const in the base class. The const of the
class xxx i will hide the const i in class yyy for the class xxx only.
Fields
A field to start with is another word for a variable in a class. There are a large number of generic
rules that apply to all members of a class and we will not tire you by repeating them ad nauseam.
A variable can never have an uninitialized value in C#.
a.cs
public class zzz
{
static int i;
static bool j;
public static void Main()
{
System.Console.WriteLine(zzz.i + “ “ + zzz.j );
}}
Output
0 False
Static variables are initialized when the class is loaded first. An int is given an initial value of
zero and a bool False.
a.cs
public class zzz
{
int i;
bool j;
public static void Main()
{
zzz a = new zzz();
System.Console.WriteLine(a.i + “ “ + a.j );
}}

16. Output
0 False
An instance variable is initialized at the time of creation. The keyword new will create an
instance of the zzz. It will allocate memory for each of the non static variables and then initialize
each of them to their default values.
a.cs
public class zzz
{
static int i = j + 10;
static int j = i + 1;
public static void Main()
{
System.Console.WriteLine(zzz.i + “ “ + zzz.j );
}
}
Output
10 11
Outputs make a lot of sense if you understand them in plain simple English. C# always initializes
static fields to their initial value after creating them . Variables i and j are thus given a default of
zero. Then C# realizes that these variables need to be assigned some values. It does not read all
the lines, only one at a time. It will now read the first line and as the variable j has a value of 0, i
will get a value of 10. Then at the next line, j is the value of i plus 1. The variable i has a value of
10 and j now becomes 11. As it does not see both lines at the same time, it does not notice the
circularity of the above definition. In short, though the above example works, it is frowned upon
by the powers to be at C#.
a.cs
public class zzz
{
int i = j + 10;
int j = i + 1;
public static void Main()
{
}
}
Compiler Error
a.cs(3,9): error CS0236: A field initializer cannot reference the nonstatic field, method, or
property ‘zzz.j’
a.cs(4,9): error CS0236: A field initializer cannot reference the nonstatic field, method, or
property ‘zzz.i’
It does not work for instance variables as the rules of an instance variable are different than that
of static. The field initializer of an instance variable has to be determined at the time of creation
of the object. The variable j does not have a value at this point in time. It cannot refer to variables
of the same instance at the time of creation. Thus we can refer to no instance members to
initialize an instance member. Textual order means first come first served.

17. Readonly Fields
Fields can be also tagged with the modifier readonly.
a.cs
public class zzz
{
public static readonly int i = 10;
public static void Main()
{
System.Console.WriteLine(i);
}
}
Output
10
No errors at all. However, remember if we use a non static variable in a static function we will get
an error.
a.cs
public class zzz
{
public static readonly int i = 10;
public static void Main()
{
i = 20;
System.Console.WriteLine(i);
}
}
Compiler Error
a.cs(6,1): error CS0198: A static readonly field cannot be assigned to (except in a static
constructor or a variable initializer)
You cannot change the value of a readonly field after its being given an initial value.
a.cs
public class zzz {
public static readonly int i ;
public static void Main() {
}
}
Unlike a const, a readonly field does not have to be initialized at the time of creation.
a.cs
public class zzz
{
public static readonly int i ;
static zzz()
{

18. i = 20;
System.Console.WriteLine(“In Const”);
}
public static void Main()
{
System.Console.WriteLine(i);
}
}
Output
In Const
20
A static readonly field can be initialized in a static constructor also. This is the major difference
between a const and a readonly field.
a.cs
public class zzz
{
public readonly aa a = new aa();
public static void Main()
{
}
}
public class aa
{
}
The same example which gave an error with const does not give an error with readonly. To sum
up a readonly is a more generic const and it makes our programs more readable as we refer to a
name and not a number. Is 100 more intuitive or priceofcopper easier to understand? The
compiler would for reasons of efficiency convert all const’s and readonly variables to the actual
values.
a.cs
public class zzz
{
public static void Main()
{
}
}
public class aa
{
public int readonly i = 10;
}
Compiler Error
a.cs(9,12): error CS1585: Member modifier ‘readonly’ must precede the member type
and name
a.cs(9,23): error CS1519: Invalid token ‘=’ in class, struct, or interface member
declaration

19. Wherever you can place multiple modifiers, remind yourself that there are rules that decide the
order of modifiers, which comes first. Here the readonly modifier precedes the data type int. Once
again, no great cosmic law responsible, just a rule that must be remembered.
a.cs
public class zzz
{
public static void Main()
{
}
}
public class aa {
public readonly int i = 10;
void abc(ref int z)
{
}
void pqr()
{
abc(ref i);
}
}
Compiler Error
a.cs(13,9): error CS0192: A readonly field cannot be passed ref or out (except in a
constructor)
A readonly field cannot be changed by anyone except a constructor. The function abc
expects a ref parameter which if you have forgotten allows you to change the value of the
original. Thus C# does not permit a readonly as a parameter to a function that accepts a
ref or a out parameters.