The tradition of using Constants haven't changed much through the times of C++ and now C#, the implication is also the same. Looking deep into the working of Constatnts in C#, we can summarize that A constant is a symbol that has a never-changing value and when declaring a constant symbol. The value of constant as known as compile time and do not change, the compiler then saves the constant's value in the assembly's metadata. This means that you can define a constant only for t primitive types. In C#, the following types are primitives and can be used to define constants: Boolean, Char, Byte, SByte, Int16, UInt16, Int32, UInt32, Int64, UInt64, Single, Double, Decimal, and String.

Constants are declared  as a field, using the const keyword before the type of the field. Constant must be initilized as they are declared because a constant are always considered to be part of defining type. Constant can be marked as public, private, protected, internal or protected internal. these access modifiers defines how users of the class can access constant.

Note: Constant are always considerd to be static memberes not instance members. Definig a constant causes the creation of metadata. 

Example:

class Calendar

{

    const int months = 12;

    const int weeks = 52;

    const int days = 365;

 

    const double daysPerWeek = days / weeks;

    const double daysPerMonth = days / months;

} 

Constants are accessed as if they were static fields, although they cannot use the static keyword. Expressions that are not contained within the class defining the constant must use the class name, a period, and the name of the constant to access the constant. For example:

int birthstones = Calendar.months; 

When code refer to const keyword or constant sysmbol, compiler loop up the sysmbol in the metadata of the assembly that defines the constant, extract the constant's value, and ambed value in the emitted IL code. Because a constant's value is embedded directly in code, constants don't require any memory to be allocated for them at run time. In addition, you can't get the address of a constant and you can't pass a constant by reference. These constraints also mean that constants don't have a good cross-assembly versioning story, so you should use them only when you know that the value of a symbol will never change.



Currently rated 1.0 by 1 people

  • Currently 1/5 Stars.
  • 1
  • 2
  • 3
  • 4
  • 5