Expresiones y Operadores en C# - Parte 1

Tabla de Contenido

0. Introducción
1. Concepto de Expresión
2. Expresiones Primarias
3. Expresiones Vacías
4. Expresiones de Asignación
5. Conclusiones
6. Glosario
7. Referencias

0. Introducción

Como en la matemática elemental, al igual en álgebra, existe los medios lógicos y estructurales necesarios para la construcción de expresiones que denoten un valor a partir de valores desconocidos (variables) y constantes o valores conocidos. En los lenguajes de programación este concepto matemático y algebraico se ha heredado para permitir crear algoritmos compuestos de instrucciones (los pasos), que al mismo tiempo éstas últimas estén compuestas por expresiones que generen un valor de acuerdo a los datos de entrada, combinados con constantes o valores aleatorios.

C# no es la excepción en este apartado: el programador a través de los elementos de construcción del lenguaje puede crear expresiones a partir de otras menos complejas, o desde una simple constante o variable.

Este es el tema que se va a tratar en este artículo, además de los operadores y otros elementos del lenguaje, que también son otra pieza fundamental para la formación de expresiones.

1. Concepto de Expresión

Una expresión consiste en la composición (simple o compleja, dependiendo de qué tipo de valor estemos esperando al final de la evaluación de la expresión) de valores constantes y variables que una vez evaluados (a través de operadores (tema de la segunda parte de este artículo)) generarán un valor.

En C#, por ejemplo, las expresiones más simples son:

• La variable, y
• La constante

La transformación de una expresión se puede llevar a cabo a través del uso de operadores. Esto se logra a través de la combinación de operandos con los operadores. Cuando se evalúe, a la que se le podría llamar expresión principal, ésta generará otra distinta, y que podría eventualmente ser parte de otra más compleja (una llamada a un método, por ejemplo).

Expresión Constante

Se refiere a una expresión que su valor es fijo, por ejemplo:

• 1
• Math.PI
• 29
• Math.E

Expresión Variable

Una expresión variable es aquella que está compuesta por la combinación de una o más variables (al igual que expresiones constantes). Ejemplos:

• x
• y
• objetoComputador.ObtenerSerial();
• aleatorio.Next();

Esta es una manera de crear expresión (del caso más sencillo al más complejo):

• 12
• 12 * 30
• 1 + ( 12 * 30 )

En este ejemplo, la identación de los elementos demarca su sencillez (más a la izquierda) a su mayor complijadad (el caso contrario, mayor identación a la derecha) como en 1 + ( 12 * 30 ).

2. Expresiones Primarias

Son aquellas expresiones compuestas por los elementos de construcción básicos o intrínsecos del lenguaje. En C# un ejemplo sería:

Math.Log( 1 );

Por un lado, el operador de acceso a miembros: el operador . (punto) combinado con el operador de llamada a método, los paréntesis ovalares: (). Esta llamada de método es una expresión.

3. Expresiones Vacías (Void)

Estas expresiones se caracterizan por no devolver o generar un valor después de ejecutarse o evaluarse, como es el caso del método :

Console.WriteLine (1);

A partir de aquí se puede inferir que la expresión por su naturaleza de evaluación a vacío, no puede ser usada como operando en:

1 + Console.WriteLine (1) // Error en tiempo de compilación.

4. Expresiones de Asignación

El uso del operador de asignación es la clave para la colocación de valores resultantes de las evaluaciones de una expresión sobre una variable o constante. Ejemplo básico:

x = x * 5;

Una vez se evalúe x * 5 el valor generado se almacenará en la variable x. Eso nos revela que no se trata de una expresión vacía.

Por otro lado:

y = 5 * ( x = 2);

primero asigna 2 a la variable x, y luego ese valor multiplicado a por 5 nos da 10, que va a ser el valor que se asignará a y.

Otra demostración de múltiple asignación:

a = b = c = d = 0;

C# también dispone de operadores de asignación compuestos en los que se debe prestar particular atención:

x *= 2; // equivalante a x = x * 2;

x <<= 1; // equivalante a x = x << 1;

5. Conclusiones

Reconocer los diferentes tipos de expresiones que se pueden crear para un programa en C# es útil, debido a la utilidad ubicuidad de expresiones en la programación de cualquier rutina sobre el lenguaje.

6. Glosario

• Expresión
• Expresión vacía
• Múltiple asignación
• Operador de asignación compuesto

7. Referencias

[1]: C# 5.0 in a Nutshell by Joseph Albahari and Ben Albahari. Copyright 2012 Joseph Albahari and Ben Albahari, 978-1-449-32010-2.

O

var - Variables Locales de Tipo Deducido Implícitamente en C#

Tabla de Contenido

0. Introducción
1. Deducción de tipos - var
2. var y los Tipos Anónimos
3. Consideraciones e Implicaciones del Uso de var
4. Conclusiones
5. Glosario
6. Referencias

0. Introducción

En muchas oportunidades sea por conveniencia, comodidad, sobre el código fuente, el programador puede solicitar al compilador de C# que en tiempo de ejecución se encargue de deducir o inferir los tipos de una variable a partir de la evaluación de la expresión, el tipo de dato que se le ha de asignar a la parte izquierda de la instrucción: el identificador. Es aquí donde el lenguaje C# cuenta con una construcción propia para llevar a cabo toda esta tarea 'mágica': var.

1. Deducción de Tipos - var

Comúnmente, estamos acostumbrados a ser explícitos en la especificación de tipos a las variables que declaramos en el código fuente de nuestros programas. Esto ocurre, por supuesto, en lenguajes de programación fuertemente tipeados (en Seguridad de Tipos en C# se puede profundizar aún más en este tema); al contrastar con lenguajes débilmente tipeados (como puede ser el caso de PHP [1]), éstos dan mucha flexibilidad al programador en la tarea declaración de variables, dado que no es necesario especificar el tipo de la variable a declarar (al igual, también trae consigo algunos bugs inherentes al código relacionados con la conversión de tipos, evaluación de expresiones que generan valores de tipos diferentes, etc).

Continuando, desde la versión 3.0 de C# [2] nuevas características fueron introducidas, entre ellas la de deducción de tipos (a través de var), que en un principio consiste en una regla simple:

sí el compilador es capaz de inferir el tipo a partir del tipo del valor de la evaluación de una pressión, entonces la construcción var puede ser utilizada en ese lugar.

A través de los siguientes ejemplos en código fuente se puede ilustrar con más detalle el concepto de var:

var x = "OrtizOL";

var y = new System.Text.StringBuilder();

var z = (float)Math.PI;

La parte derecha de la instrucción de cada uno de estos ejemplos, a simple vista, nos informa del tipo de dato a declarar a cada uno de los identificadores (esta es la tarea del compilador).

Las instrucciones anteriores son equivalantes a estas:

string x = "OrtizOL";

System.Text.StringBuilder y = new System.Text.StringBuilder();

float z = (float)Math.PI;

Evidentemente, en las instrucciones recientes el programador ha hecho uso directo o explícito del tipo a declarar cada uno de los tres identificadores ( x:string, y:System.Text.StringBuilder, y z:float).

Otros ejemplos útiles

// a es compilado como un arreglo de enteros (int[])

var a = new[] { 0, 1, 2 };

En una instrucción de inicialización de la estructura repetiva for [3]:

for(var x = 1; x < 10; x++);

En una instrucción de inicialización foreach [3]:

foreach(var item in lista)

{

//...

}

También, en una instrucción using:

using (var archivo = new StreamReader("X:\\MiArchivo.txt")) {...}

2. var y los Tipos Anónimos

[3]: El uso de var puede ser asunto simplemente de comodidad sintáctica, o en la mayoría de casos opcional. Sin embargo, en situaciones que el tipo de dato no es conocido ni por el programador ni el compilador, estamos hablando de los tipos anónimos; en este escenario usar var es mandatorio. Un escenario donde se presenta, según [3], esta situación es en el uso de de expresiones de consulta LINQ [4]. Aquí está un ejemplo (tomado de [3]):

Archivo C# ImplicitlyTypedLocals.cs [enlace alternativo]:

► Prueba de ejecución.

En la línea 16 gracias al uso de var podemos acceder a las propiedadese del tipo anónimo (que es aquel que se instancia (sin conocer su tipo) en las líneas 9-11).

3. Consideraciones e Implicaciones del Uso de var

En [5] se declara que a pesar de la flexibilidad o comodidad sintáctica que ofrece C# a través de var, existe la siguiente restricción:

var x = 5;
x = "OrtizOR"; // Error en tiempo de compilación, x es de tipo int

Esto se debe a que las variables deducidas implícitamente son tipos estáticos, es decir (para este caso), que una vez inferido su tipo, éste no puede ser cambiado por cualquier otro: en el caso anterior se pretende pasar de int a string (lo cual es imposible debido a la razón anterior. {Lectura recomendad: [6]}.

Restricciones sobre var:

• Un variable var no puede inicializar con null.
• var no se puede utilizar en campos de instancia.
• Sólo está permitido su uso en la misma instrucción donde se declara y se inicializa la variable.
• No está permitida la inicialización de tipos implícitos, en una misma instrucción:
  
  Permitido:
  int x = y = z = 0;
  
  No permitido:
  var x = y = y = 0;

Por otro lado en [5]:

var can decrease code readability in the case when you can't deduce the type purely by looking at the variable declaration. For example: 

Random r = new Random();

var x = r.Next();

What type is x?

4. Conclusiones

Podemos optar por el uso de var en muchos escenarios (casi cualquiera) pero debemos tener en cuenta aspectos de legibilidad del código, compatibilidad hacia atrás (versiones anteriores a la 3.0 de C#). No deberíamos decantarnos por el uso de var por el siemple hecho de comodidad sintáctica. Para resaltar una vez más, el uso sobresaliente de var se da en el manejo de Tipos Anónimos (tema que trataré en varios artículos futuros). 

5. Glosario

- Comodidad sintáctica
- Débilmente tipeado
- Fuertamente tipeado
- Tipo anónimo

6. Referencias

[1]: PHP - Wikipedia, the free encyclopedia - http://en.wikipedia.org/wiki/PHP
[2]: Overview of C# 3.0 - http://msdn.microsoft.com/en-us/library/bb308966.aspx
[3]: Variables locales con asignación implícita de tipos (Guía de programación de C#) - http://msdn.microsoft.com/es-es/library/bb384061.aspx
[4]: Language Integrated Query - Wikipedia, the free encyclopedia - http://en.wikipedia.org/wiki/Language_Integrated_Query
[5]: C# 5.0 in a Nutshell by Joseph Albahari and Ben Albahari. Copyright 2012 Joseph Albahari and Ben Albahari, 978-1-449-32010-2.
[6] Introduction to Static and Dynamic Typing - SitePoint - http://www.sitepoint.com/typing-versus-dynamic-typing/

O