C# Interview Questions on Constants
What are constants in C#?
Constants in C# are immutable values which
are known at compile time and do not change for the life of the program.
Constants are declared using the const keyword. Constants must be initialized
as they are declared. You cannot assign a value to a constant after it
isdeclared. An example is shown below.
using System;
class Circle
{
public const double PI = 3.14;
public Circle()
{
//Error : You can only assign a value to a constant field at the time of
declaration
//PI = 3.15;
}
}
class MainClass
{
public static void Main()
{
Console.WriteLine(Circle.PI);
}
}
Can you declare a class or a struct as
constant?
No, User-defined types including classes,
structs, and arrays, cannot be const. Only the C# built-in types excluding
System.Object may be declared as const. Use the readonly modifier to create a
class, struct, or array that is initialized one time at runtime (for example in
a constructor) and thereafter cannot be changed.
Does C# support const methods, properties,
or events?
No, C# does not support const methods,
properties, or events.
Can you change the value of a constant
filed after its declaration?
No, you cannot change the value of a
constant filed after its declaration. In the example below, the constant field
PI is always 3.14, and it cannot be changed even by the class itself. In fact,
when the compiler encounters a constant identifier in C# source code (for
example, PI), it substitutes the literal value directly into the intermediate
language (IL) code that it produces. Because there is no variable address
associated with a constant at run time, const fields cannot be passed by
reference.
using System;
class Circle
{
public const double PI = 3.14;
}
How do you access a constant field declared
in a class?
Constants are accessed as if they were
static fields because the value of the constant is the same for all instances
of the type. You do not use the static keyword to declare them. Expressions
that are not in the class that defines the constant must use the class name, a
period, and the name of the constant to access the constant. In the example
below constant field PI can be accessed in the Main method using the class name
and not the instance of the class. Trying to access a constant field using a
class instance will generate a compile time error.
using System;
class Circle
{
public const double PI = 3.14;
}
class MainClass
{
public static void Main()
{
Console.WriteLine(Circle.PI);
Circle C = new Circle();
// Error : PI cannot be accessed using an instance
// Console.WriteLine(C.PI);
}
}
--------------
C# Interview Questions on Fields
What are the 2 broad classifications of
fields in C#?
1. Instance fields
2. Static fields
What are instance fields in C#?
Instance fields are specific to an instance
of a type. If you have a class T, with an instance field F, you can create two
objects of type T, and modify the value of F in each object without affecting
the value in the other object.
What is a static field?
A static field belongs to the class itself,
and is shared among all instances of that class. Changes made from instance A
will be visible immediately to instances B and C if they access the field.
Will the following code compile?
using System;
class Area
{
public static double PI = 3.14;
}
class MainClass
{
public static void Main()
{
Area A = new Area();
Console.WriteLine(A.PI);
}
}
No, a compile time error will be generated
stating "Static member 'Area.PI' cannot be accessed with an instance
reference; qualify it with a type name instead". This is because PI is a
static field. Static fields can only be accessed using the name of the class
and not the instance of the class. The above sample program is rewritten as
shown below.
using System;
class Area
{
public static double PI = 3.14;
}
class MainClass
{
public static void Main()
{
Console.WriteLine(Area.PI);
}
}
Can you declare a field readonly?
Yes, a field can be declared readonly. A
read-only field can only be assigned a value during initialization or in a
constructor. An example is shown below.
using System;
class Area
{
public readonly double PI = 3.14;
}
class MainClass
{
public static void Main()
{
Area A = new Area();
Console.WriteLine(A.PI);
}
}
Will the following code compile?
using System;
class Area
{
public readonly double PI = 3.14;
}
class MainClass
{
public static void Main()
{
Area A = new Area();
A.PI = 3.15;
Console.WriteLine(A.PI);
}
}
No, PI is readonly. You can only read the
value of PI in the Main() method. You cannot assign any value to PI.
What is wrong with the sample program
below?
using System;
class Area
{
public const double PI = 3.14;
static Area()
{
Area.PI = 3.15;
}
}
class MainClass
{
public static void Main()
{
Console.WriteLine(Area.PI);
}
}
You cannot assign a value to the constant
PI field.
What is the difference between a constant
and a static readonly field?
A static readonly field is very similar to a
constant, except that the C# compiler does not have access to the value of a
static read-only field at compile time, only at run time.
No comments:
Post a Comment