Saltar al contenido

Variables y constantes en C#.

El uso de variables y constantes en C# o cualquier otro lenguaje de programación es fundamental. Una vez definidas en este artículo, podemos decir que su uso es muy parecido a otros lenguajes de programación. Por ejemplo en java.

Las variables en C#.

Cuando se declaran variables, en C# debemos tener claro que debemos hacerlo de la siguiente manera:

<Identificador> <Tipo de dato> <nombre de la variable>;

Es muy importante destacar que en el lenguaje C#, no se puede utilizar una variable que no hayamos iniciado. Es decir, no podemos utilizar una variable a la cual no le hayamos dado ningún valor.

Veamos que tipos de datos son los más utilizados en C#.

Tipos de datos más utilizados en CSharp.

Aunque en los lenguajes de programación hay muchos tipos de datos, vamos a ver los que más se utilizan en C#. En este caso, estos tipos de datos también son muy utilizados en lenguaje java.

tipos de datos en para variables y constantes en c#
tipos de datos en c#

Antes de ver algún ejemplo de como trabajar con variables y constantes, vamos a ver algunas reglas que se consideran buenas prácticas para nombrar variables.

Buenas prácticas a la hora de declarar variables en C#.

  • Las variables no deben comenzar por un guion bajo.
  • No crear dos o más variables que se diferencien en una única letra.
  • Una variable debe comenzar por una letra minúscula.
  • Cuando la variable contiene dos palabras, comenzar la segunda con mayúscula. Es decir, seguir la regla CamelCase.

Por otra parte, para declarar variables en c#, podemos hacerlo de dos formas diferentes.

  • Declarar la variable en una línea y después iniciarla en la siguiente o más adelante en nuestro programa.
  • Otra forma, sería declarar e iniciar la variable en la misma línea.

Vamos a ver un ejemplo de estos dos casos.

using System;

namespace Operaciones_con_Matrices
{
    class Program
    {
        static void Main(string[] args)
        {
            // Declaro cuatro variables. Asignamos el valor en una linea.
            char primeraLetra = 'H';
            char segundaLetra = 'O';
            char terceraLetra = 'L';
            char cuartaLetra = 'A';

            // Declaro tres variables. Asignamos el valor en varias lineas.
            float numeroPi;
            numeroPi = 3.14F;

            byte edad;
            edad = 18;

            double numDecimal;
            numDecimal = 5.17;

            string texto;

            // Esto es considerado una variable de tipo objeto,
            // ya que son varios caracteres char formando una frase.
            texto = "Ejemplo de variable de tipo string";
        }
    }
}

Una vez hemos visto los tipos de datos que y como declarar variables en C#, cabe destacar que hay un tipo de dato llamado string. Este tipo de dato tanto en C# como en otro tipos de lenguaje de programación como por ejemplo java, son consideramos objetos, es decir, tipos de datos no primitivos. Este tipo de dato String en C#, lo veremos más adelante.

En C#, existen varias formas de mostrar el valor de una variable por pantalla. Dos de las que vamos a ver son a través de la interpolación y por paso de parámetros.

Concatenación de variables por interpolación en csharp.

Veamos el mismo ejemplo pero concatenando el valor de las variables por interpolación.

using System;

namespace GuardarDatosEnVariablesInterpolacion
{
    class Program
    {
        static void Main(string[] args)
        {
            // Declaramos una variable y la iniciamos con cadena vacía.
            string nombre = "";

            // Mostramos un mensaje para introducir el nombre.
            Console.WriteLine("Escribe tu nombre");

            // Lo almacenamos en la variable
            nombre = Console.ReadLine();

            // Mostramos el valor de la variable
            Console.WriteLine($"Tu nombre es {nombre}");
            
            //Pausamos la consola
            Console.ReadKey(true);
        }
    }
}

Vamos a ver en el siguiente ejemplo como mostrar mensajes de variables por paso de parámetros.

Mostrar variables por parámetros en CSharp.

El método Write(); o WriteLine();, puede recibir varios parámetros. Por un lado le pasaremos el texto literal entre comillas de lo que queremos mostrar, y por otro las variables que queremos mostrar. Esto se hará pasando parámetros en la misma instrucción. Vamos a ver el mismo ejemplo anterior pero pasando las variables por parámetros.

using System;

namespace GuardarDatosEnVariablesConParametros
{
    class Program
    {
        static void Main(string[] args)
        {
            // Declaramos dos variable y las iniciamos con cadenas vacías.
            string nombre = "";
            string apellidos = "";

            // Mostramos un mensaje para introducir el nombre.
            Console.WriteLine("Escribe tu nombre:");

            // Lo almacenamos en la variable
            nombre = Console.ReadLine();

            // Mostramos un mensaje para introducir los apellidos.
            Console.WriteLine("Escribe tus apellidos:");

            // Lo almacenamos en la variable
            apellidos = Console.ReadLine();

            /* Mostramos el valor de las variables
             * pasandole dos parámetros*/
            Console.WriteLine("Tu nombre es {0} y tus apellidos {1}", nombre, apellidos);

            /* El cero entre llaves hace refererncia
             * a la primera variable nombre. El 1 tambien entre llaves
             * hace referencia a la segunda variable apellidos. Estas
             * Se estan pasando por parámetros como vemos en la instrucción
             * Console.WriteLine("frase a mostrar";, parámetros);
             * Podemos escribirlo tambien al revés.*/
            Console.WriteLine("Tus apellidos son {0} y el nombre {1}", apellidos, nombre);

            // En este caso el 0 corresponde a los apellidos y el 1 al nombre

            // Pausamos la consola
            Console.ReadKey();
        }
    }
}

Las constantes en C#.

Cuando declaramos una constante, es obligatorio declararla e iniciarla en una sola línea. En caso contrario, el programa dará error. Para declarar constantes, lo haremos de la misma forma que las variables. La diferencia es que utilizaremos la palabra reservada const. Además, el nombre de la constante la escribiremos en mayúsculas por convención.

<Identificador> <const> <Tipo de dato> <nombre de la variable>;

Vamos a ver un ejemplo de declaración de constantes en C#.

using System;

namespace Operaciones_con_Matrices
{
    class Program
    {
        static void Main(string[] args)
        {
            // Declaración de dos constantes
            // asignación un valor en una linea.
            // Los tipos de datos char
            // siempre van entre comillas simples.
            const char LETRAFINAL= 'J';

            // En caso de usar la variable decimal float
            // debemos indicar una f al final.
            // Esta f, puede ser mayúscula o minúscula.
            // De la siguiente manera.
            const float NUMEROPI = 3.14F;
        }
    }
}

A la hora de estar realizando nuestros programas, utilizamos de forma habitual las variables y constantes en c#. Por otra parte, puede que tengamos que comparar diferentes valores. Por este motivo, debemos conocer también los tipos de operadores que existen.