C# | Tipos de Variables

Una variable es un nombre dado a una ubicación de memoria y todas las operaciones realizadas en la variable afectan esa ubicación de memoria. En C# , todas las variables deben declararse antes de que puedan usarse. Es la unidad básica de almacenamiento en un programa. El valor almacenado en una variable se puede cambiar durante la ejecución del programa. 

Tipos de Variables

• Variables locales
• Variables de instancia o variables no estáticas
• Variables estáticas o variables de clase
• Variables constantes
• Variables de solo lectura
   

Variables locales

Una variable definida dentro de un bloque, método o constructor se denomina variable local.  

• Estas variables se crean cuando se ingresa al bloque o se llama a la función y se destruye después de salir del bloque o cuando la llamada regresa de la función.
• El alcance de estas variables existe solo dentro del bloque en el que se declara la variable. es decir, podemos acceder a estas variables solo dentro de ese bloque.

Ejemplo 1: 

// C# program to demonstrate
// the local variables
using System;
class StudentDetails {
     
    // Method
    public void StudentAge()
    {
         
        // local variable age
        int age = 0;
         
        age = age + 10;
        Console.WriteLine("Student age is : " + age);
    }
 
    // Main Method
    public static void Main(String[] args)
    {
         
        // Creating object
        StudentDetails obj = new StudentDetails();
         
        // calling the function
        obj.StudentAge();
    }
}

Producción: 

Student age is : 10

Explicación: en el programa anterior, la variable «edad» es una variable local de la función StudentAge(). Si usamos la variable edad fuera de la función StudentAge(), el compilador producirá un error como se muestra en el programa a continuación.

Ejemplo 2: 

// C# program to demonstrate the error
// due to using the local variable
// outside its scope
using System;
 
class StudentDetails {
     
    // Method
    public void StudentAge()
    {
         
        // local variable age
        int age = 0;
        age = age + 10;
    }
 
    // Main Method
    public static void Main(String[] args)
    {
         
        // using local variable age outside it's scope
        Console.WriteLine("Student age is : " + age);
    }
}

Error:

prog.cs(22,43): error CS0103: El nombre `edad’ no existe en el contexto actual

Variables de instancia o variables no estáticas

Las variables de instancia son variables no estáticas y se declaran en una clase pero fuera de cualquier método, constructor o bloque. Como las variables de instancia se declaran en una clase, estas variables se crean cuando se crea un objeto de la clase y se destruyen cuando se destruye el objeto. A diferencia de las variables locales, podemos usar especificadores de acceso para variables de instancia.

Ejemplo: 

// C# program to illustrate the
// Instance variables
using System;
 
class Marks {
     
    // These variables are instance variables.
    // These variables are in a class and
    // are not inside any function
    int engMarks;
    int mathsMarks;
    int phyMarks;
 
    // Main Method
    public static void Main(String[] args)
    {
         
        // first object
        Marks obj1 = new Marks();
        obj1.engMarks = 90;
        obj1.mathsMarks = 80;
        obj1.phyMarks = 93;
 
        // second object
        Marks obj2 = new Marks();
        obj2.engMarks = 95;
        obj2.mathsMarks = 70;
        obj2.phyMarks = 90;
 
        // displaying marks for first object
        Console.WriteLine("Marks for first object:");
        Console.WriteLine(obj1.engMarks);
        Console.WriteLine(obj1.mathsMarks);
        Console.WriteLine(obj1.phyMarks);
 
        // displaying marks for second object
        Console.WriteLine("Marks for second object:");
        Console.WriteLine(obj2.engMarks);
        Console.WriteLine(obj2.mathsMarks);
        Console.WriteLine(obj2.phyMarks);
    }
}

Producción : 

Marks for first object:
90
80
93
Marks for second object:
95
70
90

Explicación: En el programa anterior, las variables, engMarks, mathsMarks, phyMarks son variables de instancia. Si hay varios objetos como en el programa anterior, cada objeto tendrá sus propias copias de las variables de instancia. Está claro a partir del resultado anterior que cada objeto tendrá su propia copia de la variable de instancia.

Variables estáticas o variables de clase

Las variables estáticas también se conocen como variables de clase. Si una variable se declara explícitamente con el modificador estático o si una variable se declara bajo cualquier bloque estático, estas variables se conocen como variables estáticas. 

• Estas variables se declaran de manera similar a las variables de instancia, la diferencia es que las variables estáticas se declaran utilizando la palabra clave estática dentro de una clase fuera de cualquier bloque o constructor de métodos.
• A diferencia de las variables de instancia, solo podemos tener una copia de una variable estática por clase, independientemente de cuántos objetos creemos.
• Las variables estáticas se crean al comienzo de la ejecución del programa y se destruyen automáticamente cuando finaliza la ejecución.

Nota: Para acceder a las variables estáticas, no es necesario crear ningún objeto de esa clase, simplemente acceda a la variable como: 

class_name.variable_name;

Ejemplo: 

// C# program to illustrate
// the static variables
using System;
class Emp {
 
    // static variable salary
    static double salary;
    static String name = "Aks";
 
    // Main Method
    public static void Main(String[] args)
    {
 
        // accessing static variable
        // without object
        Emp.salary = 100000;
         
        Console.WriteLine(Emp.name + "'s average salary:"
                                           + Emp.salary);
    }
}

Producción: 

Aks's average salary:100000

Nota: La inicialización de variables no estáticas está asociada con la creación de instancias y las llamadas al constructor, por lo que las variables no estáticas también se pueden inicializar a través del constructor. No inicializamos una variable estática a través del constructor porque cada vez que el constructor llama, anulará el valor existente con un nuevo valor.

Diferencia entre variable de instancia y variable estática

• Cada objeto tendrá su propia copia de la variable de instancia, mientras que solo podemos tener una copia de una variable estática por clase, independientemente de cuántos objetos creemos.
• Los cambios realizados en una variable de instancia utilizando un objeto no se reflejarán en otros objetos, ya que cada objeto tiene su propia copia de la variable de instancia. En el caso de las estáticas, los cambios se reflejarán en otros objetos ya que las variables estáticas son comunes a todos los objetos de una clase.
• Podemos acceder a las variables de instancia a través de referencias de objetos y se puede acceder a las variables estáticas directamente usando el nombre de la clase.
• En el ciclo de vida de una clase, una variable estática es decir, se inicializa una y solo una vez, mientras que las variables de instancia se inicializan 0 veces si no se crea ninguna instancia y n veces si se crean n instancias.
• La sintaxis para variables estáticas y de instancia es:

 class Example
        {
            static int a; // static variable
            int b;        // instance variable
        }
 

Variables constantes

Si una variable se declara usando la palabra clave » const «, entonces es una variable constante y estas variables constantes no se pueden modificar una vez después de su declaración, por lo que debe inicializarse solo en el momento de la declaración.

Ejemplo 1: el programa a continuación mostrará el error porque no se proporciona ningún valor en el momento de la declaración de la variable constante. 

// C# program to illustrate the
// constant variables
using System;
class Program {
 
    // constant variable max
    // but no value is provided
    const float max;
 
    // Main Method
    public static void Main()
    {
         
        // creating object
        Program obj = new Program();
         
        // it will give  error
        Console.WriteLine("The value of b is = " + Program.b);
    }
}

Error:

prog.cs(8,17): error CS0145: un campo constante requiere que se proporcione un valor 
 

Ejemplo 2: Programa para mostrar el uso de variables constantes  

// C# program to illustrate the
// constant variable
using System;
class Program {
 
    // instance variable
    int a = 10;
     
    // static variable
    static int b = 20;
 
    // constant variable
    const float max = 50;
 
    // Main Method
    public static void Main()
    {
         
        // creating object
        Program obj = new Program();
         
        // displaying result
        Console.WriteLine("The value of a is = " + obj.a);
        Console.WriteLine("The value of b is = " + Program.b);
        Console.WriteLine("The value of max is = " + Program.max);
    }
}

Producción: 

The value of a is = 10
The value of b is = 20
The value of max is = 50

Puntos importantes sobre las variables constantes:  

• El comportamiento de las variables constantes será similar al comportamiento de las variables estáticas, es decir, inicializadas una y sólo una vez en el ciclo de vida de una clase y no requieren la instancia de la clase para acceder o inicializar.
• La diferencia entre una variable estática y constante es que las variables estáticas se pueden modificar, mientras que las variables constantes no se pueden modificar una vez declaradas.

Variables de solo lectura

Si una variable se declara usando la palabra clave readonly , serán variables de solo lectura y estas variables no se pueden modificar como constantes, pero después de la inicialización. 

• No es obligatorio inicializar una variable de solo lectura en el momento de la declaración, también se pueden inicializar bajo el constructor.
• El comportamiento de las variables de solo lectura será similar al comportamiento de las variables no estáticas, es decir, se inicializarán solo después de crear la instancia de la clase y una vez por cada instancia de la clase creada.

Ejemplo 1: en el programa a continuación, las variables de solo lectura k no se inicializan con ningún valor, pero cuando imprimimos el valor de la variable, el valor predeterminado de int, es decir, 0, se mostrará de la siguiente manera:

// C# program to show the use
// of readonly variables
// without initializing it
using System;
class Program {
 
    // instance variable
    int a = 80;
     
    // static variable
    static int b = 40;
 
    // Constant variables
    const float max = 50;
     
    // readonly variables
    readonly int k;
 
    // Main Method
    public static void Main()
    {
         
        // Creating object
        Program obj = new Program();
         
        Console.WriteLine("The value of a is = " + obj.a);
        Console.WriteLine("The value of b is = " + Program.b);
        Console.WriteLine("The value of max is = " + Program.max);
        Console.WriteLine("The value of k is = " + obj.k);
    }
}

Producción: 

The value of a is = 80
The value of b is = 40
The value of max is = 50
The value of k is = 0

Ejemplo 2: para mostrar la inicialización de la variable de solo lectura en el constructor.

// C# program to illustrate the
// initialization of readonly
// variables in the constructor
using System;
class Geeks {
 
    // instance variable
    int a = 80;
     
    // static variable
    static int b = 40;
 
    // Constant variables
    const float max = 50;
     
    // readonly variables
    readonly int k;
 
    // constructor
    public Geeks()
    {
 
        // initializing readonly
        // variable k
        this.k = 90;
    }
 
    // Main Method
    public static void Main()
    {
         
        // Creating object
        Geeks obj = new Geeks();
 
        Console.WriteLine("The value of a is = " + obj.a);
        Console.WriteLine("The value of b is = " + Geeks.b);
        Console.WriteLine("The value of max is = " + Geeks.max);
        Console.WriteLine("The value of k is = " + obj.k);
    }
}

Producción : 

The value of a is = 80
The value of b is = 40
The value of max is = 50
The value of k is = 90

Ejemplo 3: programa para demostrar cuándo se inicializa la variable de solo lectura después de su declaración y fuera del constructor:

// C# program to illustrate the
// initialization of readonly
// variables twice
using System;
class Geeks {
 
    // instance variable
    int a = 80;
     
    // static variable
    static int b = 40;
 
    // Constant variables
    const float max = 50;
     
    // readonly variables
    readonly int k;
 
    // constructor
    public Geeks()
    {
 
        // first time initializing
        // readonly variable k
        this.k = 90;
    }
 
    // Main Method
    public static void Main()
    {
         
        // Creating object
        Geeks obj = new Geeks();
 
        Console.WriteLine("The value of a is = " + obj.a);
        Console.WriteLine("The value of b is = " + Geeks.b);
        Console.WriteLine("The value of max is = " + Geeks.max);
 
        // initializing readonly variable again
        // will compile time error
        obj.k = 55;
 
        Console.WriteLine("The value of k is = " + obj.k);
    }
}

Error:

prog.cs(41,13): error CS0191: No se puede asignar un campo de solo lectura `Geeks.k’ (excepto en un constructor o un inicializador de variable) 
 

Puntos importantes sobre las variables de solo lectura: 

• La única diferencia entre las variables de instancia y de solo lectura es que las variables de instancia se pueden modificar, pero la variable de solo lectura no se puede modificar.
• La variable constante es un valor fijo para toda la clase, mientras que las variables de solo lectura son un valor fijo específico para una instancia de clase.