Tipos de Datos Básicos en C# - Parte 1

Tabla de Contenido

0. Introducción
1. Variables y Tipos
2. Tipos Predefinidos
3. Conclusiones
4. Palabras Clave
5. Referencias

0. Introducción

En esta primera parte de Tipos Básicos en C# empezaremos con el manejo de términos importantes en la programación: el concepto de variable y tipos predefinidos. Continuaremos con el ejemplo EstudioSintaxisCSharp para comprender y afianzar los conceptos anteriores.

Archivo C# EstudioSintaxisCSharp.cs [Enlace alternativo]:

1. Tipo, Variable, y Constante

1.1 Tipo

En un principio, la definición de tipo se puede asociar al molde que da las características (valores) y comportamiento (métodos, propiedades, entre otros) a una variable. Si nos fijamos en el ejemplo de código fuente de arriba, detectamos los valores 12 y 30 como enteros (int). Es como en este caso, declaramos una variable identificada como x del mismo tipo anterior, así:

int x = 12 * 30;

1.2 Variable

Podemos definir a una variable como una locación de memoria que puede contener distintos valores a lo largo del tiempo.

1.3 Constante

A diferencia de lo anterior, una constante siempre representará el mismo valor durante todo el tiempo de ejecución de un programa. A continuación, se muestra cómo declarar una constante en C#:

const int y = 360;

2. Tipos Predefinidos

C#, así como también los demás lenguajes compatibles con .NET Framework: F#, VB.NET, Delphi.NET, C++/CLI, etc., tiene asociado un conjunto de tipos predefinidos especiales que son utilizados por el compilador. Entre los que tenemos: enteros (int), cadenas de caracteres (string), y valores lógicos booleanos (bool).

2.1 Enteros (int)

Por ejemplo, int es un tipo predefinido que se usa para la representación del conjunto de los números enteros de 32 bits de memoria. Es decir, los números enteros que comprende el rango: 

Sobre las literales enteras (int) se permite realizar funciones como las aritméticas en instancias de ese tipo:

int x = 12 * 30;

2.2 Cadenas de caracteres (string)

Otro de los tantos tipos predefinidos en C# es string. Un string es una cadena de caracteres (también conocida como ristra) que permite formar palabras o frases como: ".NET" o "http://ortizol.blogspot.com". Sobre instancias de este tipo predefinido se pueden realizar operaciones como:

string mensaje = "Hola mundo";
string mensajeEnMayusculas = mensaje.ToUpper();
Console.WriteLine(mensajeEnMayusculas); // HOLA MUNDO

int x = 2013;
mensaje = mensaje + x.ToString();
Console.WriteLine(mensaje); // Hola mundo2013

2.3 bool

Una variable del tipo predefinido bool solo puede contener exactamente uno de sus dos posibles valores: true o false. Este tipo se utiliza para la evaluación de expresiones lógicas que bifurcan el flujo de ejecución en una estructura de control condicional if:

bool variableSimple = false;

if(variableSimple)

Console.WriteLine("Esto no se imprimirá");

int x = 5000;

bool menosDeUnaMilla = x < 5280;

if(menosDeUnaMilla)

Console.WriteLine("Esto se imprimirá");

3. Conclusiones

Hemos visto los tipos predefinidos de C#, y hemos comprendido que cada uno posee una palabra reservada que se utiliza para la declaración de variables del tipo en cuestión. .NET Framework cuenta con muchos tipos predefinidos, por ejemplo, la clase DateTime.

4. Palabras Clave

• Bifurcar
• bool
• DateTime
• int
• Tipo de dato predefinido

5. 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.
[2]: DateTime Structure - http://msdn.microsoft.com/en-us/library/system.datetime.aspx

H

Sintaxis de C# - Parte 2

Tabla de Contenido

0. Introducción

1. Literales

2. Puntuadores

3. Operadores

4. Comentarios

5. Conclusiones

6. Glorario

7. Referencias

0. Introducción

Continuando con la introducción a la sintaxis de C#, en esta entrada me propongo a presentar las piezas primitivas de datos: las literales. Además, los Puntuadores que definen los límites de bloques de código ({, }, y ;); inclusive se hablará de los operadores con los cuales se logra transformar expresiones a otras. Finalmente, se mostrará el uso de los comentarios que nos sirven para ir documentando el código fuente que escribimos.

Para extender aún más la explicación de los conceptos que se manejarán en esta entrada, continuo con el ejemplo en código fuente C# EstudioSintaxisCSharp.

Archivo C# EstudioSintaxisCSharp.cs [Enlace alternativo]:

1. Literales

De acuerdo a [1], se puede inferir que los literales son piezas de datos primitivas que pueden ser utilizadas en los programas para representar un valor numérico, cadena de caracteres, por ejemplo. En EstudioSintaxisCSharp tenemos los siguientes literales en la línea 7 12 y 30. Otros tipos de literales:

• Literales booleanos: true y false;
• literales numéricos: 1, 11, 19, 2013, 3.14159;
• literales de caracter: secuenas de escape (\n, \t, \r, etc), caracteres ('j', '8', 'h'); 
• literales de cadena de caracteres: "este es una cadena" (observe que debe estar encerrada entre comillas dobles).

2. Puntuadores

Los puntuadores son caracteres especiales que delimitan bloques de código y el final de una sentencia. Para nuestro ejemplo, tendríamos los siguientes puntuadores en EstudioSintaxisCSharp:

{ (líneas 4 y 6), } (líneas 9 y 10), ; (líneas 7 y 8)

Los corchetes agrupan múltiples sentencias dentro de un bloque de sentencias. Las sentencias pueden ocupar varias líneas. Esto último resulta útil para asuntos de legibilidad del código fuente.

3. Operadores

La función principal de un operador consiste en la transformación y combinación de expresiones. En C#, un operador se denota con un símbolo: suma (+), resta (-), producto (*), cociente (/). En el código fuente tenemos:

• . (línea 8): se le conoce como acceso a miembro de objeto.
• () (línea 8): usados para la declaración e invocación de métodos y agrupador de expresiones.
• * (línea 7) producto.
• = (línea 7) asignación.

4. Comentarios

Los comentarios son un medio útil para la documentación del código fuente. Resulta práctico (y requerido) en los casos donde la arbitrariedad del programador conlleve a la escritura de código poco comprensible por otros miembros del equipo. Además, comentar el código nos ayudará al proceso de refactorización en un caso futuro donde se deba hacer mantenimiento a la aplicación.

Formas de documentar en C#

Comentarios de línea simple:

Por ejemplo: int x = 3; // Asigna 3 a x es útil para documentar una línea simple de código.

Comentarios de múltiples líneas:

int x = 12 * 30; /* Este comentario 

se expande dos líneas */ 

Hay otras maneras más eficientes y efectivas de documentar un proyecto, y consiste en documentación XML. Más adelante crearé un artículo dedicado sólo a esta forma de documentar.

5. Conclusiones

Se ha introducido nuevo vocabulario relacionado con la sintaxis de C#. Se ha comprendido el uso de literales como unidades fundamentales en la edición de código fuente. Con el código en EstudioSintaxisCSharp se conceptualizó lo que es un operador y su utilidad (combinación y transformación de sentencias). Además, de comprender los puntuadores para la creación de bloques de código, y delimitadores de sentencias (;). Para finalizar se mostró el uso de los comentarios (de línea simple, multiples líneas).

Glosario

- Literal
- Operador
- Puntuador

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.
[2] What does the word "literal" mean? - http://stackoverflow.com/questions/485119/what-does-the-word-literal-mean
[3] C# Operators - http://msdn.microsoft.com/en-us/library/6a71f45d(v=vs.10).aspx

J

Sintaxis de C# - Parte 1

La sintaxis de C# es uno de los temas más importantes e interesantes a tratar en el aprendizaje del lenguaje, es por esta razón que a partir de este post se presentaran temas relacionados divididos en partes para facilitar su estudio, lectura y comprensión. Empiezo con Identificadores y Palabras reservadas (e inclusive palabras reservadas contextuales), enseguida Literales, Puntuadores, y Operadores; Comentarios.

La clase EstudioSintaxisCSharp se convertirá en el caso de estudio para introducir los conceptos citados anteriormente. Este es el código fuente de la clase:

Archivo C# EstudioSintaxisCSharp.cs [Enlace alternativo]:

- Identificadores y Palabras Reservadas:

Identificadores

Los identificadores son los literales de un léxico específico (contexto del problema, por ejemplo) que representan locaciones de memoria. Éstos nos sirven como mecanismo nemotécnico para las variables, métodos, propiedades, eventos, etc. Los nombres escogidos para los identificadores son arbitrarios (dependen del léxico del programador, del dominio del problema en el que se esté trabajando). Es importante mencionar que los nombres deben poseer un nombre significativo para facilitar su uso, lectura, y refactorización futura.

Para el caso práctico, reconozcamos varios de los identificadores en el código fuente de la clase :

• System
• EstudioSintaxisCSharp
• Main
• x
• Console
• WriteLine

Para componer un identificador hay que tener en cuenta unas reglas y características:

• Deben empezar con una letra (a-z, A-Z) o un carácter de subrayado (_).
• No está permitido que el primer carácter sea un número.
• Para evitar conflictos con las palabras reservadas utilizamos el prefijo @.
• Están compuestas por caracteres Unicode.

Todos los identificadores (debido a la naturaleza de lenguaje estático de C#) son sensibles a mayúsculas y a minúsculas. El identificador x (equis minúscula) es distinto de X (equis mayúscula).

Los nombres de variables locales, parámetros, y campos privados, por convención, utilizan la escritura en camello (CamelCase [1]). Ejemplos:

• miVariable
• saldoCliente
• capacidadMemoriaRam

Para los identificadores restantes, generalmente aceptado, se usa escritura Pascal (Pascal Case [2]).

Palabras Reservadas

Las palabras reservadas son literales especiales utilizadas por el compilador, y no pueden ser utilizadas como identificadores. En EstudioSintaxisCSharp se halla el siguiente conjunto de palabras reservadas:

• using
• class
• static
• void
• int

C# 5.0 cuenta con más de 65 palabras reservadas. En la Figura 1 se muestra el listado completo.

Figura 1. Listado completo palabras reservadas en C# 5.0 [4]

 - ¿Cómo evitar conflictos?:

En casos especiales en que el programador requiera usar una palabra reservada del lenguaje, C# provee una mecanismo útil y sencillo para lograrlo; es a través de el prefijo @. Para demostrarlo:

class class {...} // Ilegal
class @class {...} // Legal

Hay que dejar claro que el símbolo @ no hace parte del nombre de la variable: @miSaldo es lo mismo que miSaldo.

Este prefijo nos ayuda en casos cuando decidimos utilizar librerías de los diferentes lenguajes de .NET Framework que tienen diferentes palabras reservadas.

- Palabras reservadas contextuales (Contextual Keywords [5][6]):

En C# existen palabras reservadas que pueden ser utilizadas como tal, y también como identificadores: se les conoce como palabras reservadas contextuales (o en inglés, Contextual keywords). Además, su uso tiene significado específico en el código, por ejemplo [6]:

Notemos la declaración int var = 1; a pesar de que var es una palabra reservada, el compilador de C# no presenta ningún conflicto debido a que se trata de una palabra reservada contextual. Lo anterior lo contrastamos con var resultado, esta declaración hace uso de resultado como variable dinámica.

C# posee más de 24 palabras reservadas de este tipo. La Figura 1 presenta el listado completo.

Figura 1. Listado de palabras reservadas contextuales (Contextual keywords) en C# 5.0 [4].

Conclusiones:

Se ha aprendido acerca del uso básico de la sintaxis en C#. Los identificadores son palabras de un léxico que sirven para hacer referencia a diferentes elementos del código fuente: método, variables, nombres de clases, de propiedades, eventos, etc. Las palabras reservadas son un conjunto especial de literales del compilador de C# para componer código fuente. Finalmente, las palabras reservadas contextuales no presentan conflicto si se utilizan como identificador.

Glosario:

- Camel case
- Keyword
- Literal
- Palabra reservada
- Pascal case
- Puntuador
- Sintaxis

Referencias:
[1] CamelCase - http://en.wikipedia.org/wiki/CamelCase
[2] Pascal Case - http://c2.com/cgi/wiki?PascalCase
[3] Unicode - https://en.wikipedia.org/wiki/Unicode
[4] C# 5.0 in a Nutshell by Joseph Albahari and Ben Albahari. Copyright 2012 Joseph Albahari and Ben Albahari, 978-1-449-32010-2.
[5] Contextual Keywords - http://msdn.microsoft.com/en-us/library/the35c6y.aspx
[6] C# Contextual Keywords - http://www.dotnetperls.com/contextual-keyword

J

Compilación en C#

Hablemos un poco del proceso de compilación de C#. Este artículo será muy interesante pues integra muchos de los conceptos prácticos que involucra la escritura de código fuente en lenguaje C# para su posterior compilación a un assembly (ensamblado) ejecutable (.exe).

- ¿Qué es la compilación?:

La compilación es el proceso de traducción de código fuente (uso de palabras del inglés, entendible por los humanos o lenguaje de alto nivel) a código objeto (interpretable por la máquina, lenguaje de bajo nivel). Este proceso está compuesto, normalmente, por las siguientes fases:

• Análisis léxico
• Preprocesamiento
• Parseo
• Análisis semántico
• Generación de código objeto
• Optimización de código

- Compilación en C#:

El código fuente escrito en lenguaje C# se escribe en archivos de texto plano con extensión .cs. .NET Framework posee compiladores para todos lenguajes compatibles con la CLR, para el caso particular, tenemos a csc.exe que se ejecuta desde la línea de comandos y al que se le debe pasar un archivo (o varios, inclusive) para generar un assembly (o ensamblado).

Un assembly, es la unidad de empaquetamiento y despliegue en .NET Framework. Hay dos tipos de assembly, los ejecutables (o de proceso) o las librerías. En el caso de los procesos, tenemos aplicaciones Windows y de consola, para que sea así deben tener como punto de entrada el método Main. Por otro lado, las librerías pueden ser referenciadas desde aplicaciones que las incluyen en los proyectos; a diferencia de los procesos, las librerías (.dll) no poseen un punto de entrada. Adicionalmente, se puede ver a .NET Framework como un conjunto de librerías para distintos propósitos (e.g., creación de interfaces gráficas, algoritmos numéricos, conexión a base de datos, acceso a datos, criptografía, acceso a red, entre otros más).

El proceso de compilación en C# puede ser realizado desde el entorno de desarrollo integrado Visual Studio [2] o desde la línea de comandos [3]. A continuación presento un ejemplo sencillo acerca del proceso de compilación del programa en código fuente MiPrimerPrograma.cs:

Así compilamos a MiPrimerPrograma.cs:

csc MiPrimerPrograma.cs

La Figura 1 muestra todo el proceso de compilación y ejecución del programa anterior.

Figura 1. Compilación y Ejecución de MiPrimerPrograma.cs

[Nota: El compilador de C# se encuentra en la siguiente ruta %SystemRoot%\Microsoft.NET\Framework\ donde %SystemRoot% es el directorio para Windows.]

Si quisiéramos producir una librería (.dll), ejecutamos el siguiente comando:

csc /target:library MiPrimerPrograma.cs

Conclusiones:

Se ha podido ver que el proceso de compilación es análogo a una traducción de un lenguaje natural a otro. Este proceso involucra varias fases bien definidas que permiten traducir código fuente (en lenguaje de alto nivel) a código objeto (en lenguaje de bajo nivel: entendible por la máquina). Para efectos prácticos, se ha incluido un ejemplo para compilar y ejecutar un programa escrito en lenguaje C#.

Glosario:

- Análisis léxico
- Código fuente
- Compilación
- Compilador
- Ejecutable
- Exe
- IDE

Referencias:
[1] Compiler - http://en.wikipedia.org/wiki/Compiler
[2] Microsoft Visual Studio - https://en.wikipedia.org/wiki/Microsoft_Visual_Studio
[3] Command Prompt - http://en.wikipedia.org/wiki/Command_Prompt

H

Refactorización de la Clase Prueba

En la presente entrada nos detendremos en la refactorización de la clase Prueba (descrita en Primer Programa en C#). Se introducirán nuevos conceptos, y se hará una descripción del uso del método Main: sus distintas firmas, valores de retorno, su parámetro en forma de arreglo de tipo string. También hablaremos de los tipos de funciones en C#.

Debido a que ya hemos hecho uso del concepto de clase, aprovecharé esta misma entrada para describirla (como bloque de construcción y elemento fundamental en la programación orientada a objetos).

- ¿Qué es la refactorización?:

Si nos apoyamos en la definición en [1], se entiende que la refactorización es el proceso de modificar la estructura interna de una construcción de código fuente (clase, namespace, enumeración, método, propiedad, etc.) sin alterar su protocolo (funcionalidad o comportamiento) externo. Otra manera de referirnos al mismo proceso es limpiar el código.

- Refactorización de la clase Prueba [2]:

En el primer programa que presentamos en [2], se mostró varios de los conceptos básicos de la programación en C#. Ahora les explicaré una versión de esa clase a la que le he aplicado refactorización (o limpieza del código) con el fin de hacer algunas definiciones importantes que nos servirán para la escritura de programas mejor estructurados y con código comprensible a futuro y para otros programadores.

Si nosotros observamos detenidamente, por ejemplo la clase Console [3], la documentación asociada a ésta muestra una descripción simplificada de los constructores, métodos, propiedades, etc., encontramos funciones de alto nivel y bajo nivel.

Una definición básica para funciones de alto nivel, son aquellas que muestran el concepto de una función desde su forma más abstracta (más cercana al lenguaje de los humanos), es decir, si tenemos:

public void Suma(double valorA, double valorB)

Mientras que una función de bajo nivel, es aquella que presenta en un nivel (cercano al lenguaje de la arquitectura de la máquina) de detalle la implementación de una función. Así:

public double Suma(double valorA, double valorB)
{
double suma = valorA + valorB;

return suma;
}

Podemos apreciar la diferencia entre ambas declaraciones: la primera resulta más simple y directa que la segunda, dado que esta última nos ofrece la declaración completa del método Suma con todas las sentencias dentro del cuerpo.

Ahora sí pasemos a hacer una refactorización de la clase Prueba presentada en [2]:

class Prueba
{
static void Main()
{
Console.WriteLine(PiesAPulgadas(30)); // 360
Console.WriteLine(PiesAPulgadas(100)); // 1200
}

static int PiesAPulgadas(int pies)
{
int pulgadas = pies * 12;
return pulgadas;
}
}

Aquí se puede ver el uso explícito de los dos conceptos anteriores (funciones de alto y bajo nivel).  Aquí tenemos la firma (signatura) del método PiesAPulgadas:

static int PiesAPulgadas(int pies)

Así mismo, la invocación de esa función desde una función de alto nivel (Main):

static void Main()
{
Console.WriteLine(PiesAPulgadas(30)); // 360
Console.WriteLine(PiesAPulgadas(100)); // 1200
}

Examinemos algunos de los elementos más importantes de la clase Prueba:

El método Main es el método reconocido por C# para señalar el punto de entrada de ejecución del programa. Este método se caracteriza por poseer diferentes versiones permisibles:

static void Main()
static void Main(string[] args)
static int Main()
static int Main(string[] args)

En cuanto a los tipos de retorno (void e int) el segundo es utilizado para indicar el estado (satisfactorio, con advertencias, o error) de finalización del programa.

Dos de las versiones de este método, además, especifican un parámetro como arreglo de objetos string; útil para programas tipo consola que requieren de argumentos ingresados de la línea de comandos (prompt).

- Clases de funciones en C#:

El método Main es un tipo de función en C#. Existen otros; como:

• Operadores aritméticos: suma (+), resta (-), producto (*), y cociente (/).
• Constructores: Especifican la forma en que debe ser creado un objeto.
• Propiedades: Permiten cambiar y obtener el estado de un objeto.
• Métodos: Comportamiento del objeto.
• Eventos: Responde a los cambios del estado de un objeto.

- La clase Console [3]:

Console representa objetos para la entrada, salida y error estándares. Permite a un programa tipo consola obtener valores desde la entrada estándar (teclado); igualmente presentar valores en la salida estándar (pantalla). En la refactorización de la clase Prueba se puede ver el uso del método WriteLine para mostrar los valores devueltos por el método PiesAPulgadas.

- Concepto de namespace:

En el nivel más exterior de un programa, los tipos se organizan dentro de namespaces. En la línea 1 se observa la inclusión de los tipos disponibles en el namespace System []. La clase Console pertenece a ese namespace.

Definición de un namespace:

Al igual que las clases Prueba y Prueba2, .NET Framework también se encuentra organizado dentro de namespaces anidados. Por ejemplo, este es el namespace que contiene los tipos para la manipulación de texto:

using System.Text;

Conclusiones:

El uso de la refactorización es importante para limpiar o reestructurar el código de proyectos pasados. Con la clase Prueba se ejemplificó el proceso anterior. Se introdujo los conceptos de función de bajo y alto nivel para diferenciar funciones que son legiblemente humanas, como los de bajo nivel, que muestran los detalles de la implementación de un tipo de función. Finalmente, se definió lo que es y para qué sirve un namespace.

Glosario:

- Alto nivel
- Bajo nivel
- Entrada estándar
- Namespace
- Refactorización
- Salida estándar

Referencias:
[1] Refactorización - http://es.wikipedia.org/wiki/Refactorizaci%C3%B3n
[2] Primer Programa en C# - http://ortizol.blogspot.com/2013/06/primer-programa-en-c.html
[3] Console class - http://msdn.microsoft.com/en-us/library/system.console.aspx
[4] I want to know the difference between Low-level functions & Top-level functions - http://stackoverflow.com/questions/633617/i-want-to-know-the-difference-between-low-level-functions-top-level-functions
[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] System Namespace - http://msdn.microsoft.com/en-us/library/system.aspx.

H