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.
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
{
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
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
{
}
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()
{
}
}
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.
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.
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’
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()
{
}
}
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
{
}
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.
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
6 2 3
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
{
}
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);
}
}
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 );
} }
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.
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()
{
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
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.
Arrao4u 