O constanta reprezinta o valoare care nu se schimba (immutable). Folosim o constanta pentru cazul in care avem o valoare care trebuie repetata in codul aplicatiei. Astfel, ii putem da o denumire care sa ajute la intelegerea scopului ei si ii putem modifica valoarea doar intr-un singur loc.
La fel ca o variabila, o constanta are un tip, un nume si o valoare. Constantele trebuie initializate chiar in momentul declararii.

In C# exista doua tipuri de constante: constante la compilare (valoarea este cunoscuta la compilare) si constante la executie (initializarea se face la runtime).

Const

Pentru declararea constantelor la compilare, se foloseste modificatorul const.

Declaram o constanta Integer.

        //compile constant
        public const int Code = 10;

Daca nu initializam valoarea, vom primi mesajul de eroare:
A const field requires a value to be provided.

O constanta poate reprezenta valoarea unui calcul

        public const int SecondsPerDay = 60*60*24;

Valoarea unei constante se poate baza pe valoarea unei alte constante.

        public const int SecondsPerWeek = SecondsPerDay*7;

Daca vrem sa schimbam valoarea unei constante vom primi mesajul:
The left-hand side of an assignment must be a variable, property or indexer.

Constantele la compilare sunt inlocuite cu valoarea lor. Astfel, urmatoarele secvente de cod vor genera acelasi IL.

            if (myCode == Constants.Agent.Code)
            { 
                //
            }

            if (myCode == 10)
            {
                //
            }

Const se aplica pentru tipurile valoare numerice (sbyte, byte, short, ushort, int, uint, long, ulong, char, float, double, decimal), bool, char, enumerare sau siruri de caractere. Pentru tipurile definite de utilizator, clase, structuri, vectori, vom folosi readonly.

Constantele sunt accesate ca si niste membri statici pentru ca valoarea este aceeasi pentru toate instantele tipului.

Daca in proiect apare o noua versiune pentru un dll care contine constante, atunci programul trebuie recompilat pentru a prelua noile valori ale constantelor.

Readonly

Cu ajutorul modificatorului readonly putem crea o clasa, un vector, o structura care este initializata la runtime si a carei valoarea nu mai poate fi schimbata.

Pentru ca valoarea este evaluata la runtime, campul de tip readonly poate fi definit si in constructor.

        //readonly field
        public readonly double PI;
       
        //constructor
        public Constants()
        {
            //assignment 
            PI = 3.14;
        }

Daca incercam sa atribuim constantei o alta valoare intr-un alt loc, vom primi eroare la compilare.

        private void ChangeValue()
        {
            PI = 56;
        }

A readonly field cannot be assigned to (except in a constructor or a variable initializer).

Fata de constantele const, constantele readonly nu sunt statice.

Readonly static

Modul pentru declararea unei constante readonly static nu difera de modul in care se declara o constanta const.

        //readonly static field
        public static readonly double PI = 3.14;

Campul este accesibil iar valoarea este cunoscuta la runtime.

            Console.WriteLine(Constants.Constants.PI);

Construim clasa Agent:

    /// <summary>
    /// Agent class with properties
    /// </summary>
    public class Agent
    {
        public string LastName
        { get; set; }

        public string FirstName
        { get; set; }
    }

Pentru o avea o constanta de acest tip, declaram astfel:

        //runtime constant
        public static readonly Agent Agent = new Agent { FirstName = "James", LastName = "Bond" };

Constantele la runtime sunt mai flexibile, ele pot fi de orice tip si se pot initializa in constructor. Ele nu se pot declara in interiorul unei metode.

        private void MyMethod()
        {
            //corect
            const string name = "Name";
            //incorect
            readonly int age = 25;
        }

C# nu suporta constante pentru metode, proprietati, evenimente.
Constantele pot avea ca modificator de acces public, private, protected, internal.

Constantele const nu pot fi statice, sunt evaluate in momentul compilarii si sunt initializate doar la declarare. Se pot declara si in interiorul unei metode.
Constantele readonly pot fi statice sau de instanta, sunt evalutate in momementul executiei si pot fi initializate la declarare sau in constructor. Nu se pot declara in interiorul unei metode.

Avantajul major pentru folosirea const este rapiditatea. Atunci cand performanta este critica, constantele la compilare sunt recomandate. Dezavantajul il reprezinta pierderea flexibilitatii, flexibilitate pe care o putem obtine prin folosirea constantelor la runtime, pentru ca acestea se aplica oricarui tip.