Variables

Una variable puede ser comparada a espacio de almacenamiento y es esencial para el programador. En C# una variable se declara de la siguiente manera:

<tipo de dato> <nombre>;

Un ejemplo podría lucir así:

string nombre;

Esa es la versión más básica, pero la variable aún no tiene un valor. Puedes asignarle uno después o al momento de declararla, así:

<data type> <name> = <value>;

Si ésta variable no es local al método en el que te encuentras trabajando (Ej.: una variable miembro de una clase), puede que quieras asignar una visibilidad a la variable:

<visibilidad> <tipo de dato> <nombre> = <valor>;

Un ejemplo completo:

private string name = "John Doe";

La parte de la visibilidad está relacionada a las clases, así que encontrarás una explicación más completa de ella en el capítulo sobre las clases. Concentrémonos en la parte de la variable con un ejemplo donde en realidad usemos un par de ellas:

using System;

namespace ConsoleApplication1
{
    class Program
    {
    static void Main(string[] args)
    {
        string firstName = "John";
        string lastName = "Doe";

        Console.WriteLine("Name: " + firstName + " " + lastName);

        Console.WriteLine("Please enter a new first name:");
        firstName = Console.ReadLine();

        Console.WriteLine("New name: " + firstName + " " + lastName);

        Console.ReadLine();
    }
    }
}

Ok, mucho de esto ya se ha explicado, así que nos vamos a saltar a la parte interesante. Primero que todo, declaramos un grupo de variables del tipo string. Un string contiene solo texto y como puedes ver, ya le asignamos un valor. Después, mostramos una linea de texto en la consola de salida en donde usamos las dos variables. La cadena esta hecha usando el caracter + para unir las otras partes.

A continuación, le pedimos al usuario que escriba un nuevo nombre, y usamos el método ReadLine() para leer la entrada del usuario desde la cónsola e ingresarlo en la variable firstName. Una vez que el usuario presione la tecla Enter, el nuevo nombre es asignado a la variable, y en la siguiente linea mostramos la presentación del nombre de nuevo, para mostrar el cambio. Hemos usado nuestra primera variable y la característica mas importante de una variable: La habilidad de cambiar su valor mientras se ejecuta.

Otro ejemplo interesante es con las matematicas. El siguiente es uno basado en el uso del mismo codigo ya utilizado

int number1, number2;

Console.WriteLine("Please enter a number:");
number1 = int.Parse(Console.ReadLine());

Console.WriteLine("Thank you. One more:");
number2 = int.Parse(Console.ReadLine());

Console.WriteLine("Adding the two numbers: " + (number1 + number2));

Console.ReadLine();

Coloca esto en nuestro método Main, y pruébalo. El único nuevo "truco" que usamos aquí, es el método int.Parse(). Este simplemente lee una cadena y la convierte en un entero. Como puedes ver, esta aplicación no hace ningún esfuerzo en validar la entrada del usuario, y si ingresas algo que no es un número, se muestra una excepción. Más acerca de esto luego.

Variables y alcance

Hasta ahora, hemos usado únicamente variables locales, las cuales son definidas y usadas dentro del mismo método. En C#, una variable definida dentro de un método no puede ser usada fuera de este método - esto es porqué es llamada local. Si estás familiarizado con otros lenguajes de programación, puede que conozcas también las variables globales, las cuales pueden ser accedidas desde otros lugares, pero C# no soporta el concepto de variables globales. En su lugar, puedes definir un campo en una clase, que puede ser accedido desde todos los métodos de esta clase. Permíteme demostrarte esto con un ejemplo:

using System;

namespace VariableScope
{
    class Program
    {
    private static string helloClass = "Hello, class!";

    static void Main(string[] args)
    {
        string helloLocal = "Hello, local!";
        Console.WriteLine(helloLocal);
        Console.WriteLine(Program.helloClass);
        DoStuff();
    }

    static void DoStuff()
    {
        Console.WriteLine("A message from DoStuff: " + Program.helloClass);
    }
    }
}

Observa el miembro helloClass, declarado en el ámbito de la clase en lugar de dentro del método - esto nos permitirá acceder a él desde ambos lugares, nuestro método Main() como dentro de nuestro método DoStuff(). Esto no se cumple para nuestra variable helloLocal, que ha sido declarada dentro del método Main() y por lo tanto solamente puede ser usada dentro de este método en específico.

El concepto de diferenciar en dónde una variable ha sido declarada se la llama scoping (alcance) y previene que tu código se convierta en un enorme desorden de variables que puedan ser cambiadas desde muchos lugares. Otra técnica que nos ayuda con esto es llamada visibility (visiblilidad) de miembro (en este caso ilustrado por la palabra reservada private), la cuál discutiremos en el capítulo acerca de clases.

Resumen

Las variables te permiten almacenar datos de varios tipos, por ejemplo, cadenas de texto, números u objetos personalizados. Hay variables locales, que son accesibles dentro del método en dónde fueron definidas, y después hay campos de la clase, que pueden ser accedidos desde todos los métodos de la clase e incluso fuera de la clase, si la visibilidad lo permite.