Programación .

NET
(Junior )
Manual de introducción al
desarrollo de aplicaciones
con C#
Primera Parte
Audiencia
Este curso está orientado a aquellas profesionales o estudiantes que quieran adquirir los
conocimientos necesarios de programación basado en la plataforma MS .NET, desarrollo de
aplicaciones en C# sobre la plataforma Microsoft Visual Studio. Y para todas aquellas
personas que deseen desarrollar e implementar o convertir sus habilidades a esta tecnología.

Pre-Requisitos
Tener conocimientos básicos de programación en cualquier lenguaje y de base de datos
relacionales. Por ejemplo teoría de bases de datos, diferencias entre base de datos y planilla
de cálculos, etc.

Nota: Si usted no está seguro de sus conocimientos lo invitamos a tomar los cursos gratuitos
dentro de Microsoft Virtual Academy (MVA).

Al finalizar el curso
Después de completar este curso los alumnos serán capaces de:
 Explicar las capacidades de Microsoft .NET Framework
 Crear aplicaciones sencilla usando Microsoft .Net
 Conocimiento básico del Lenguaje de Programación C#
 Utilizar los conceptos de POO

-2-
Índice
MÓDULO I ..................................................................................................... - 8 -

INTRODUCCIÓN A .NET ............................................................................... - 8 -

1- Introducción a Microsoft .Net ............................................................................................ - 9 -
¿Qué es .Net Framework? -9-
Common Language Runtime (CLR) - 10 -
Biblioteca de Clases - 11 -
Microsoft Intermediate Language (MSIL) - 11 -
Compilación JIT (Just in Time) - 12 -
Ensablados - 12 -
Espacios de Nombres (Namespace) - 13 -

2- Microsoft Visual Studio.NET ............................................................................................ - 15 -

Introducción - 15 -
Proyectos y Soluciones - 15 -
Soluciones - 15 -
Plantillas de Proyectos - 16 -
Tipos de Proyectos - 17 -
Presentación del Entorno de Desarrollo (IDE) - 18 -
Explorador de soluciones - 19 -
Ventanas del Editor y del Diseñador de Windows Forms - 19 -
Características del Editor de Código - 20 -
Refactorización - 20 -
Ventana de Propiedades - 21 -
Cuadro de herramientas - 21 -
Referencias de Proyectos - 22 -
Visual Basic .Net - 22 -
C# - 22 -
Visual C++ - 23 -
Elección del Lenguaje - 23 -

3- Introducción a Aplicaciones Windows ........................................................................... - 24 -

Introducción - 24 -
Formularios Windows - 24 -
Controles - 24 -
Control Button - 24 -
Control TextBox - 25 -
Control Label - 25 -
Control ComboBox - 25 -
Control ListBox - 26 -
Control RadioButton - 26 -
Control CheckBox - 26 -
MessageBox - 26 -
Introducción a Eventos - 27 -

MÓDULO II .................................................................................................. - 28 -

-3-
INTRODUCCIÓN AL LENGUAJE C# .......................................................... - 28 -
1- Introducción a C# .............................................................................................................. - 29 -
Definición - 29 -
Sentencias - 29 -
Llaves - 29 -
Como dar formato a un código en C# - 30 -
Indentación - 30 -
Sensibilidad a mayúsculas y minúsculas - 30 -
Espacio en blanco - 30 -
Comentarios - 30 -
Diseño - 31 -

2- Tipo de Datos Predefinidos.............................................................................................. - 32 -

Introducción - 32 -
Tipos de Datos - 32 -
Almacenado Datos - 32 -
Eligiendo un tipo - 32 -
Variables - 33 -
Nombres de variables - 33 -
Inicializando variables - 33 -
Asignando valores literales - 33 -
Tipo Caracteres - 34 -
Caracteres de Escape - 34 -
Examinando variables en Visual Studio .NET (Depuración) - 34 -
Tipo de Dato string - 36 -
Usando cadenas literales - 36 -
Entendiendo Unicode - 37 -
Constantes - 37 -
Enumeraciones - 37 -
Conversión de Datos - 38 -
Conversión explícita - 39 -
Otras conversiones - 40 -
Expresiones y Operadores - 40 -
Tipos de operadores: - 40 -
Operadores matemáticos - 42 -
Operadores lógicos - 42 -
Con qué usar operadores - 42 -
Precedencia de Operadores - 43 -
Asociatividad - 43 -
Matrices (Arrays) - 43 -

3- Sentencias C# .................................................................................................................... - 45 -

3- Sentencias C# .................................................................................................................... - 45 -
Sentencia IF - 45 -
Usando el ternario - 46 -
Sentencia switch - 46 -
Sentencias iterativas - 47 -
Sentencia for - 47 -
Sentencia while - 48 -
Usando la palabra reservada continue - 48 -
Usando la palabra reservada break - 49 -
Sentencia do - 49 -

-4-
 Control de Excepciones - 49 -

MÓDULO III ................................................................................................. - 51 -

FUNDAMENTOS DE LA POO ..................................................................... - 51 -

1- Conceptos Básicos ........................................................................................................... - 52 -
Abstracción - 52 -
Buscando el nivel de abstracción correcto - 52 -
Encapsulamiento - 53 -
Modelo - 54 -
Programación Estructurada - 54 -
Programación Orientada a Objetos - 54 -

2- Elementos Básicos de POO ............................................................................................. - 56 -

Clase - 56 -
Objeto - 56 -
Características de los objetos - 56 -
Comportamiento de los Objetos - 56 -
Implementación de un objeto - 57 -
Estado interno/estructura interna - 57 -
Identidad - 57 -
Práctica - 58 -
Envío de Mensajes - 58 -
Especificación de un Mensaje - 60 -
¿Qué es un método? - 61 -
Comportamiento común entre objetos - 62 -
Clases - 62 -
Clases e Instancias - 63 -
Especificación de Clases - 64 -
Instanciación - 64 -
Formas de Conocimiento - 65 -
Variables de Instancia - 65 -
Parámetros - 65 -
Variables Temporales - 65 -
Seudo Variable: this - 65 -

3- UML..................................................................................................................................... - 66 -
Definición - 66 -
Modelado - 66 -
Unificado - 66 -
Lenguaje - 67 -
Diagramas de UML 2.0 - 67 -
Diagrama de Clases - 67 -
Clase - 69 -
Atributos - 69 -
Visibilidad - 69 -
Operaciones - 70 -
Responsabilidades - 71 -
Relaciones - 71 -
Asociación - 71 -
Agregación - 72 -
Composición - 73 -

-5-
 Notación accesoria - 73 -
Generalización - 73 -
Dependencia - 74 -
Notas - 75 -

MÓDULO IV ................................................................................................. - 76 -

POO CON C# ............................................................................................... - 76 -

1- POO con C# ....................................................................................................................... - 77 -
C# - 77 -
Clases - 77 -
Campos - 77 -
Propiedades - 78 -
Métodos - 79 -
Parámetros de los métodos - 79 -
Sobre Carga - 79 -
Creación de Instancias - 80 -
Modificadores de Acceso - 80 -
Estructuras - 81 -
Interfaces - 81 -
Constructores - 82 -
Destructores - 82 -
Garbage Collection - 82 -
Miembros Estáticos - 82 -

2- Herencia y Polimorfismo .................................................................................................. - 84 -

Herencia - 84 -
this y base - 84 -
Cláusula Sealed y Abstract - 85 -
SobreEscritura (invalidación) - 85 -
Conversiones (Casting) - 86 -
Polimorfismo - 86 -

3- Colecciones ....................................................................................................................... - 89 -
Definición - 89 -
Colecciones no Genéricas - 89 -
Colecciones Genéricas - 89 -
List<T> - 90 -
Dictionary<TKey, TValue> - 90 -

MÓDULO V .................................................................................................. - 92 -

INTRODUCCIÓN A XHTML Y SCRIPT ....................................................... - 92 -

1- XHTML ................................................................................................................................ - 93 -
Definición - 93 -
Diferencias con HTML 4.01 - 93 -
Etiquetas y Atributos - 94 -
Primer documento XHTML - 94 -
Encabezados o títulos - 96 -

-6-
 Elemento strong - 97 -
Elemento em - 97 -
Elemento span - 98 -
Enlaces o Hipervínculos - 98 -
Imagenes - 100 -
Listas - 101 -
Elemento Table - 102 -
Formularios - 106 -
Elemento input - 106 -
Cuadros de texto - 106 -
Botones de radio - 107 -
Botón de comprobación checkbox - 108 -
Botones de envio y de reset - 108 -
Cajas de texto - 109 -
Elemento select - 110 -
Elemento label - 111 -
Agrupando con fieldset - 111 -

2- Estilos en XHTML ............................................................................................................ - 113 -

Estilos - 113 -
Archivos de Hojas de Estilos en Cascada (css) - 113 -
Clases en CSS - 114 -
Estilos Incluido en la sección Head - 115 -
Estilos en el mismo elemento - 115 -
Herencia de Estilos - 115 -

3- Scripts .............................................................................................................................. - 117 -

Definición - 117 -
Javascript - 117 -
Instrucciones Javascripts - 118 -
Variables - 119 -
Operadores aritméticos - 119 -
Operadores de Asignación - 119 -
Operadores de Comparación - 120 -
Operadores Lógicos - 120 -
Método Alert() - 120 -
Método getElementById - 121 -

-7-
 Módulo I

Introducción a .Net

-8-
1- Introducción a Microsoft .Net
¿Qué es .NET ?
Microsoft .Net es un conjunto de Tecnologías de software para conectar información,
personas, sistemas y dispositivos. Permite un alto nivel de integración del software mediante el
uso de Servicios Web.
Esta Tecnología se apoya en el .net Framework y en el ambiente de desarrollo multi-lenguaje
Visual Studio.net

¿Qué es .Net Framework?

.NET Framework es un componente integral de Windows que admite la creación y la ejecución

de la siguiente generación de aplicaciones y servicios Web.
.NET Framework proporciona un entorno de ejecución administrado, un desarrollo e
implementación simplificada y la integración con una gran variedad de lenguajes de
programación.
El diseño de .NET Framework está enfocado a cumplir los objetivos siguientes:
 Proporcionar un entorno coherente de programación orientada a objetos, en el que el
código de los objetos se pueda almacenar y ejecutar de forma local, ejecutar de forma
local pero distribuida en Internet o ejecutar de forma remota.
 Proporcionar un entorno de ejecución de código que reduzca lo máximo posible la
implementación de software y los conflictos de versiones.
 Ofrecer un entorno de ejecución de código que fomente la ejecución segura del mismo,
incluso del creado por terceras personas desconocidas o que no son de plena
confianza.
 Proporcionar un entorno de ejecución de código que elimine los problemas de
rendimiento de los entornos en los que se utilizan secuencias de comandos o
intérpretes de comandos.
 Ofrecer al programador una experiencia coherente entre tipos de aplicaciones muy
diferentes, como las basadas en Windows o en el Web.

-9-
  Basar toda la comunicación en estándares del sector para asegurar que el código de
.NET Framework se puede integrar con otros tipos de código.

Los componentes clave de .NET Framework son

 Common Language Runtime (CLR)
 La biblioteca de clases .NET Framework, que incluye ADO.NET, ASP.NET, formularios
Windows Forms y Windows Presentation Foundation (WPF).

Common Language Runtime (CLR)

Common Language Runtime administra la memoria, ejecución de subprocesos, ejecución de

código, comprobación de la seguridad del código, compilación y demás servicios del sistema.
Estas características son intrínsecas del código administrado que se ejecuta en Common
Language Runtime.
Con respecto a la seguridad, los componentes administrados reciben grados de confianza
diferentes, en función de una serie de factores entre los que se incluye su origen (como
Internet, red empresarial o equipo local). Esto significa que un componente administrado puede
ser capaz o no de realizar operaciones de acceso a archivos, operaciones de acceso al
Registro y otras funciones delicadas, incluso si se está utilizando en la misma aplicación activa.
El motor en tiempo de ejecución impone seguridad en el acceso al código. Por ejemplo, los
usuarios pueden confiar en que un archivo ejecutable incrustado en una página Web puede
reproducir una animación en la pantalla o entonar una canción, pero no puede tener acceso a
sus datos personales, sistema de archivos o red.
Además, el motor en tiempo de ejecución impone la solidez del código mediante la
implementación de una infraestructura estricta de comprobación de tipos y código denominado
CTS (Common Type System, Sistema de tipos común). CTS garantiza que todo el código
administrado es auto descriptivo. Los diferentes compiladores de lenguajes de Microsoft y de
terceros generan código administrado que se ajusta a CTS. Esto significa que el código
administrado puede usar otros tipos e instancias administrados, al tiempo que se aplica
inflexiblemente la fidelidad y seguridad de los tipos.
Además, el entorno administrado del motor en tiempo de ejecución elimina muchos problemas
de software comunes. Por ejemplo, el motor en tiempo de ejecución controla automáticamente
la disposición de los objetos, administra las referencias a éstos y los libera cuando ya no se
utilizan. Esta administración automática de la memoria soluciona los dos errores más comunes
de las aplicaciones: la pérdida de memoria y las referencias no válidas a la memoria.
Además, el motor en tiempo de ejecución aumenta la productividad del programador. Por
ejemplo, los desarrolladores pueden crear aplicaciones en el lenguaje que prefieran y seguir
sacando todo el provecho del motor en tiempo de ejecución, la biblioteca de clases y los
componentes escritos en otros lenguajes por otros colegas. El proveedor de un compilador
puede elegir destinarlo al motor en tiempo de ejecución. Los compiladores de lenguajes que se

- 10 -
destinan a .NET Framework hacen que las características de .NET Framework estén
disponibles para el código existente escrito en dicho lenguaje, lo que facilita enormemente el
proceso de migración de las aplicaciones existentes.
Aunque el motor en tiempo de ejecución está diseñado para el software del futuro, también es
compatible con el software actual y el software antiguo. La interoperabilidad entre el código
administrado y no administrado permite que los desarrolladores continúen utilizando los
componentes COM y las DLL que necesiten.
El motor en tiempo de ejecución está diseñado para mejorar el rendimiento. Aunque Common
Language Runtime proporciona muchos servicios estándar de motor en tiempo de ejecución, el
código administrado nunca se interpreta. Una característica denominada compilación JIT (Just-
In-Time) permite ejecutar todo el código administrado en el lenguaje de máquina nativo del
sistema en el que se ejecuta. Mientras tanto, el administrador de memoria evita que la memoria
se pueda fragmentar y aumenta la zona de referencia de la memoria para mejorar aún más el
rendimiento.
Por último, el motor en tiempo de ejecución se puede alojar en aplicaciones de servidor de gran
rendimiento, como Microsoft® SQL Server™ e Internet Information Services (IIS). Esta
infraestructura permite utilizar código administrado para escribir lógica empresarial, al tiempo
que se disfruta del superior rendimiento de los mejores servidores empresariales del sector que
pueda alojar el motor en tiempo de ejecución.

Biblioteca de Clases
La biblioteca de clases de .NET Framework es una colección de tipos reutilizables que se
integran estrechamente con Common Language Runtime. La biblioteca de clases está
orientada a objetos, lo que proporciona tipos de los que su propio código administrado puede
derivar funciones. Esto ocasiona que los tipos de .NET Framework sean sencillos de utilizar y
reduce el tiempo asociado con el aprendizaje de las nuevas características de .NET
Framework. Además, los componentes de terceros se pueden integrar sin dificultades con las
clases de .NET Framework.
Como en cualquier biblioteca de clases orientada a objetos, los tipos de .NET Framework
permiten realizar diversas tareas de programación comunes, como son la administración de
cadenas, recolección de datos, conectividad de bases de datos y acceso a archivos. Además
de estas tareas habituales, la biblioteca de clases incluye tipos adecuados para diversos
escenarios de desarrollo especializados.

Microsoft Intermediate Language (MSIL)

Cuando se compila a código administrado, el compilador convierte el código fuente en
Lenguaje intermedio de Microsoft (MSIL), que es un conjunto de instrucciones independiente
de la CPU que se pueden convertir de forma eficaz en código nativo. MSIL incluye
instrucciones para cargar, almacenar, inicializar y llamar a métodos en los objetos, así como
instrucciones para operaciones lógicas y aritméticas, flujo de control, acceso directo a la
memoria, control de excepciones y otras operaciones. Antes de poder ejecutar código, se debe
convertir MSIL al código específico de la CPU, normalmente mediante un compilador Just-In-
Time (JIT). Common Language Runtime proporciona uno o varios compiladores JIT para cada
arquitectura de equipo compatible, por lo que se puede compilar y ejecutar el mismo conjunto
de MSIL en cualquier arquitectura compatible.
Cuando el compilador produce MSIL, también genera metadatos. Los metadatos describen los
tipos que aparecen en el código, incluidas las definiciones de los tipos, las firmas de los
miembros de tipos, los miembros a los que se hace referencia en el código y otros datos que el
motor en tiempo de ejecución utiliza en tiempo de ejecución. El lenguaje intermedio de
Microsoft (MSIL) y los metadatos se incluyen en un archivo ejecutable portable (PE), que se
basa y extiende el PE de Microsoft publicado y el formato Common Object File Format (COFF)
utilizado tradicionalmente para contenido ejecutable. Este formato de archivo, que contiene

- 11 -
código MSIL o código nativo así como metadatos, permite al sistema operativo reconocer
imágenes de Common Language Runtime. La presencia de metadatos junto con el Lenguaje
intermedio de Microsoft (MSIL) permite crear códigos auto descriptivos, con lo cual las
bibliotecas de tipos y el Lenguaje de definición de interfaces (IDL) son innecesarios. El motor
en tiempo de ejecución localiza y extrae los metadatos del archivo cuando son necesarios
durante la ejecución.
Los archivos ejecutables están conformados por
• MSIL
• Datos Adicionales (Metadata)
El MSIL es independiente del lenguaje en el que se desarrolla

Compilación JIT (Just in Time)

La compilación JIT convierte MSIL en código nativo a petición en el tiempo de ejecución de la

aplicación, cuando el contenido de un ensamblado se carga y ejecuta. Common Language
Runtime proporciona un compilador JIT para cada arquitectura de CPU compatible, por lo que
los programadores pueden crear un conjunto de ensamblados MSIL que se puede compilar con
un compilador JIT y se puede ejecutar en equipos distintos con diferentes arquitecturas. No
obstante, el código administrado sólo se ejecutará en un determinado sistema operativo si
llama a las API nativas específicas de la plataforma o a una biblioteca de clases específica de
la plataforma.
La compilación JIT tiene en cuenta el hecho de que durante la ejecución nunca se llamará a
parte del código. En vez de utilizar tiempo y memoria para convertir todo el MSIL de un archivo
ejecutable portable (PE) a código nativo, convierte el MSIL necesario durante la ejecución y
almacena el código nativo resultante en memoria para que sea accesible en las llamadas
posteriores que se produzcan en el contexto de ese proceso. El cargador crea y asocia un
código auxiliar a cada método de un tipo cuando este tipo se carga y se inicializa. Cuando se
llama a un método por primera vez, el código auxiliar pasa el control al compilador JIT, el cual
convierte el MSIL del método en código nativo y modifica el código auxiliar para señalar
directamente al código nativo generado. Por tanto, las siguientes llamadas al método
compilado mediante un compilador JIT pasan directamente al código nativo.

Ensablados
Los ensamblados son las unidades de creación de las aplicaciones .NET Framework;
constituyen la unidad fundamental de implementación, control de versiones, reutilización,
ámbitos de activación y permisos de seguridad. Un ensamblado es una colección de tipos y
recursos creados para funcionar en conjunto y formar una unidad lógica de funcionalidad. Los
ensamblados proporcionan a Common Language Runtime la información necesaria para
conocer las implementaciones de tipos. Para el motor en tiempo de ejecución, un tipo no existe
si no es en el contexto de un ensamblado.

- 12 -
Espacios de Nombres (Namespace)
Los espacios de nombres organizan jerárquicamente los objetos definidos en un ensamblado.
Un ensamblado puede contener varios espacios de nombres; éstos, a su vez, pueden contener
otros espacios de nombres. Los espacios de nombres evitan las ambigüedades y simplifican
las referencias cuando se utilizan grupos grandes de objetos, como bibliotecas de clases.
Dentro de un espacio de nombres pueden definirse elementos como los módulos, interfaces,
clases, delegados, enumeraciones, estructuras y otros espacios de nombres. Los elementos
como propiedades, procedimientos, variables y eventos no se pueden definir en el nivel de
espacio de nombres sino que deben declararse dentro de los contenedores como módulos,
estructuras o clases.

namespace AplicacionPrueba {
public partial class Form1: Form
{
public Form1()
{
InitializeComponent();
}
}
}

Los nombres completos son referencias de objetos que llevan como prefijo el nombre del
espacio de nombres en el que está definido el objeto. Los nombres completos evitan los
conflictos de nombres porque permiten al compilador determinar qué objeto se utiliza. No
obstante, los nombres pueden llegar a ser largos y complicados. Para solucionar este
problema, puede utilizar la instrucción using para definir un alias, es decir, un nombre
abreviado que sustituya al nombre completo.

namespace EspacioEjemplo
{
namespace EspacioEjemplo2
{
public partial class ClaseEjemplo
{
}
}
}

El nombre completo de la clase del ejemplo anterior sería:

EspacioEjemplo.EspacioEjemplo2.ClaseEjemplo

Definiendo:
using EspacioEjemplo.EspacioEjemplo2;

Podemos entonces utilizar a la clase ClaseEjemplo sin la necesidad de escribir el nombre

completo.

Algunos espacios de nombre del framework son:

 System: Contiene clases fundamentales y clases base que definen tipos de datos de
referencia y de valor de uso frecuente, eventos y controladores de eventos, interfaces,
atributos y excepciones de procesamiento
 System.Collections: Contiene interfaces y clases que definen varias colecciones de
objetos, como listas, colas, matrices de bits, tablas hash y diccionarios.
 System.Configuration: Contiene los tipos que proporcionan el modelo de
programación para controlar los datos de configuración.

- 13 -
 System.Data: Proporciona acceso a las clases que representan la arquitectura de
ADO.NET. ADO.NET le permite generar componentes que administran eficazmente los
datos de varios orígenes de datos
 System.Drawing: Proporciona acceso a funcionalidad de gráficos básica de GDI+.
 System.Globalization: Contiene clases que definen información relativa a la referencia
cultural, incluido el idioma, el país o región, los calendarios utilizados, los modelos de
formato para las fechas, la moneda y los números y el criterio de ordenación de las
cadenas
 System.IO: Contiene tipos que permiten leer y escribir en los archivos y secuencias de
datos, así como tipos que proporcionan compatibilidad básica con los archivos y
directorios
 System.Net: Poporciona una interfaz de programación sencilla para muchos de los
protocolos que se utilizan actualmente en las redes.
 System.Secutity: Proporciona la estructura subyacente del sistema de seguridad de
Common Language Runtime, incluidas las clases base de los permisos.
 System.Text: Contiene clases que representan codificaciones de caracteres Unicode y
UTF-8
 System.Web: Contienen tipos que habilitan la comunicación entre el explorador y el
servidor en aplicaciones Web.
 System.Windows: Proporciona varias importantes clases de elementos base de
Aplicaciones Windows y Windows Presentation Foundation (WPF),
 System.XML: Proporciona compatibilidad basada en estándares para procesar XML

- 14 -
2- Microsoft Visual Studio.NET
Introducción
Visual Studio es un conjunto completo de herramientas de desarrollo para la generación de
aplicaciones web ASP.NET, Servicios Web, aplicaciones de escritorio y aplicaciones móviles.
Visual Basic, Visual C# y Visual C++ utilizan todos el mismo entorno de desarrollo integrado
(IDE), que habilita el uso compartido de herramientas y hace más sencilla la creación de
soluciones en varios lenguajes. Asimismo, dichos lenguajes utilizan las funciones de .NET
Framework, las cuales ofrecen acceso a tecnologías clave para simplificar el desarrollo de
aplicaciones web ASP y Servicios Web XML.
Características
 Un solo IDE (Integrated Development Environment)
 Soporte para varios lenguajes .NET (VB.NET, C#, etc.)
 Desarrollo de múltiples tipos de proyectos
 Explorador Web integrado (basado en IE)
 Interface personalizable
 Posee varias utilidades adicionales: Acceso a datos SQL Server, Depurador,
Intellisense, Emuladores para móviles, etc.

Proyectos y Soluciones
Visual Studio dispone de dos contenedores que le ayudan a administrar eficazmente los
elementos necesarios para el desarrollo, como referencias, conexiones de datos, carpetas y
archivos. Estos contenedores se denominan soluciones y proyectos. Asimismo, Visual Studio
proporciona carpetas de soluciones para organizar proyectos relacionados en grupos y, a
continuación, llevar a cabo acciones en esos grupos de proyectos
Los proyectos son contenedores que se ubican en una solución para administrar, compilar y
almacenar ítems. El contenido de los ítems depende del proyecto que se está desarrollando y
del lenguaje. Pueden ser archivos de código, imágenes, gráficos, etc.

Soluciones
Una solución permite a los desarrolladores concentrarse en la tarea de desarrollo y distribución
de los proyectos, en lugar de resolver detalles de administración de los archivos de proyecto y
los componentes.
Una solución de Visual Studio permite:
 Trabajar con varios proyectos en la misma instancia de Visual Studio
 Trabajar con ítems utilizando configuraciones y opciones que se aplican a un conjunto
de proyectos
 Utilizar el Explorador de Soluciones para diseñar y compilar la solución
Visual Studio genera automáticamente una solución cuando se crea un nuevo proyecto. Es
posible agregar nuevos proyectos a una solución a medida que se necesitan.
Para administrar los proyectos y archivos de una solución, el Explorador de Soluciones provee
una vista gráfica de toda la solución. También permite agregar carpetas de ítems que no
pertenecen al proyecto.
La definición de la solución se crea en dos archivos:
 Una definición de solución .sln
 Opciones de usuario de la solución .suo
Una solución puede contener varios proyectos que pueden ser abiertos, cerrados y salvados al
mismo tiempo. Cada proyecto en una solución puede contener varios archivos o ítems. Los
tipos de los ítems contenidos en un proyecto dependen del lenguaje de desarrollo utilizado.
La relación lógica entre una solución y sus componentes no reflejan, necesariamente, la forma
en la que la solución y sus componentes son almacenados en el disco. Si se crea una

- 15 -
aplicación que consta de varios proyectos, es recomendable crear una carpeta de solución
donde se almacenen todos los proyectos.

Plantillas de Proyectos
Visual Studio permite acceder a un número predefinido de plantillas. Al agregar diferentes
módulos, estos agregan plantillas. Las plantillas de proyectos permiten a los desarrolladores
concentrarse en la funcionalidad específica que se desea implementar y es desde el proyecto
donde se administra las diversas tareas referidas a la compilación, guardado y apertura.
Al instalar Visual Studio también se instalan una serie de plantillas de proyectos y elementos
predefinidas. Por ejemplo, las plantillas de la Biblioteca de clases y aplicaciones para Windows
de Visual Basic y Visual C# disponibles en el cuadro de diálogo Nuevo Proyecto son todas
ejemplos de plantillas de proyectos. Las plantillas de elementos instaladas están disponibles en
el cuadro de diálogo Agregar Nuevo Elemento e incluyen los elementos como archivos XML,
páginas HTML y Hojas de estilo.

- 16 -
Estas plantillas proporcionan un punto inicial a los usuarios para empezar a crear nuevos
proyectos o ampliar los proyectos actuales. Las plantillas de proyecto proporcionan los archivos
básicos necesarios para un tipo de proyecto determinado, para incluir referencias a
ensamblado estándar y establecer propiedades de proyecto y opciones de compilador
predeterminadas.
Las plantillas de elementos pueden abarcar desde un único archivo vacío con la extensión de
archivo correcta hasta un elemento de varios archivos que contenga elementos como archivos
de código fuente con código auxiliar, archivos de información de diseñador y recursos
incrustados.
Además de las plantillas instaladas disponibles en los cuadros de diálogo Nuevo proyecto y
Agregar nuevo elemento, puede crear sus propias plantillas o descargar y usar plantillas
creadas por la comunidad.
Para acceder a la plantilla de proyectos desde el menú: Archivos -> Nuevo Proyecto
Una vez seleccionado el tipo de proyecto, se deben completar campos que determinan
ubicación e identificación del proyecto y de la solución que lo contiene.
 Nombre: Determina el nombre del proyecto.
 Ubicación: Permite seleccionar la ubicación física de la Solución y Proyecto
 Solución: Da la opción de crear una nueva solución contenedora del proyecto o incluirlo
en una solución preexistente
 Nombre de la Solución: Nombre de la solución que se creará junto al proyecto. Por
defecto es el mismo nombre que el proyecto.

Tipos de Proyectos
A continuación se mencionan algunos tipos de proyectos disponibles:
 Aplicaciones de Windows (Windows Forms)
 Aplicaciones de Windows Presentation Foundation (WPF)
 Aplicaciones de consola.
 Aplicaciones de ASP.NET
 Servicios Web.

- 17 -
  Servicios de Windows
 Aplicaciones orientadas a servicios utilizando Windows Communication Foundation
(WCF).
 Aplicaciones habilitadas para el flujo de trabajo utilizando Windows Workflow
Foundation (WF).

Presentación del Entorno de Desarrollo (IDE)

El entorno de desarrollo integrado (IDE) es un conjunto de herramientas de desarrollo
expuestas a través de una interfaz de usuario común. Algunas de las herramientas se
comparten con otros lenguajes de Visual Studio, y otras, como el compilador de C#, son
exclusivas de Visual C#.
A continuación se detallan las herramientas y ventanas más importantes de Visual C#. Las
ventanas de la mayoría de estas herramientas se pueden abrir desde el menú Ver.
 El Editor de código, para escribir código fuente.
 El compilador de C#, para convertir el código fuente de C# en un programa ejecutable.
 El depurador de Visual Studio, para depurar el programa.
 El Cuadro de herramientas y el Diseñador, para desarrollar rápidamente interfaces de
usuario con el mouse.
 El Explorador de soluciones, para ver y administrar archivos de proyecto y
configuraciones.
 El Diseñador de proyectos, para configurar opciones del compilador, rutas de
implementación, recursos, etc.
 La Vista de clases, para navegar por el código fuente según los tipos, no los archivos.
 La ventana Propiedades, para configurar propiedades y eventos en los controles de la
interfaz de usuario.
 El Explorador de objetos, para ver los métodos y clases disponibles en las bibliotecas
de vínculos dinámicos, incluidos los ensamblados de .NET Framework y los objetos
COM.
 Esquema de Documentos, proporciona una vista esquemática de los elementos y
secuencias de comandos del documento actual.

- 18 -
Explorador de soluciones

La ventana de la parte superior derecha es el

Explorador de soluciones, que muestra todos los
archivos del proyecto en una vista de árbol jerárquica.
Cuando se utiliza el menú Proyecto para agregar
nuevos archivos al proyecto, se verán reflejados en el
Explorador de soluciones. Además de los archivos, el
Explorador de soluciones también muestra la
configuración del proyecto y las referencias a las
bibliotecas externas que necesita la aplicación.
Para obtener acceso a las páginas de propiedades del
Diseñador de proyectos, haga clic con el botón
secundario del mouse en el nodo Propiedades del
Explorador de soluciones y, a continuación, haga clic
en Abrir. Utilice estas páginas para modificar opciones
de generación, requisitos de seguridad, detalles de
implementación y muchas otras propiedades del
proyecto.

Ventanas del Editor y del Diseñador de Windows Forms

- 19 -
 Permite escribir el código y desarrollar las interfaces
de usuario.
El Código Editor, el Diseñador de Windows Forms o
el Diseñador de Windows Presentation Foundation
(WPF) utilizan la ventana principal grande. Puede
cambiar entre la vista Código y la vista Diseño
haciendo clic en Código o Diseñador en el menú
Ver, o utilizando los métodos abreviados de teclado
F7 o MAYÚS + F7. En la vista Diseño, puede
arrastrar controles a la ventana desde el Cuadro de
herramientas, que se puede hacer visible haciendo
clic en la ficha Cuadro de herramientas del margen
izquierdo.

Características del Editor de Código

 Fragmentos de Código (Code Snippets): Los fragmentos de código están listos para
usar y se pueden insertar rápidamente en el código. Para insertar un fragmento
seleccionar botón derecho Insertar Fragmento de Código y elegir el fragmento de la
lista proporcionada
 Smart Tags: Habilita las áreas más comunes para aplicarlas dentro del contexto de
trabajo.
 Intellisense: Ofrece una serie de características que facilitan el acceso a referencias
del lenguaje. Permite realizar búsquedas en elementos del lenguaje.
 Refactorización: La refactorización es el proceso que consiste en mejorar el código
una vez escrito cambiando su estructura interna sin modificar su comportamiento
externo.
 Seguimiento de Cambios: Cuando el margen izquierdo está pintado de amarillo
significa que la línea fue editada y no ha sido grabada. Si el margen es verde significa
que el código ha sido grabado recientemente.
 Marcadores (Bookmarks): Puede utilizar marcadores para marcar líneas en el código
de forma que pueda volver rápidamente a una ubicación concreta y saltar de sentidos
entre las ubicaciones

Refactorización
 Extraer Métodos: Proporciona una manera sencilla para crear un nuevo método a
partir de un fragmento de código existente
 Cambiar Nombres: Ofrece una manera sencilla de cambiar el nombre a los
identificadores de los símbolos de código, como campos, variables locales, métodos,
espacios de nombres, propiedades y tipos
 Encapsular Campos: Permite crear rápidamente una propiedad a partir de un campo
existente
 Extraer Interfaz: Ofrece una manera sencilla de crear una nueva interfaz con
miembros originados a partir de una clase, estructura o interfaz existente
 Quitar Parámetros: Proporciona una forma sencilla para quitar parámetros de
métodos. Cambia la declaración; en cualquier ubicación en la que se llame al miembro,
se quitará el parámetro para reflejar la nueva declaración
 Reordenar parámetros: Proporciona una manera sencilla de cambiar el orden de los
parámetros para los métodos. Cambia la declaración y, en todas las ubicaciones donde
se llama al miembro, los parámetros se reorganizan para reflejar el nuevo orden

- 20 -
Ventana de Propiedades

Permite establecer las propiedades y enlazar los

eventos para los controles de la interfaz de usuario,
como botones, cuadros de texto, etc.

Cuadro de herramientas

El Cuadro de herramientas muestra los iconos de los

elementos que puede agregar a los proyectos Visual
Studio.
Cada icono del Cuadro de herramientas se puede arrastrar
y colocar en una superficie de vista de diseño; o bien,
copiarse y pegarse en un editor de código dentro del
entorno de desarrollo integrado (IDE) de Visual Studio.
Cualquier acción agrega el código básico para crear una
instancia del elemento del Cuadro de herramientas en el
archivo del proyecto activo.

- 21 -
Referencias de Proyectos
Para poder escribir un código que trabaje con un componente externo, el proyecto debe
contener en primer lugar una referencia al mismo. Puede hacer referencia a los siguientes tipos
de componentes:
 Bibliotecas de clases o ensamblados de .NET Framework
 Componentes COM
 Otros ensamblados o bibliotecas de clases de proyectos de la misma solución
 Servicios Web XML
Use Agregar referencia (Cuadro de diálogo) para agregar referencias a los componentes en
tiempo de diseño. También puede utilizar el cuadro de diálogo Agregar referencia para ir a
ensamblados que no se muestren. No puede agregar referencias de Caché de ensamblados
global (GAC), ya que forma parte estrictamente del entorno de tiempo de ejecución.

Lenguajes de Visual Studio .Net

Visual Basic .Net
Rescrito por completo para trabajar bajo .NET. Ahora totalmente orientado a objetos.
Características:
 Sintaxis similar a Visual Basic de versiones anteriores
 Herencia, Sobrecarga, Constructores y miembros estáticos
 Administración estructurada de excepciones
 Comprobación de Tipos
 Incluye IntelliSense.

C#
Fue un lenguaje creado especialmente para .NET. Totalmente orientado a objetos.
Características:
 Sintaxis similar a C++, Java

- 22 -
  Basada en signos de llaves {}
 Tipos seguros
 Sensible a mayúsculas y minúsculas
 Todo es tratado como objetos
 Las líneas finaliza con un ; (punto y coma)
 Incluye IntelliSense.

Visual C++
Permite la generación de código C++, que no sea manejado por el CRL (.Net Framework)
Características:
 Lenguaje Orientado a Objeto
 Compatible con COM y con integración de código de plataformas.
 Incluye seguridad de tipos.
 Proporciona seguridad por medio de mecanismos de confianza intrínsecos del código.
 Compatible con componentes XML basados en Web y conceptos de metadatos
extensibles.
 Interoperabilidad con otros lenguajes, entre plataformas y con datos heredados.
 Capacidad de control de versiones para facilitar la administración y la implementación.
 Incluye IntelliSense.

Elección del Lenguaje

Prácticamente no hay diferencias de performance entre lenguajes ya que todos compilan en
MSIL
La elección del lenguaje dependerá de su experiencia previa con otros lenguajes o decisión
personal.
 Si conoce Java, C++, etc. >> C# (nuestra elección)
 Si conoce VB o VBScript >> VB.NET

- 23 -
3- Introducción a Aplicaciones Windows

Introducción
Windows Forms es una de las dos tecnologías que se utiliza en Visual C# para crear
aplicaciones cliente inteligentes basadas en Windows que se ejecutan en .NET Framework.
Windows Forms es especialmente adecuado para escenarios de desarrollo rápido de
aplicaciones donde la prioridad principal no es una interfaz gráfica de usuario compleja.

Formularios Windows
Un formulario es una superficie visual en la que se muestra información al usuario.
Normalmente las aplicaciones de Windows Forms se generan agregando controles a los
formularios y programando respuestas a las acciones del usuario, como clics del mouse (ratón)
o presiones de teclas. Un control es un elemento de la interfaz de usuario discreto que muestra
datos o acepta la entrada de datos.
Cuando un usuario hace algo en su formulario o en alguno de sus controles, la acción genera
un evento. La aplicación reacciona a estos eventos utilizando código y procesa los eventos
cuando aparecen.
Los formularios Windows Forms contienen diversos controles que puede agregar a los
formularios: controles que muestran cuadros de texto, botones, cuadros desplegables, botones
de opción e incluso páginas Web.
Con el Diseñador de Windows Forms de arrastrar y colocar de Visual Studio, puede crear con
facilidad aplicaciones de Windows Forms. Simplemente seleccione los controles con el cursor y
agréguelos donde desee en el formulario. El diseñador dispone de herramientas como líneas
de cuadrícula y líneas de ajuste para minimizar la molestia de alinear los controles.
Su evento más usado es el evento Load que se ejecuta al cargar el formulario en memoria.
Algunas de sus propiedades son: Text, Enabled, FormBorderStyle, Icon, MaximizeBox,
MinimizeBox, ControlBox, Size, StartPosition y WindowsState.

Controles
Los controles de los formularios Windows Forms son componentes reutilizables que
encapsulan funciones de la interfaz de usuario y se utilizan en aplicaciones Windows cliente.
Estos formularios Windows Forms no sólo proporcionan varios controles listos para usar, sino
que también proporcionan la infraestructura para desarrollar controles personalizados. Los
controles existentes se pueden combinar entre sí o ampliar, también se pueden crear otros
controles personalizados.

Control Button

- 24 -
Representa un control de botón de Windows.
Se puede hacer clic en Button utilizando el mouse (ratón), la tecla Enter o la barra espaciadora
si el botón tiene foco.
Es posible cambiar la apariencia del botón.
Su evento más usado es el evento Click. Propiedades que se configuran habitualmente: Text,
Enabled, Font, Image, TextAlign, etc.

Control TextBox

Representa un control de cuadro de texto de Windows.

Con el control TextBox, el usuario puede escribir texto en una aplicación. Este control tiene
funcionalidad adicional que no se encuentra en el control de cuadro de texto de Windows
estándar, como el enmascaramiento de caracteres de contraseña y la edición de múltiples
líneas.
Las propiedades que generalmente se configuran son: Text, TextAlign, Enabled, BackColor,
ForeColor, Size, PasswordChar, MultiLine, ReadOnly y MaxLength.

Control Label

Representa una etiqueta estándar de Windows

Los controles Label se utilizan normalmente para proporcionar texto descriptivo de un control.
Por ejemplo, se puede utilizar un objeto Label para agregar texto descriptivo para un control
TextBox e informar al usuario del tipo de datos que se espera tener en el control. Los controles
Label se pueden utilizar también para agregar texto descriptivo a un Form para proporcionar al
usuario información útil. Por ejemplo, se puede agregar Label en la parte superior de Form que
proporciona al usuario instrucciones sobre cómo especificar datos en los controles del
formulario. Los controles Label se pueden utilizar también para mostrar información en tiempo
de ejecución sobre el estado de una aplicación. Por ejemplo, se puede agregar un control Label
a un formulario para mostrar el estado de cada archivo cuando se procesa una lista de
archivos.
Las propiedades que generalmente se configuran son: Text, TextAlign, Enabled, BackColor,
ForeColor, AutoSize, etc.

Control ComboBox

Representa un control de cuadro combinado de Windows

Un ComboBox muestra un campo de edición de cuadro de texto combinado con un ListBox y
permite al usuario seleccionar elementos de la lista o escribir texto nuevo. El comportamiento
predeterminado de ComboBox es mostrar un campo de edición con una lista desplegable
oculta. La propiedad DropDownStyle determina el estilo que mostrará el cuadro combinado.
La propiedad Items permite ingresar la lista de valores

- 25 -
Control ListBox

Representa un control de Windows para mostrar una lista de elementos.

El control ListBox permite mostrar una lista de elementos para que el usuario los seleccione
haciendo clic en ellos. Un control ListBox puede proporcionar una o varias selecciones
mediante la propiedad SelectionMode. La propiedad Items permite ingresar la lista de valores

Control RadioButton

Permite al usuario seleccionar una única opción entre un grupo de elecciones cuando se
emparejan con otros controles RadioButton.
Cuando el usuario selecciona un botón de opción dentro de un grupo, los otros se borran
automáticamente. Todos los controles RadioButton de un contenedor determinado, como Form,
constituyen un grupo. Para crear varios grupos en un formulario, coloque cada grupo en su
propio contenedor, como un control GroupBox o Panel.
La propiedad Checked permite saber si la opción esta seleccionada o no.

Control CheckBox

Utilice un control CheckBox para dar al usuario una opción del tipo verdadero/falso o sí/no. El
control CheckBox de casilla de verificación puede mostrar una imagen o texto, o ambos.
La propiedad Checked permite saber si la opción esta seleccionada o no

MessageBox
Muestra un cuadro de mensaje que puede contener texto, botones y símbolos que informan e
instruyen al usuario.

MessageBox.Show("Aca se ingresa el mensaje a mostrar.", "Titulo de la

Ventana", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);

- 26 -
Introducción a Eventos
Un evento es una acción a la que se puede responder o que se puede "controlar" mediante
código. Los eventos se pueden generar mediante una acción del usuario, por ejemplo,
haciendo clic con el mouse (ratón) o presionando una tecla, mediante código del programa o
mediante el sistema.
Las aplicaciones controladas por eventos ejecutan código en respuesta a los eventos. Cada
formulario y cada control exponen un conjunto de eventos predefinido que se puede utilizar al
programar. Si se produce uno de estos eventos y hay código en el controlador de eventos
asociado, se invocará este código.
Los tipos de eventos que produce un objeto varían, pero muchos tipos son comunes a la
mayoría de los controles. Por ejemplo, la mayoría de los objetos controlan un evento Click

private void button1_Click(object sender, EventArgs e)

{
MessageBox.Show("Mensaje en el evento click del button");
}

- 27 -
 Módulo II

Introducción al lenguaje
C#

- 28 -
1- Introducción a C#
Definición
La estructura de un lenguaje de programación específica los elementos que debe incluir en su
aplicación y define cómo organizar estos elementos para que el compilador entienda su código.
El siguiente código muestra la estructura básica de una aplicación C#:

using System;
class HelloWorld
{
static void Main()
{
Console.WriteLine("Hola Mundo");
}
}

Los elementos y los principios de organización que se muestran en las seis líneas de código
anteriores son brevemente descriptas línea por línea en las siguientes secciones.
 La palabra reservada using: Hace referencia a recursos de la biblioteca del .NET
Framework de Microsoft. Se utiliza para crear un alias para un espacio de nombres o
para importar tipos definidos en otros espacios de nombres.
 El espacio de nombres (namespace) System: System es el espacio de nombres que
provee acceso a toda la funcionalidad de sistema sobre la cual se construye la
aplicación.
 Class: Programar en C#, o en cualquier lenguaje orientado a objetos, consiste en
escribir clases, las cuales se usan para crear objetos. En el ejemplo de código, la clase
se llama HelloWorld.
 El método Main: Los métodos describen el comportamiento de una clase. En la tercera
línea, static void Main es un método global que le dice al compilador donde comienza la
ejecución de la aplicación. Toda aplicación C# debe incluir un método Main en una de
las clases. Normalmente el método Main se encuentra en Program.cs

Sentencias
Las sentencias son instrucciones que se completan para realizar acciones en aplicaciones C#.
Las sentencias están separadas entre sí por un punto y coma, para permitir al compilador
distinguir unas de otras.
Algunos lenguajes ubican una sentencia por línea. En C#, usted puede incluir múltiples
sentencias en una línea, o una sentencia en múltiples líneas. Es buena práctica escribir una
sentencia por línea; aunque, por cuestiones de legibilidad, es mejor dividir una sentencia larga
en varias líneas.

Llaves
Las llaves {} se usan para identificar el comienzo y el final de bloques de código en una
aplicación. Cada llave que abre debe tener su correspondiente llave que cierra.
En el ejemplo, las llaves que siguen a “class HelloWorld” encierran los ítems que están dentro
de la clase HelloWorld. Las llaves que siguen a “Main” se usan para encerrar las sentencias
que están en el método Main.
Microsoft Visual Studio® .NET provee varias señales para asegurarse que sus llaves estén
correctamente cerradas. Cuando se escribe una llave que cierra, los elementos que encierra
aparecen en negrita por un instante. También, los indicadores que están en el margen
izquierdo del documento muestran el alcance del grupo de sentencias.

- 29 -
Como dar formato a un código en C#
Dar formato es otro elemento del programa, diseñado para ayudar a organizar su código. Se
fomenta el uso de convenciones para mejorar la estructura y la legibilidad de su código.

Ejemplo
El código demuestra cómo aplicar los principios de indentación, sensibilidad a mayúsculas y
minúsculas, espacios en blanco y comentarios:

using System;
class HelloWorld
{
static void Main()
{
Console.WriteLine("Hola Mundo");
//escribe Hola Mundo
}
}

Indentación
La indentación indica que la sentencia se encuentra dentro de un mismo grupo de sentencias.
Las sentencias que están en un mismo grupo o bloque deberían estar indentadas al mismo
nivel. Esta es una convención importante que mejora la legibilidad de su código. Aunque la
indentación no es obligatoria, o requerida por el compilador, es una práctica recomendada.

Sensibilidad a mayúsculas y minúsculas

C# es sensible a mayúsculas y minúsculas, lo que significa que el compilador distingue entre
caracteres en mayúscula y minúscula. Por ejemplo, las palabras “programa”, “Programa” y
“PROGRAMA” se consideran diferentes en una aplicación, no se puede sustituir una por otras.

Espacio en blanco
El espacio en blanco es ignorado por el compilador. Por eso, se pueden usar espacios en
blanco para mejorar la legibilidad y el formato del código. La única excepción es que el
compilador no ignora los espacios entre comillas.

Comentarios
Se pueden incluir comentarios de una sola línea en una aplicación insertando una doble barra
(//) seguida del comentario.
Alternativamente, si su comentario es muy largo y ocupa múltiples líneas, puede usar barra
asterisco (/*) para indicar el comienzo de un comentario y asterisco barra (*/) para indicar el
final de su comentario.
El siguiente ejemplo es un comentario de múltiples líneas que incluye un asterisco al principio
de cada línea. Estos asteriscos son opcionales y puede incluirlos para hacer que el comentario
sea más fácil de identificar.

/*
* Comentario de múltiples líneas
* Este ejemplo muestra cómo dar formato a un
* comentario de múltiples líneas en C#
*/
/* uso alternativo de este comentario */

- 30 -
Diseño
Usted puede ubicar la llave que abre al final de la línea en que comienza el grupo, o puede
ubicar la llave en la siguiente línea del método o clase, tal como se muestra en el siguiente
ejemplo:

using System;
class HelloWorld
{
static void Main()
{
Console.WriteLine("Hello, World");
}
}

Ambos diseños son aceptados y correctos. Sin embargo, es importante ser consistente.
Su organización debería elegir qué diseño usar.

- 31 -
2- Tipo de Datos Predefinidos
Introducción
Cada vez que su aplicación deba almacenar datos temporalmente para usarlos durante la
ejecución, se almacenan en variables. Puede pensar una variable como si fuera una caja de
almacenamiento. Las cajas vienen en diferentes tamaños y formas, llamados tipos, éstos
proveen almacenamiento para varios tipos de datos. Por ejemplo, el tipo de variable usado
para almacenar un nombre es diferente al que se usa para guardar la edad de la persona.

Tipos de Datos
Los tipos predefinidos son aquellos provistos por el lenguaje C# y .NET Framework. La
siguiente tabla lista los tipos predefinidos y describe los datos que están diseñados para
almacenar.

Tipo predefinido Definición #Bytes

Byte Enteros de 0 a 255 1
Sbyte Enteros de -128 a 127 1
Short (Int16) Enteros de -32768 y 32767 2
Ushort (UInt16) Enteros de 0 y 65535 2
Int (Int32) Enteros de -2147483648 y 2147483647 4
Uint (UInt32) Enteros de 0 y 4294967295 4
Long (Int64) Enteros de -9223372036854775808 y 9223372036854775807 8
Ulong (UInt64) Enteros de 0 y 18446744073709551615 8
Bool Booleano: true o false 1
Float Punto flotante de precisión simple 4
Double Punto flotante de precisión doble 8
Decimal Decimal con 28 dígitos (punto fijo) 12
Object Tipo Base para todos otros tipos N/A
Char Carácter Unicode simple entre 0 y 65535 2
String Secuencia ilimitada de caracteres Unicode N/A
DateTime Para fechas y hora 8

Almacenado Datos
Suponga que está escribiendo una aplicación que permite al usuario comprar ítems por Internet
con tarjeta de crédito. Su aplicación debe administrar varias piezas de información: el nombre
de la persona, el monto de compra, el número de la tarjeta de crédito y la fecha de expiración
de la tarjeta. Para representar esta información, su aplicación usa distintos tipos.

Eligiendo un tipo
Deje que el dato que está representando determine la elección del tipo. Por ejemplo, si algo
puede ser solo verdadero o falso, use bool. Decimal es una buena elección para dinero o
cualquier valor con decimales. Es preferible no usar los tipos de datos de punto flotante para no
generar problemas con los redondeos. Cuando se trabaje con enteros, un int es la elección
típica, a menos que haya una razón para elegir otro tipo.
Además de los tipos predefinidos, usted puede definir sus propios tipos para contener cualquier
dato que elija.

- 32 -
Variables
Una variable es un espacio de almacenamiento para un tipo en particular. Por ejemplo, si su
aplicación debe procesar un valor de dinero, requiere una variable que soporte ese valor.
Antes de usar una variable, debe declararla. Al declarar una variable, usted está reservando
espacio de almacenamiento para esa variable en memoria. Después de declarar una variable,
debe inicializarla asignándole un valor.
La sintaxis para declarar una variable es el tipo de declaración seguido del nombre de la
variable. Por ejemplo:

int miEntero;
bool archivoFueCerrado;

Nombres de variables
La siguiente lista identifica algunas buenas prácticas para nombrar variables:

 Asignar nombres significativos.

 Usar la notación camello. En la notación camello la primera letra del identificador es
minúscula y la primer letra de cada palabra siguiente en el identificador es mayúscula,
como nuevaCuentaBancaria.
 No usar palabras reservadas de C#.
 Aunque C# sea sensible a mayúsculas y minúsculas, no crear variables que difieran
solo en ello.

Inicializando variables
Para inicializar una variable, se le asigna un valor. Para asignar un valor, usar el operador (=)
seguido del valor, y luego un punto y coma, como se muestra en el siguiente ejemplo:

int miVariable;
miVariable = 1;

Se puede combinar estos pasos, por ejemplo:

int miVariable = 1;

Más ejemplos de declaraciones de variables se muestran en el siguiente código:

int x = 25;
int y = 50;
bool estaAbierto = false;
sbyte b = -55;

Asignando valores literales

Cuando se asigna 25 a x en el código anterior, el compilador asigna el valor literal 25 en la
variable x. No obstante, la siguiente asignación genera un error de compilación:

decimal bankBalance = 3433.20;

// ERROR!

Este código causa un error porque el compilador de C# asume que cualquier número literal con
un punto decimal es un double (tipo de dato double), a menos que se especifique que es un
decimal. Se especifica el tipo de literal agregando el sufijo, como se muestra en el siguiente
ejemplo:

- 33 -
decimal balance= 3433.20M;

Los sufijos de literales que se pueden usar se muestran en la siguiente tabla. Se permiten
minúsculas:

Categoría Sufijo Descripción

Entero U Sin signo

L Long
UL Long sin signo
Número Real F Float
D Double
M Decimal
L Long

Tipo Caracteres
Un carácter (tipo char) se especifica entre comillas simples:

char miInicial = 'a';

Caracteres de Escape
Algunos caracteres no se pueden especificar usando comillas simples, por ejemplo, un carácter
de nueva línea o un beep o una comilla simple. Para representar estos caracteres, se debe
usar caracteres de escape, los cuales se muestran en la siguiente tabla:

Secuencia de escape Nombre del character

\' Comilla simple
\" Comilla doble
\\ Barra invertida
\0 Null
\a Alerta
\b Retroceso
\f Avance
\n Línea Nueva
\t Tabulación Horizontal
\v Tabulación Vertical

Por ejemplo, se puede especificar una comilla simple como sigue:

char comillaSimple = '\'';

Examinando variables en Visual Studio .NET (Depuración)

El entorno de desarrollo de Visual Studio .NET provee herramientas útiles para examinar el
valor de las variables mientras su aplicación esta ejecutándose.
Para examinar el valor de una variable, ubicar un breakpoint en la variable que usted desea
examinar, corra la aplicación en modo Debug, y luego usar la herramienta de Debug para ver
los valores.

- 34 -
 1. Ubicar un breakpoint haciendo click en el margen izquierdo de la ventana de código. El
breakpoint queda indicado como un punto rojo. Ud. puede ubicar un breakpoint
haciendo click en New Breakpoint en el menú Debug.

2. Ejecutar su aplicación en modo Debug

3. Su aplicación se ejecutará hasta que encuentre un breakpoint. Cuando la aplicación

encuentra un breakpoint, se pausa, y el entorno de desarrollo marca la línea próxima a
ejecutarse
4. Usar el menú Debug para ver el valor de la variable o simplemente posicione el cursor
sobre la misma. Para abrir las ventanas de Debug, en el menú Debug, seleccionar
Windows, y luego hacer click en Autos o en Locals

La ventana Autos muestra las variables usadas en la sentencia actual y la próxima. Por
defecto, la ventana Autos se visualiza abajo del entorno de desarrollo cuando se encuentra
en modo debug.

La ventana Locals muestra las variables locales.

5. Para pasar al próximo breakpoint, cuando esté listo de continuar ejecutando su programa,
puede presionar F5 o hacer click en Continue en el menú Debug. O puede ejecutar el
programa paso a paso presionando F11 o F10, o haciendo click en Step Over del del menú
Debug
6. Para pasar al próximo breakpoint, cuando usted esté listo

- 35 -
Tipo de Dato string
La cadena (string) es uno de los tipos de datos más comúnmente usado. Una variable string
contiene una secuencia de caracteres alfanuméricos que son usados como entrada para
cálculos o búsquedas.
Nota: No hay límite en el número de caracteres que conforman una cadena.

Una cadena se declara como cualquier otra variable, se asigna el tipo (string) y se le da un
nombre. Se puede asignar un valor literal a una variable string encerrando el valor entre
comillas dobles.

string saludo = "Hola Mundo";

También se pueden incluir caracteres de escape en un string. Por ejemplo, si Ud. desea crear
un string escrito en dos líneas, puede incluir un retorno de línea en el string usando el carácter
\n, como se muestra en el siguiente ejemplo:

string saludo = "Hola \nMundo";

Este código produce la siguiente salida:

Hola
Mundo

Si Ud. quiere insertar una tabulación, use el carácter de escape \t, como se muestra en el
siguiente ejemplo:

string saludo = "Hola \tMundo"; //produce Hola Mundo

string ruta = "c:\\My Documents\\sample.txt";
// produces c:\My Documents\sample.txt

Usando cadenas literales

Una cadena literal es un string que es interpretado por el compilador exactamente como esté
escrito, lo que significa que aún cuando la cadena ocupe múltiples líneas o incluya caracteres
de escape, éstos no son interpretados por el compilador y son incluidos en la salida. La única
excepción son las comillas dobles, que deben ser interpretadas por el compilador para que
pueda reconocer dónde termina la cadena.
Una cadena literal se indica con el símbolo (@) seguido de la cadena entre comillas dobles.
Por ejemplo:

string saludo = @"Hola";

string saludo = @"Hola\tMundo"; // produces "Hola\tMundo"
string ruta = @"c:\My Documents\sample.txt";
// produce c:\My Documents\sample.txt

Si se desea usar comillas dobles dentro de la cadena literal, se debe agregar otro par de
comillas dobles. Por ejemplo, para producir “Hola” se usa es siguiente código:

string s = @"""Hola"""; // Nota: tres comillas dobles de cada lado

El código anterior produce la salida:

"Hola"

- 36 -
Entendiendo Unicode
El .NET Framework usa Unicode UTF-16 (Unicode Transformation Format, 16-bit encoding
form) para representar caracteres. C# también codifica caracteres usando el estándar de
Unicode. El estándar de Unicode es el mecanismo universal actual de codificación que se usa
para representar texto en el procesamiento de computación. El estándar anterior era ASCII. El
estándar Unicode representa un avance significativo sobre ASCII porque Unicode asigna un
valor numérico único, llamado punto de código, y un nombre a cada carácter que se usa en
todos los lenguajes del mundo. ASCII define solo 128 caracteres, lo que significaba que
algunos lenguajes no se podían representar correctamente en una aplicación.
Por ejemplo, el carácter “A” se representa por el código de punto “U+0041” y el nombre “LATIN
CAPITAL LETTER A”. Los valores están disponibles para más de 65.000 caracteres, y hay
espacio para soportar hasta un millón más. Para más información, ver el estándar Unicode en
www.unicode.org.

Constantes
Una constante es una variable cuyo valor no puede modificarse. Las constantes son útiles en
situaciones donde el valor que se usa tiene un significado y es fijo, como el número pi, el radio
de la Tierra, o el porcentaje de un impuesto.
Las constantes hacen su código mas legible, mantenible y robusto. Por ejemplo, si asigna el
valor 6378 a la constante llamada radioTierra, cuando use este valor en cálculos es
inmediatamente aparente qué valor se está haciendo referencia, y no es posible asignarle un
valor distinto por otra persona.
Una constante se declara usando la palabra clave y el tipo. Se debe asignar un valor a la
constante en el momento de la declaración.

Ejemplos:
const int radioDeLaTierra = 6378; //km
const long distanciaAlSol = 149600000; //km
const double velocidadOrbital = 29.79D; //km seg

Enumeraciones
Una enumeración especifica un grupo de constantes. Una enumeración es un tipo definido por
usuario, lo que significa que usted puede crear una enumeración, declarar variables de ese tipo
y asignar valores a esas variables. El propósito de una enumeración es representar valores
constantes.
Además de proveer todas las ventajas de las constantes, las enumeraciones:
 Hacen que su código sea más fácil de mantener asegurando que a sus variables se
asignen solamente valores anticipados.
 Permiten que usted asigne nombres fácilmente identificables a sus valores, haciendo
que su código sea más fácil de leer.
 Hacen que su código sea más fácil de escribir, porque se asignan valores de la
enumeración., ya que muestra una lista de posibles valores que usted puede usar.
 Permiten que especifique un set de valores constantes y defina un tipo que acepte
valores solamente de ese set.
Usted crea una enumeración usando la palabra clave enum, asignando un nombre, y luego
listando los valores que su enumeración puede tomar.
Es recomendable que use la notación Pascal, para el tipo y para cada miembro de la
enumeración. En la notación Pascal, la primera letra de cada palabra del identificador se
escribe con mayúscula, como ListaDePlanetas.

Ejemplo

- 37 -
enum Planeta
{
Mercurio,
Venus,
Tierra,
Marte
}

El código anterior crea un nuevo tipo, Planeta. Ud. puede crear variables de este tipo y
asignarles un valor de la lista de la enumeración.
Cuando usted quiera hacer referencia a un miembro en una enumeración, use el nombre de la
enumeración, un punto y el nombre del miembro.

Por ejemplo: el siguiente código declara una variable planetaInterno de tipo Planeta, y le asigna
un valor:

Planeta planetaInterno = Planeta.Venus;

Usted puede declarar una enumeración en una clase o en un espacio de nombre, pero no
dentro de un método.
Si los miembros de su enumeración deben tener un valor específico, usted puede asignar a
miembros de una enumeración esos valores en la declaración. El siguiente código asigna el
valor del radio de cada planeta interno:

enum Planetas
{
Mercurio = 2437,
Venus = 6095,
Tierra = 6378
}

Usted puede usar cualquier entero como tipo base que se usará para la enumeración
especificando el tipo luego del nombre de la enumeración. Por ejemplo:

enum Planetas : uint

{
Mercurio = 2437,
Venus = 6095,
Tierra = 6378
}

Conversión de Datos
Cuando se diseña aplicaciones, a menudo se debe convertir un dato de un tipo a otro. La
conversión puede ser necesaria cuando se realizan operaciones con dos tipos distintos.
Por ejemplo, cuando se ingresa un valor numérico en una página web, el tipo de dato puede
ser texto. Un programador debe entonces convertir ese texto a un tipo numérico.
Otra razón para convertir es evitar el desbordamiento (overflow). Si usted trata de sumar dos
bytes, el compilador retorna un int. Retorna un int porque el byte puede mantener solo 8 bits,
hasta un valor de 255, entonces el resultado de sumar dos bytes podría resultar fácilmente en
un número mayor de 255 (int=byte+byte). Por esta razón, el valor resultante de la suma es
convertido por el compilador y devuelto como un int.
Hay dos tipos de conversiones en el .NET Framework: implícitas y explícitas.

- 38 -
  Una conversión implícita es automáticamente realizada por la CLR (Common
Language Runtime) sobre operaciones que garantizan no truncar información.
 En una conversión explícita se solicita explícitamente al compilador a realizar una
conversión, que de otra forma podría perder información o produciría un error.

Conversiones implícitas
La siguiente tabla muestra los tipos de conversión implícita que soporta C#:

De A
Sbyte short, int, long, float, double, decimal
Byte short, ushort, int, uint, long, ulong, float, double, decimal
Short int, long, float, double, decimal
Ushort int, uint, long, ulong, float, double, decimal
Int long, float, double, decimal
Uint long, ulong, float, double, decimal
long, ulong float, double, decimal
Float Double
Char ushort, int, uint, long, ulong, float, double, decimal

Notar que las conversiones implícitas pueden ser realizadas desde un tipo pequeño a otro más
grande o desde un entero sin signo a un entero con signo.

Ejemplo
El siguiente ejemplo muestra una conversión implícita:

int x = 123456; // int es un entero de 4 bytes

long y = x; // conversión implícita a un long

Conversión explícita
La sintaxis para realizar una conversión explícita se muestra en el siguiente código:

tipo variable1 = (tipo) variable2;

El tipo entre paréntesis indica al compilador que el valor de la derecha (variable2) es convertido
al tipo que está especificado entre paréntesis.

Ejemplo
El siguiente ejemplo muestra una conversión explícita:

int x = 500;
short z = (short) x;
// conversión explícita a un short, z contiene el valor 500

Es importante recordar que las conversiones explícitas pueden resultar en pérdida de datos o
generar errores si los tipos de datos o los valores asignados no son compatibles. Por ejemplo,
en el siguiente código, un decimal es explícitamente convertido a un int:

decimal d = 1234.56M;
int x = (int) d;

El resultado de esta conversión es que a x se le asigna el valor 1234.

- 39 -
Otras conversiones
La biblioteca de clases de .NET Framework provee un soporte para tipos de conversiones en la
clase System.Convert.

int x = 500;
short z = System.Convert.ToInt16(x);

Expresiones y Operadores
El propósito de escribir una expresión es realizar una acción y retornar un valor. Por ejemplo,
usted puede escribir una expresión para hacer un cálculo matemático, asignar un valor o
comparar dos valores:
Una expresión es una secuencia de operadores y operandos. Un operador es un símbolo
determinador que indica la acción que usted quiere que ocurra en su expresión. Un operando
es el valor sobre el cual la operación es realizada. Un operador está específicamente diseñado
para producir un nuevo valor en base al operando.

Tipos de operadores:
 Aritméticos: Usados para realizar cálculos aritméticos como la suma.
 De Comparación: Usados para comparar si un valor es mayor, mayor o igual, menor,
menor o igual a otro.
 Lógicos: Usados para definir situaciones and/or.
 Condicional: Usado para realizar una sentencia if.
 De Asignación: Usado para asignar un valor a una variable.

La mayoría de los operadores solamente se usan con datos numéricos, pero otros también se
usan para cadenas.
La siguiente tabla lista todos los operadores que se pueden usar en C#:

Tipo de Operador
Operador
Primario (x), x.y, f(x), a[x], x++, x--, new, typeof, sizeof, checked,unchecked
Unario +, -, !, ~, ++x, --x, (T)x
Matemático + , - ,*, /, %
Desplazamiento << , >>
Comparación < , > , <= , >= , is
Igualdad ==
Lógico &,|,^
Condicional && , || , ?
Asignación = , *= , /= , %= , += , -= , <<=, >>= , &= , ^= , |=

Nota
Es importante notar la diferencia entre el operador de asignación y el operador de igualdad.
Notar que “es igual a” se representa con dos signos igual (==) porque un solo signo (=) se usa
para asignar un valor.

int x = 10;
// asignación
int y = 20;
int z = x + y;
// (z == 30) z es igual a 30?

- 40 -
C# hace posible usar una sintaxis concisa para manipular datos en forma compleja. La
siguiente tabla muestra cómo realizar operaciones en una forma más corta.

Forma corta Expresión idéntica

x++ , ++x x=x+1
x--, --x x=x-1
x += y x=x+y
x -= y x=x–y
x *= y x=x*y
x /= y x=x/y
x %= y x=x%y
x >>= y x = x >> y
x <<= y x = x << y
x &= y x=x&y
x |= y x=x|y
x ^= y x=x^y

Incremento y decremento
Los operadores de incremento y decremento pueden usarse antes o después del operando.
Por ejemplo, x++ y ++x son ambos equivalentes a x=x+1. Sin embargo, cuando estos
operadores se usan en expresiones, x++ y ++x se comportan de manera diferente. ++x
incrementa el valor de x antes de que la expresión sea evaluada. Es decir, se incrementa x y
luego el nuevo valor de x se usa en la expresión.

Ejemplo 1

int x = 5;
(++x == 6) // verdadero o falso?
La respuesta es “verdadero”.

x++ incrementa el valor de x después de que la expresión se ejecuta, entonces, la expresión se

evalúa usando el valor original de x.

Ejemplo 2

x = 5
(x++ == 6) // // verdadero o falso?
La respuesta es “falso”.

Ejemplo 3

int x = 10
int y = x++; // y es igual a 10
int z = x + y; // z es igual a 21

Una ayuda para mejorar la legibilidad de su código, es ubicar el incremento y el decremento en

sentencias separadas.

Negación lógica
El operador de negación lógica es un signo de admiración (!). Se usa para revertir el valor de
un tipo bool.

- 41 -
Si bool b es falso, !b es verdadero
Si bool b es verdadero, !b es falso

Por ejemplo:
bool estaAbierto = true;
bool estaCerrado = !estaAbierto;

Operadores matemáticos
Además de los operadores obvios + - * y /, existe el operador de resto (%) que devuelve el
resto de una división. Por ejemplo:

int x = 20 % 7;
// x == 6

Operadores lógicos
C# provee operadores lógicos, como se muestra en la siguiente tabla:

Tipo de Operador Operador Descripción

Lógico
Condicional && x && y retorna verdadero si ambos son verdaderos y se
evalúa solo si x es verdadero.
|| x || y retorna verdadero si alguno de ellos o ambos son
verdaderos y se evalúa solo si x es falso.
Booleano & x & y retorna verdadero si ambos son verdaderos
| x | retorna verdadero si alguno de ellos o ambos son
verdaderos.
^ x ^ y retorna verdadero si alguno de ellos es verdadero y
falso si ambos son verdaderos o ambos falsos.

Los desarrolladores a menudo usan los operadores lógicos condicionales. Estos operadores
siguen las mismas reglas que los operadores booleanos pero tienen la característica que solo
son evaluados si es necesario.

Con qué usar operadores

Se puede usar también el operador de suma y de igualdad con cadenas. El signo más
concatena cadenas y el de igualdad las compara.

string a = "semi";
string b = "circulo";
string c = a + b;
string d = "cuadrado";

La cadena c tiene el valor semicírculo.

bool mismaForma = ( "circulo" == "cuadrado" );

mismaForma = ( b == d );

El booleano mismaForma es falso en ambas sentencias.

- 42 -
Precedencia de Operadores
Los desarrolladores a menudo crean expresiones que realizan más de un cálculo, comparación
o una combinación de ambos. En estas situaciones, la precedencia de los operadores controla
el orden en el cual se evalúan las expresiones. Si se desea que las operaciones se realicen en
un orden diferente, se debe indicar al compilador el orden usando paréntesis.
Por ejemplo, el operador mas (+) tiene una precedencia más baja que el operador de
multiplicación (*), entonces a + b * c significa multiplicar b * c y luego sumar a.

Paréntesis: Usar paréntesis para mostrar el orden de evaluación y hacer la evaluación de su

expresión más legible. Los paréntesis extra son eliminados por el compilador y no hacen su
aplicación más lenta.
Por ejemplo, en la siguiente expresión, el compilador multiplica b por c y luego suma d.

a=b*c+d

Usando paréntesis, en la siguiente expresión, el compilador primero evalúa lo que está entre
paréntesis, (c + d), y luego multiplica por b.

a = b * (c + d)

Los siguientes ejemplos demuestran la precedencia de los operadores y el uso de paréntesis

para controlar el orden de la evaluación.
10 + 20 / 5 (es reultado es 14)
(10 + 20) / 5 (es reultado es 6)
10 + ( 20 / 5 ) (es reultado es 14)
((10 + 20) * 5) + 2 (es reultado es 152)

Asociatividad
Todos los operadores binarios, aquellos que necesitan dos operandos, son asociativos a
izquierda, es decir, que la expresión se evalúa de izquierda a derecha, excepto por los
operadores de asignación. Los operadores de asignación y condicionales son asociativos a
derecha.

Por ejemplo:
x + y + z se evalúa como (x + y) + z
x = y = z se evalúa como x = (y = z)

Matrices (Arrays)
Una matriz es una estructura de datos que contiene varias variables del mismo tipo. Una matriz
se declara con un tipo:

type[] arrayName;

Ejemplos:
int[] array1 = new int [5];
int[] array2 = new int [] { 1, 3, 5, 7, 9 };
int[] array3 = { 1, 2, 3, 4, 5, 6 };

Una matriz tiene las propiedades siguientes:

 Una matriz puede ser unidimensional, multidimensional o escalonada

- 43 -
  El valor predeterminado de los elementos numéricos de matriz se establece en cero y
el de los elementos de referencia se establece en null.
 Una matriz escalonada es una matriz de matrices y por consiguiente sus elementos
son tipos de referencia y se inicializan en null.
 Las matrices inicializan su índice en cero: una matriz con n elementos se indiza desde
0 hasta n-1.
 Los elementos de una matriz pueden ser de cualquier tipo, incluido el tipo matriz.
 Los tipos de matriz son tipos de referencia derivados del tipo base abstracto Array.
Puesto que este tipo implementa IEnumerable e IEnumerable<T>, puede utilizar la
iteración foreach en todas las matrices de C#.

int[] numbers = { 4, 5, 6, 1, 2, 3, -2, -1, 0 };

foreach (int i in numbers)
{
System.Console.Write("{0} ", i);
}

- 44 -
3- Sentencias C#
Sentencia IF
Una sentencia condicional permite controlar el flujo de la aplicación seleccionando las
sentencias que serán ejecutadas, basándose en el valor de una expresión booleana.
Hay tres variaciones de una sentencia condicional:
 If
 if / else
 if / else if.

Cuando una expresión que se está evaluando es verdadera, el código siguiente a la sentencia
if será ejecutada.

La sintaxis para la sentencia if / else es la siguiente:

if (expresión booleana)
sentencia1
else
sentencia2
La sentencia1 se ejecuta si la expresión booleana es verdadera. Si es falsa se ejecuta la
sentencia2.

Por ejemplo:
if ( ventas > 10000 ) {
bono += 100;
}
else {
bono = 0;
}

Se puede usar else if para evaluar varias condiciones dentro de la misma sentencia

if (ventas > 10000)

{
bono += 100;
}
else if (ventas > 5000)
{
bono += 30;
}
else
{
bono = 0;
}

Se puede evaluar más de una expresión en una sentencia. Por ejemplo, las expresiones que
siguen a la sentencia if se evalúan como verdaderas si ventas es mayor a 10000 pero menor a
500000:

if ( (ventas > 10000) && (ventas < 50000) ) {

// ventas esta entre 10001 y 49999 inclusive
}

- 45 -
Usando el ternario
El operator ternario (?) es una forma corta de la sentencia if...else. Es útil cuando se desea
realizar una comparación y retornar un valor booleano.

Por ejemplo, la siguiente expresión asigna el valor 0 al bono si el valor de ventas es menor a
10000:

bono = (ventas > 10000) ? 100 : 0;

Sentencia switch
Una sentencia switch selecciona el código a ejecutar basándose en el valor de una expresión.
Las sentencias switch son útiles para seleccionar una rama de ejecución de una lista de
opciones mutualmente exclusivas. Usar sentencias switch hacen su aplicación más eficiente y
su código más legible que si se usa sentencias if anidadas.
Una sentencia switch toma la forma de una expresión seguida de bloques de opciones,
indicando los casos. Cuando la expresión en el argumento equivale al valor de uno de los
casos, el código que sigue a ese caso es ejecutado. Cuando no equivale a ningún caso, se
ejecuta el caso por defecto (default), si es que hay uno definido.
Se debe incluir una sentencia break al final de cada bloque de opción para que no se produzca
un error de compilación (siempre que exista código en ese caso).

Ejemplo:
La siguiente sentencia switch asume que x es un entero.
switch (x)
{
case 0:
// x is 0
break;
case 1:
// x is 1
break;
case 2:
// x is 2
break;
}

La secuencia de ejecución es la siguiente:

1. Se evalúa x.
2. Si una de las constantes en el caso es igual al valor de la expresión del switch, se pasa el
control a la sentencia seguida del caso.
3. Si ninguno de los casos equivale al valor de la expresión, el control se pasa al final de la
sentencia switch, o al caso por defecto, el cual es descripto en la siguiente sección.
Si x tiene el valor 1, las sentencias del caso 1 se ejecutan.

Default: Si lo desea se puede definir una condición para aquellos valores que no son
manejados en ninguno de los casos.
El siguiente ejemplo muestra cómo definir una condición por defecto.

switch (x)
{
case 0:
// x is 0
break;
case 1:

- 46 -
 // x is 1
break;
case 2:
// x is 2
break;
default:
// x no es 0, 1 o 2
break;
}

El caso por defecto maneja cualquier valor que no esté contemplado en los casos.

Sentencias iterativas
C# provee varios mecanismos de iteración, lo cual le permite ejecutar un bloque de código
repetidas veces hasta que se cumple una cierta condición. En todos los casos una sentencia se
ejecuta hasta que una expresión booleana se hace verdadera.

Sentencia for
Una iteración for se usa para ejecutar un código un cierto número de veces. Se usa un for
cuando se conoce por adelantado el número de veces que quiere repetir la ejecución de un
código. Por ejemplo, suponga que desea saber el monto de una cuenta bancaria de ahorros
luego de 10 años, y desea saber el total que tendrá al finalizar cada año. Una forma es escribir
la sentencia cuenta *= interés 10 veces, o usar una iteración.

La sintaxis para declarar una iteración for es:

for (inicializador; condición; iterador) {

sentencias;
}

Ejemplo

for ( int i = 0; i < 10; i++ ) {

Console.WriteLine( "i = {0}",i );
}
for ( int j = 100; j > 0; j -= 10 ) {
Console.WriteLine( "j = {0}", j );
}

Esta estructura es muy flexible. Por ejemplo, el contador de iteraciones puede ser
incrementado o decrementado en cada iteración. En este caso, es necesario conocer la
cantidad de iteraciones.

Ejemplo de un for que decrementa

for ( int i = 10; i > 0; i-- ) {

// sentencias;
}

Ejemplo de un for que incrementa de 10 en 10

for ( int i = 0; i <= 100; i = i+10 ) {

// sentencias;

- 47 -
}

Las sentencias inicialización e iteración pueden contener más una variable local, como se
muestra en el siguiente ejemplo:

for ( int i = 0, j = 100; i < 100; i++, j-- ) {

Console.WriteLine("{0}, {1}", i, j );
}

Este ejemplo produce la siguiente salida:

0, 100
1, 99
2, 98
.
.
.
99, 1

Sentencia while
Tal como en el caso del for, la iteración while evalúa la condición antes de ejecutar el código.
Se usa cuando no se conoce exactamente cuántas veces debe iterar.

La sintaxis para declarar una iteración while es la siguiente:

while (condición) {
// sentencias;
}

Ejemplo

while ( leerArchivo == true ) {

// sentencias;
}

Usando la palabra reservada continue

Se puede usar la palabra reservada continue, para iniciar la próxima iteración sin ejecutar el
resto de las sentencias del while. El siguiente ejemplo lee comandos de un archivo.

while ( leerArchivo == true ) {

string comando = LeerProximaLinea();
if ( comando == "Comentar" ) {
continue; //comienza una nueva iteración
}
if ( comando == "Setear" ) {
// sentencias para hacer algo
}
}

Cuando el comando es un comentario, no hay necesidad de procesar el resto de la línea,

entonces se usa la palabra reservada continue para comenzar una nueva iteración.

- 48 -
Usando la palabra reservada break
También se puede salir de una iteración. Cuando se encuentra la palabra reservada break, se
termina la ejecución y continúa la siguiente sentencia al while.

while ( leerArchivo == true ) {

string comando = LeerProximaLinea();
if ( comando == "Exit" ) {
break; //sale del while
}
if ( comando == "Setear" ) {
// sentencias para hacer algo
}
}

Sentencia do
En una iteración do, se ejecutan las sentencias del do, se evalúa la condición y si es verdadera,
se ejecutan las sentencias nuevamente. Es útil cuando se desea ejecutar el código del cliclo al
menos una vez.

La sintaxis de una iteración do es la siguiente:

do {
// sentencias que se ejecutan al menos 1 vez
} while (expresión booleana);

Nota: El punto y coma después de la sentencia do es obligatorio.

Ejemplo
En el siguiente ejemplo, se usa un do para escribir números del 1 al 10 en una columna: int i =
1;

do {
Console.WriteLine("{0}", i++);
} while ( i <= 10)

Control de Excepciones
C# incorpora mecanismos para el tratamiento de excepciones, que pueden producirse durante
la ejecución de un programa.
La instrucción try-catch consta de un bloque try seguido de una o más cláusulas catch, las
cuales especifican controladores para diferentes excepciones. Cuando se produce una
excepción, Common Language Runtime (CLR) busca la instrucción catch que controla esta
excepción. Si el método que se está ejecutando actualmente no contiene un bloque catch de
este tipo, CLR examina el método que llamó al método actual y así sucesivamente en la pila de
llamadas. Si no se encuentra ningún bloque catch, CLR muestra al usuario un mensaje de
excepción no controlada y detiene la ejecución del programa.
El bloque try contiene el código protegido que puede causar la excepción. Este bloque se
ejecuta hasta que se produce una excepción o hasta completarse satisfactoriamente.
El bloque finally es útil para limpiar cualquier recurso asignado en el bloque try, así como
también para ejecutar cualquier código que deba ejecutarse incluso si hay una excepción. El
control se transfiere siempre al bloque finally independientemente de cómo finalice el bloque
try.

- 49 -
private void Prueba() {
Cursor = Cursors.WaitCursor;
try
{
int a = 10;
int b = 0;
int c = a / b;
}
catch (DivideByZeroException ex)
{
MessageBox.Show(ex.Message);
}
catch (Exception ex)
{
MessageBox.Show(ex.ToString());
}
finally
{
Cursor = Cursors.Default;
}
}

Los objetos de excepción que describen un error se crean y, a continuación, se producen con
la palabra clave throw.

private decimal Dividir(decimal x, decimal y)

{
if (y == 0)
throw new Exception("No es posible dividir por cero");

return x / y;
}

- 50 -
 Módulo III

Fundamentos de la POO

- 51 -
1- Conceptos Básicos
Abstracción
La abstracción es el proceso [intencional] de supresión, u ocultamiento, de detalles respecto de
un fenómeno, entidad o concepto, dejando de lado el resto, de manera de concentrarnos en
otros aspectos que nos son más significativos en un determinado contexto.
Es importante notar que este proceso de abstracción es completamente subjetivo y
dependiente del contexto; diferentes personas pueden atravesar este proceso de simplificación
de diferentes maneras para un mismo fenómeno o entidad, eliminando diferentes conceptos y,
por tanto, llegando a una caracterización diferente. Por ejemplo, tomando como objeto de
análisis el concepto de automóvil, un observador interesado en la mecánica podría
caracterizarlo como un vehículo con cierto tipo de motor, mientras que otro observador, en un
contexto diferente, podría caracterizar al mismo automóvil como un medio de trasporte,
haciendo énfasis en su capacidad de trasportar personas o cosas. Notar que en este caso, deja
de importar el tipo de motor que tenga (simplificación).
Nuestro mundo está conformado por una enorme cantidad de fenómenos y entidades,
imposibles de representar y manejar sin alguna herramienta que nos permita caracterizarlos de
alguna forma práctica.
Una forma de realizar esto es lograr abstraer determinadas características de las entidades de
nuestro dominio, para así modelar un concepto más general que las abarque. En otras
palabras, lo que buscamos es separar efectivamente los objetos concretos de la idea que
queremos representar. Esto, que en principio nos puede parecer una tarea difícil, es algo que
hacemos inconscientemente en el día a día. A modo de ejemplo, pensemos en la noción de
que un objeto se encuentre sobre otro: si vemos un florero apoyado en una mesa diremos
naturalmente que el florero se encuentra sobre la mesa. Asimismo, podemos decir que un lápiz
se encuentra sobre un escritorio o que el pan se encuentra sobre la mesada. De estos
ejemplos podemos decir que el florero, el lápiz y el pan comparten el concepto de estar sobre
algo. De hecho, una vez que logramos abstraer la idea de estar sobre, no sólo la podemos
extrapolar a otras situaciones sino que podremos hablar en abstracto con otras personas que
comprendan esa noción, sin referirnos a un caso concreto. De forma similar, podríamos utilizar
una pelota, un aro, una rueda, etc., y a partir de estos objetos explicar lo que significa que un
objeto sea redondo. Una vez hecho esto podemos determinar si una o más entidades pueden
ser caracterizadas de esta manera simplemente por comparación (verificando que el conjunto
de propiedades que define al concepto redondo también son propias de la entidad en cuestión).
Al trabajar con objetos, dos de las más importantes abstracciones con las que trabajaremos
son las nociones es-un y tiene-un:
La idea de división en partes es la abstracción tiene-un. El significado de este término es fácil
de comprender; un auto ‘tiene-un’ motor, ‘tiene-una’ transmisión, etc.
Al concepto de especialización nos referimos como la abstracción es-un. Nuevamente, el
término surge de las sentencias que pueden ser usadas para ilustrar las relaciones. Utilizando
este concepto, una bicicleta ‘es-un’ vehículo, el cual a su vez ‘es-un’ medio de transporte...”

Buscando el nivel de abstracción correcto

En las etapas tempranas del desarrollo de software uno de los problemas críticos es encontrar
el nivel de abstracción correcto o adecuado. Un error común es hacer hincapié en los niveles
más bajos, preocupándose por los detalles de implementación de varios componentes claves,
en lugar de esforzarse para asegurar que la estructura organizativa de alto nivel promueva una
clara separación de responsabilidades.
El programador (o el equipo de diseño en grandes proyectos) debe tratar de balancear el nivel
de abstracción adecuado en cada momento. Por un lado, uno no quiere ignorar o tirar a la
basura demasiados detalles sobre un problema, pero por otro lado, tampoco uno debe
mantener muchos detalles que al fin de cuentas opaquen y no nos permitan ver ciertas
cuestiones importantes.

- 52 -
En el contexto de la programación OO, la abstracción surge como un proceso de
reconocimiento de similitudes entre fenómenos, conceptos y entidades, y la decisión de
concentrarse en estas similitudes e ignorar las diferencias entre ellos. De esta manera,
logramos identificar conceptos generales (persona, auto, pelota, etc.) que puedan ser
mapeados directamente a construcciones básicas (objetos) en nuestro paradigma.

Encapsulamiento
El ocultamiento de la información es particularmente importante en la programación orientada a
objetos. Los objetos frecuentemente son complejas estructuras de datos con muchos
componentes que no deben ser accedidas por los clientes. Existen algunas razones para tal
encapsulamiento:
 La representación de un objeto está sujeta a cambios. Durante el desarrollo de una
clase puede suceder que un conjunto diferente de variables de instancia resulte mejor
con el propósito de la clase. Si los clientes acceden directamente a las variables de
instancia, éstos deben ser modificados para que queden consistentes con la nueva
representación.
 En contraste con los registros en los programas convencionales, los objetos no son
usados principalmente como contenedores cuyo único objetivo es agrupar datos
elementales. Más bien, las variables de instancia del objeto son utilizadas para
representar el estado del mismo. El objeto en sí mismo es una entidad activa que
puede llevar a cabo ciertas operaciones cuando le es requerido. Las variables de
instancia pueden ser consideradas como variables auxiliares que son necesarias para
realizar las operaciones.
 Los objetos frecuentemente poseen otros objetos. La posesión es privada para el
objeto; la relación entre el objeto y los otros objetos que le pertenecen no debe ser
alterada por los clientes.
 Los objetos son accedidos mediante referencias polimórficas. Si un objeto es accedido
a través de una variable v, el objeto referenciado por v puede cambiar dinámicamente
durante la ejecución del programa y no podemos estar seguros si la variable v siempre
hará referencia a un objeto con la misma estructura interna.
Idealmente, en cualquier sistema, intentamos que el acoplamiento entre las partes que lo
componen sea lo más bajo posible. Esto implica que cada parte sabe lo mínimo indispensable
de las otras partes, lo que implica que los cambios en alguna de esas partes no impactan (o lo
hacen en forma muy leve) en el resto de las partes del sistema.
En un sistema OO las “partes” básicas son los objetos, por lo que nos gustaría que los cambios
en un objeto impacten lo menos posible en el resto de los objetos que hacen al sistema. Uno
de las formas de lograr esto es por medio de la separación entre lo que es público de un objeto
y lo que es privado.
Desde el punto de vista más puro del paradigma orientado a objetos un objeto se define por los
servicios que puede brindar (o sea, por los mensajes que entiende). Luego, lo lógico es que
estos mensajes sean la parte pública del objeto. Por otro lado, la implementación de estos
mensajes (los métodos, o sea cómo resuelve un requerimiento el objeto) no es algo que le
importe al emisor del mensaje, por lo que debe ser privado del objeto que implementa el
método. De forma similar, tampoco tiene porque interesarle al resto de los objetos cuál es la
estructura interna de un determinado objeto ni con qué otros objetos éste tiene que colaborar
para llevar a cabo sus responsabilidades. Todo lo que le importa al objeto emisor es cuál es el
mensaje que tiene que enviar, qué parámetros debe enviar y cuál es la semántica asociada al
envío del mensaje.
El hecho de programar en términos del protocolo de un objeto, sin saber nada de su estructura
interna ni de cómo implementa sus métodos, es lo que ayuda a mantener los cambios
acotados, evitando que un cambio en un objeto se propague por todo el sistema. De aquí la
relación que nombramos anteriormente acerca de los métodos y el encapsulamiento.

- 53 -
Justamente es a través de los métodos que el objeto publica la única manera de interactuar
con él. Nada se podrá hacer que no esté provisto a través del protocolo.

Modelo
Un modelo, es una versión simplificada de algún fenómeno o entidad del mundo real. El
modelado, como proceso, está muy ligado a otro concepto muy importante que vimos
anteriormente: el de abstracción. La forma de construir un modelo, ya sea mental, físico, etc.,
es a través de un proceso de abstracción (simplificación), mediante el cual descartamos
aquellas características que no nos sean relevantes y nos concentramos en aquellas que sí
nos interesan. Esas características relevantes son las que terminarán dando forma a nuestro
modelo. En dos líneas, acerca de un modelo podríamos decir:
 Es una abstracción utilizada para entender y razonar sobre entidades y fenómenos del
mundo real.
 Debe omitir detalles no esenciales y su grado de granularidad debe estar acorde a sus
propósitos.
A pesar de no hacerlo conscientemente, vivimos constantemente utilizando y creando nuevos
modelos de todo tipo para representar los fenómenos de la naturaleza; los ejemplos abundan y
van desde los modelos físicos (utilizados en el diseño de represas, puentes, puertos y otras
construcciones) hasta los modelos matemáticos (utilizados por ejemplo para realizar
simulaciones y optimizaciones sobre sistemas reales, como en el campo de la hidrología). En
astronomía se utilizan modelos específicos para representar el movimiento de los cuerpos
celestes en el espacio, utilizando elementos de la geometría como son los círculos y las elipses
para representar las órbitas que describen los planetas, junto con otros modelos matemáticos.
Los modelos también nos permiten poder realizar simulaciones para evaluar o estimar cuál
será el desempeño del sistema en el mundo real, una vez que sea llevado a la práctica. Este
tipo de técnicas es utilizado en la industria del diseño de vehículos de alta tecnología
(automotriz o aeronáutica) para testear, por ejemplo, las características aerodinámicas de los
prototipos, utilizando maquetas a escala y simulando el desempeño del vehículo dentro de un
túnel de viento.
La ejecución de un programa se puede ver como un modelo físico simulando el
comportamiento de una parte real o imaginaria del Mundo.

Programación Estructurada
La visión clásica de la programación estructurada se refiere al control de ejecución. El control
de su ejecución es una de las cuestiones más importantes que hay que tener en cuenta al
construir un programa en un lenguaje de alto nivel. La regla general es que las instrucciones se
ejecuten sucesivamente una tras otra, pero diversas partes del programa se ejecutan o no
dependiendo de que se cumpla alguna condición. Además, hay instrucciones (los bucles) que
deben ejecutarse varias veces, ya sea en número fijo o hasta que se cumpla una condición
determinada.

Programación Orientada a Objetos

Todo es un objeto. Lo principal es la noción de objeto. Los programas están organizados en
base a clases y jerarquías de herencia.
Los objetos se comunican enviando y recibiendo mensajes. Son responsables de llevar a
cabo ciertas acciones. La forma de pedirle a un objeto que lleve a cabo una determinada tarea
es por medio del envío de un mensaje.
Los objetos tienen su propia memoria (en términos de objetos).
Cada objeto es instancia de una clase. Las clases contienen el comportamiento compartido por
sus instancias. Los objetos pueden componerse o conocer otros objetos.

- 54 -
- 55 -
2- Elementos Básicos de POO
Clase
Modelo que se usa para describir objetos similares. Es un tipo de dato definido por el usuario
que determina las estructuras de datos que lo forman y las funciones asociadas con él, es decir
es un modelo con el que se construyen los objetos. Similar a un plano o plantilla.

Objeto
Los objetos son los elementos primarios que utilizaremos para construir programas. Dichos
objetos son básicamente abstracciones de alguna entidad (ya sea tangible o no) del dominio
del problema que estamos atacando. Para resolver un problema determinado los objetos se
comportan de una determinada manera (definido por sus mensajes) e interactúan entre ellos
(enviándose de mensajes).
Todo objeto tiene estado, exhibe un comportamiento bien definido y posee identidad única.
Los objetos se crean en base a Clases. Los objetos creados se llaman instancias.
El estado interno está representado por variables de instancia que se utilizan para expresar
características del objeto y relaciones de conocimiento con los otros objetos con que va a
colaborar.
Pero no debemos perder de vista el hecho de que dentro de un sistema coexisten miles de
objetos, lo que conduce a la necesidad de disponer de algún mecanismo que permita
identificarlos unívocamente de modo de poder diferenciarlos. Por este motivo, los objetos
poseen una identidad que, como se presentó anteriormente, es una propiedad intrínseca de
cada objeto y, por tanto, no puede ser modificada por el programador.

Características de los objetos

 Comportamiento bien determinado: Al diseñar un objeto lo que uno hace es establecer
cuáles son las responsabilidades de dicho objeto. Estas responsabilidades se
materializan en un conjunto de mensajes a los que un objeto puede responder.
 Estado interno: A nivel de implementación los objetos poseen una estructura interna
que se define en términos de variables de instancia. Las variables de instancia se
utilizan para representar aquellas características propias del objeto (como puede ser el
número de una cuenta bancaria) y a los objetos con los que deberá colaborar a lo largo
de su vida.
 Identidad: Es una propiedad intrínseca que poseen todos los objetos. La definición de
identidad es la siguiente: “Un objeto solo es idéntico a sí mismo”. Notar que identidad
no es lo mismo que igualdad; dos tazas pueden ser iguales, pero cada taza solo es
idéntica a sí misma.
 Todo objeto es instancia de una clase: Como dijimos anteriormente, un objeto es una
abstracción de una entidad de nuestro modelo. Dado que generalmente nos
encontramos con un conjunto de objetos que se comportan en forma similar, el
siguiente paso es encontrar una forma de definir el comportamiento de todos estos en
forma general. Pensemos por ejemplo en las cuentas bancarias: en un banco habrá
miles de cuentas bancarias, las que se comportarán de la misma forma. Por este
motivo, aparece la noción de clase “cuenta bancaria”, la cual se utiliza para describir el
comportamiento de todas sus ocurrencias (instancias).

Comportamiento de los Objetos

Cuando pensamos en los objetos vistos desde afuera lo que nos interesa es qué es lo que el
objeto puede hacer y no cómo lo hace. El comportamiento de un objeto está directamente
relacionado con su funcionalidad y determina las operaciones que este puede realizar o a las

- 56 -
que puede responder ante mensajes enviados por otros objetos. La funcionalidad de un objeto
está determinada, primariamente, por su responsabilidad. Una de las ventajas fundamentales
de la POO es la reusabilidad del código; un objeto es más fácil de reutilizarse en tanto su
responsabilidad sea mejor definida y más concreta.
Una tarea fundamental a la hora de diseñar una aplicación es definir el comportamiento que
tendrán los objetos de las clases involucradas en la aplicación, asociando la funcionalidad
requerida por la aplicación a las clases adecuadas.
En muchos casos el objeto necesitará otros objetos que lo ayuden a llevar a cabo su tarea. En
este caso, al enviar el mensaje, el objeto emisor también le envía un conjunto de parámetros
para que el objeto pueda resolver el pedido.

Implementación de un objeto
 La implementación indica cómo hace el objeto para responder a sus mensajes.
 Se especifica a través de un conjunto de métodos.
 Es privada del objeto. Ningún otro objeto puede accederla.

Estado interno/estructura interna

El estado interno de un objeto está constituido por un conjunto de variables de instancia.
Dichas variables de instancia acompañan al objeto durante todo su ciclo de vida.
Una variable de instancia puede hacer referencia a una propiedad intrínseca de la entidad que
representa, o bien a otro objeto con el cual pueda colaborar para llevar a cabo sus
responsabilidades. A lo largo de la vida del objeto, las propiedades y colaboradores pueden
cambiar. Por ejemplo, al depositar $100 en una cuenta bancaria la variable de instancia saldo
cambiará su valor.
Este estado interno es privado del objeto. Por definición, las variables de instancia (estructura
interna) de un objeto es privado a éste. Esto le da la posibilidad al objeto de decidir qué es lo
que quiere publicar.

Identidad
La identidad es una propiedad intrínseca que poseen todos los objetos. Por definición un objeto
solo es idéntico a sí mismo. Es importante notar que identidad no es lo mismo que igualdad;
dos sillas pueden ser iguales al punto que, si nos damos vuelta y las cambian de lugar, no
podríamos distinguir cual es cual. A pesar de esto, cada silla sigue manteniendo su identidad.
La identidad sirve para poder distinguir objetos individuales dentro de un sistema. Es decir,
dentro de un sistema coexisten una cierta cantidad de objetos, por lo que es necesario poder
identificarlos y diferenciarlos entre ellos.
La identidad, a nivel práctico, no tiene mayor importancia para el programador ya que los
lenguajes orientados a objetos proveen un mecanismo por el cual cada objeto posee un
identificador único y, de hecho, casi nunca es posible obtener dicho identificador.
Indirectamente vamos a estar utilizando este concepto cuando comparemos dos objetos por
igualdad.

Ejemplo de un objeto

- 57 -
Práctica
Ejercicio 1: Agrupe los elementos de la siguiente lista en objetos y propiedades:
 Banco
 Extraer
 Apellido
 Depositar
 DNI
 CuentaBancaria
 Cliente
 CrearCuenta
 Saldo
 CerrarCuenta

Ejercicio 2: Identifique, en el siguiente enunciado, objetos y propiedades:

Una computadora está formada por tres partes principales, un monitor, un gabinete y un
teclado. Cada una de estas partes posee un modelo y un número de serie. Además el gabinete
puede determinar su temperatura y la cantidad de puertos USB que posee (tanto disponibles
como en uso).

Envío de Mensajes
Dijimos que el comportamiento de un objeto se define por medio de los mensajes que éste
entiende y que para poder enviarle un mensaje a un objeto, hay que conocerlo. Hemos visto
también que al enviarle un mensaje a un objeto, éste responde activando el método asociado al
mensaje, siempre y cuando éste exista. También vimos que un mensaje es enviado a un objeto
por otro objeto y como resultado del envío de un mensaje, siempre se retorna un objeto.
El método, es decir la implementación, especifica qué hace el objeto receptor al recibir el
mensaje. El método no contiene otra cosa que una serie de mensajes enviados a otros objetos
(sólo hay objetos y mensajes). Recordemos también que los métodos son privados al objeto y
que los objetos sólo pueden comunicarse mediante el envío de mensajes.
Por ejemplo, supongamos que contamos con un objeto que representa la torre de control de un
aeropuerto. Si la torre desea avisar al avión LV-YPS que debe aterrizar, primero debe

- 58 -
conocerlo. A su vez, si el avión LV-YPS desea comunicarse con la torre, también debe
conocerla.

Cuando la torre envíe el mensaje ‘aterrizar’ al avión, éste activará un método que contendrá el
procedimiento de aterrizaje.
Podría suceder que el avión no conozca los procedimientos para aterrizar, es decir, podría no
existir un método que se corresponda con el mensaje ‘aterrizar’. ¿Qué ocurre cuando un objeto
no entiende un mensaje recibido? Esto depende del lenguaje: algunos lenguajes pueden evitar
esta situación mediante un sistema de tipos fuerte que chequee estas situaciones en tiempo de
compilación, mientras que otros brindan una mayor libertad en cuanto al envío de mensajes y
responden, eventualmente, con un error en tiempo de ejecución.

Otro ejemplo de envío de mensajes, usando una versión simplificada del juego de rol.

 La persona envía el mensaje #dameUnCafe() a la expendedora.

 La expendedora le pide a la cafetera que le sirva el café en el vaso que le da.
 La cafetera retorna el vaso con el café preparado.
 La expendedora entrega el vaso con café a la persona

- 59 -
Siempre se debe contar con dos objetos para poder resolver el envío de un mensaje, uno
cumpliendo el rol de emisor y otro el de receptor (eventualmente podría tratarse del mismo
objeto cumpliendo los dos roles). El emisor envía un mensaje al receptor, en este caso el
mensaje hacerAlgo. El receptor recibe el mensaje y busca entre sus métodos aquel que
coincida con el nombre del mensaje. Si encuentra el método correspondiente, procede a
ejecutarlo (en este caso el objeto receptor tiene un método asociado al nombre hacerAlgo). La
ejecución del método la veremos en detalle más adelante, en este caso nos interesará saber
que al finalizar la misma, el objeto receptor deberá retornar un objeto como resultado del envío
del mensaje, devolviendo nuevamente el control al objeto emisor.

Especificación de un Mensaje
En primer lugar debemos asignarle un nombre, el mismo debe tener significado en el dominio
del problema, esto es de vital importancia para el futuro entendimiento del sistema. Por otro
lado, debemos indicar cuáles son los posibles objetos, u otro tipo de parámetro, requeridos
para resolver el mensaje.

Cada lenguaje de programación propone una sintaxis particular para indicar el envío de un
mensaje.
<objeto receptor>.<nombre de mensaje> (<parámetros>);

Por ejemplo, decirle a una cuenta bancaria que deposite $100 se escribe como:

- 60 -
 unaCuenta.depositar(100);

¿Qué es un método?
Es la contraparte funcional del mensaje. Expresa la forma de llevar a cabo la semántica propia
de un mensaje particular (el cómo).
Un método puede realizar básicamente 3 cosas:
 Modificar el estado interno del objeto.
 Colaborar con otros objetos (enviándoles mensajes).
 Retornar y terminar.

Ejemplo:
Veamos como ejemplo la implementación del método depositar del objeto caja de ahorro.
En este caso la resolución es muy sencilla: la variable de instancia saldo de la caja de ahorro
se actualiza con el valor del parámetro unMonto.

Depositar (unMonto)
Saldo  Saldo + unMonto

Este caso es muy similar, salvo que se reciben dos parámetros: el saldo y el nro. de cuenta. El
cajero conoce al banco por medio de la variable de instancia banco, y lo que hace es delegar
en dicho objeto la responsabilidad de buscar la caja de ahorro que corresponde al nro. de
cuenta que viene como parámetro. Luego, una vez encontrada la caja de ahorro
correspondiente, se le envía el mensaje depositar con el monto como parámetro.

RealizarDeposito (unMonto, nroCuenta)

cuenta  banco.BuscarCuenta(nroCuenta);
cuenta.Depositar(unMonto);

Ahora será necesario especificar el método saldo. El objeto caja de ahorro debe devolver su
saldo actual como respuesta al envío del mensaje saldo, para lo cual necesitaremos un
mecanismo que nos permita indicar cual es el resultado de evaluar un método. Para tal fin
contamos con una construcción sintáctica especial, el símbolo flecha hacia arriba. El símbolo
va seguido de cualquier objeto e indica que ese objeto será retornado como resultado de la
ejecución del método.

- 61 -
 Saldo()
Saldo;

Ejercicio: Identificar objetos y mensajes

 cuenta.extraer(unMonto)
 cuenta.titular()
 cajero.obtenerCuenta(numeroDeCuenta)
 (cajero.obtenerCuenta(210321)).saldo()
 banco.suspender(cuenta.titular())
 banco.suspender(banco.obtenerCuenta(211101).titular())

Comportamiento común entre objetos

Si pensamos nuevamente en el ejemplo del banco, es evidente que existirán varios objetos de
tipo caja de ahorro, uno por cada caja de ahorro existente en el banco. Todos estos objetos
deberán tener el mismo comportamiento y es de esperar que si hay algún cambio en el
comportamiento de las cajas de ahorro, el mismo se refleje por igual en todos los objetos de
este tipo. Luego, es necesario contar con algún mecanismo que permita agrupar el
comportamiento común a un conjunto de objetos, de manera que pueda ser reutilizado sin
tener que ser especificado individualmente. Por otro lado, el estado interno de cada caja de
ahorro será diferente (los saldos no serán los mismos por ejemplo) pero todas compartirán la
misma estructura interna (todas conocen su saldo, titular, etc.). Desde el punto de vista de la
reutilización, es así como surge la noción de clase: como una herramienta que me permite
factorizar y reutilizar estructura y comportamiento en común.

Clases
Una clase es una descripción abstracta de un conjunto de objetos.
Una clase nos permite describir en un sólo lugar el comportamiento genérico de un conjunto de
objetos. Una vez definido este comportamiento, es posible crear objetos que lo reutilicen y se
comporten de la manera allí descripta. Las clases nos permiten pensar en un nivel de
abstracción más alto. Cuando construimos programas nos preguntamos constantemente: ¿qué
clases de objetos aparecen en mi sistema?
Una clase entonces puede pensarse como un molde o plano para un tipo específico de objeto.
Molde como medio para definir la forma de los objetos.
Es natural clasificar objetos por determinadas características. En muchos casos nos
encontramos en situaciones en las que un conjunto de objetos se comportan en forma similar y
sólo difieren en sus características básicas o en los objetos con los que colabora. En estos
casos es importante poder abstraer el comportamiento común de los objetos y especificarlos en
forma abstracta, de forma tal de modelar el concepto subyacente. Como definición de clase se
puede tomar la siguiente:
Las clases describen el formato de los objetos y agrupan comportamiento en común. Una clase
especifica qué forma tendrán sus instancias (sus variables de instancia) y cómo responderán a
los mensajes que se le envíen. De esta forma, una clase puede ser vista como una descripción
de sus instancias y como un repositorio de comportamiento. Cuando se le envía un mensaje a
un objeto, lo que hace el intérprete es buscar en la clase del objeto receptor un método con el
cual responder al envío del mensaje. De ésta forma, todos los objetos que comparten una
misma clase responden en forma similar al envío de un mensaje.
En el caso de la cuenta bancaria, dado que en un banco habrá miles de cuentas, lo que
hacemos es modelar la noción de cuenta bancaria en una clase. Esta clase definirá qué
variables tendrán sus instancias, así como los mensajes a los que puede responder. En
nuestro caso la clase se llamará CuentaBancaria, especificará que sus instancias tienen dos

- 62 -
variables (saldo y titular) y que pueden responder a los mensajes saldo(), titular(),
depositar(unMonto) y extraer(unMonto).

Clases e Instancias
Uno de los problemas más comunes es la confusión entre clases e instancias. Es importante
remarcar que una clase es un molde de estructura y comportamiento, así como la encargada
de crear a sus instancias. Una vez que se crea una instancia, esta tiene sus propias variables.
Por ejemplo, si creamos dos cuentas bancarias, cada una tendrá su saldo y su titular. Lo único
que comparten es que ambas son instancia de la misma clase, lo que implica que al enviarles
un mensaje, el método que se activará se buscará en la clase CuentaBancaria, que es común
a las dos.

Contamos con una clase CajaDeAhorro, que define el comportamiento y la estructura común a
todas sus instancias. Una CajaDeAhorro sabrá extraer(unMonto) de su saldo,
depositar(unMonto) y devolver su saldo actual. Además deberá colaborar con un objeto que
cumplirá el rol de titular de la cuenta. Podemos ver en el ejemplo dos instancias de
CajaDeAhorro, cada una con su propio estado interno. Eventualmente podrían llegar a
compartir el mismo titular de cuenta (un persona es titular de ambas cuentas) o bien tener el
mismo saldo. Las dos instancias de la clase CajaDeAhorro comparten el mismo
comportamiento, definido en la propia clase.

De ahora en más cuando queramos referirnos a un método de una clase, lo haremos utilizando
la siguiente sintaxis, por convención:

NombreDeClase>>método(parámentro1, …)

Ejemplo:
CajaDeAhorro>>depositar(unMonto)
saldo := saldo + unMonto

- 63 -
Especificación de Clases
Las clases se especifican por medio de un nombre, la estructura interna que tendrán sus
instancias y los mensajes y métodos asociados que definen su comportamiento. El nombre
debe comenzar con mayúscula y no contener espacios. Las variables de instancia representan
el estado o estructura interna de las instancias de la clase. Por último, se detalla el conjunto de
mensajes que entenderá una instancia de dicha clase, también llamado protocolo.
Gráficamente:

Instanciación
Es el mecanismo de creación de objetos. Los objetos se instancian a partir de un molde (la
clase). Un nuevo objeto es una instancia de una clase.
Todas las instancias de una misma clase
 Tendrán la misma estructura interna.
 Responderán al mismo protocolo (los mismos mensajes).

Comúnmente se utiliza la palabra reservada new para instanciar nuevos objetos.

Según el lenguaje
 new es un mensaje que se envía a la clase.
 new es una operación especial.
En C# el new es una operación especial.

- 64 -
Formas de Conocimiento
Para que un objeto conozca a otro lo debe poder nombrar. Decimos que se establece una
ligadura (binding) entre un nombre y un objeto.
Podemos identificar tres formas de conocimiento o tipos de relaciones entre objetos.
 Conocimiento Interno: Variables de instancia.
 Conocimiento Externo: Parámetros.
 Conocimiento Temporal: Variables temporales.
 Además existe una cuarta forma de conocimiento especial: las seudo-variables.

Variables de Instancia
Son las que más hemos visto hasta el momento. Al definir la clase, se define la estructura que
tendrán sus instancias; esta estructura interna viene dada por un conjunto de variables de
instancia. Las variables de instancia acompañan al objeto desde su creación hasta que muere.

Parámetros
Se utilizan para nombrar objetos que el objeto receptor necesita para cumplir un requerimiento.
Por ejemplo, para alquilar una película a un cliente, el video club debe saber qué película y qué
cliente. En este caso la película y el cliente son parámetros que se envían junto con el mensaje
alquilar para poder cumplir el requerimiento.

Variables Temporales
Se definen dentro de un método. Estas variables se utilizan para nombrar objetos
temporalmente. Al finalizar la activación del método dejan de existir.

Seudo Variable: this

Así como un objeto necesita conocer a otro objeto para enviarle un mensaje, es necesario que
tenga una forma de nombrarse a sí mismo para poder enviarse mensajes. Esto se hace por
medio de la seudo-variable this. Se dice que this es una seudo-variable ya que funciona similar
a una variable de instancia, excepto por dos motivos: no está definida en ninguna clase y no
pude ser asignada. Si bien la denominación this es la más correcta para esta situación de “auto
referenciamiento”, en el sentido de que representa al objeto en sí mismo y la palabra
concuerda con este hecho, existen otros lenguajes donde se ha dado una denominación
distinta para esta misma seudo-variable.

- 65 -
3- UML

Definición
Tomar y pensar en las tres palabras por separado ayudan a la comprensión del objetivo de
este lenguaje y al porqué de su utilidad:
 Modelado: nos llevará a presentar la visión y concepción de MODELOS.
 Unificado: nos llevará a mencionar qué se unificó en UML
 Lenguaje: nos llevará a explicar que para cerrar esta Unificación de Modelado era
importante consensuar un Lenguaje; especificando su sintaxis y su semántica,
indicando también reglas para conformar modelos gráficos válidos

Modelado
Se presenta la idea de modelo porque lo que se va a notar, utilizando UML, es justamente un
modelo. Los Modelos
 Ayudan a la mejor comprensión de sistemas
 Indican qué hará el sistema pero no cómo lo hará
 Contribuyen a la corrección de errores
 Favorecen a la evolución y el reuso
 Esencial para la comunicación entre miembros de un equipo

Unificado
Booch, Rumbaug y Jacobson, son los creadores de UML, llamado inicialmente Lenguaje de
Modelado.
El Lenguaje Unificado de Modelado fue adoptado en forma unánime por los miembros de OMG
como estándar en noviembre de 1997. Allí OMG asumió la responsabilidad de futuros
desarrollos en el estándar de UML.
Hubo muchos otros aportes además de lo propuesto por Rumbaugh, Booch y Jacobson.
Todas estas contribuciones sumaron riqueza al lenguaje y gráficamente se manifiestan en los
diferentes tipos de diagramas que tiene UML.
Las ventajas buscadas y obtenidas con la unificación de diferentes enfoques son:
• Reunir los puntos fuertes de cada método
• Idear nuevas mejoras
• Proporcionar estabilidad al mercado
• Eliminar ambigüedad en los usuarios

- 66 -
Lenguaje
Es importante mencionar que la mayoría de las personas somos naturalmente visuales. Eso
explica por qué entendemos mejor y más rápidamente un dibujo que parte de un texto.
Es por ello que en el criterio de unificación de las metodologías de modelado se concluyó en un
lenguaje gráfico visual para la especificación y construcción de modelos.
Aquí vale la pena detenerse en semántica y sintaxis.
La sintaxis de UML determina la forma de los elementos básicos sintácticos. Por ejemplo, un
rectángulo con una división y nombre es una clase.
La semántica de UML especifica el significado de cada elemento de modelado. Siguiendo con
el ejemplo de la anterior, la semántica de la clase es la de denotar a un conjunto de objetos,
instancias de la misma, que tienen la misma estructura y el mismo comportamiento.
Las reglas de construcción o reglas de buena formación determinan la forma en que los
elementos pueden combinarse de manera de obtener modelos correctos. Por ejemplo, que las
clases deben tener obligatoriamente un nombre; o que los nombres de los mensajes de una
clase no pueden repetirse.

Diagramas de UML 2.0

El conjunto de diagramas se encuentra organizado en torno a dos categorías:
• Diagramas Estructurales (representados en naranja).
• Diagramas Dinámicos o de Comportamiento (representados en azul).

Diferentes diagramas se utilizan durante diferentes etapas dentro del desarrollo de software. Se
puede asociar como ejemplo alguna etapa con algún diagrama, por ejemplo, la etapa de
Análisis con los diagramas de Casos de Uso, de Actividad y de Estado.
Los diagramas a presentar a continuación se corresponden con la etapa de Diseño (hay más
diagramas para esta etapa) son los de clases y los diagramas de secuencia.

Diagrama de Clases
El objetivo de este diagrama es el de representar los objetos del sistema, especificando la
estructura de las clases, sus relaciones y su comportamiento. Describe la vista estática de un
sistema.

- 67 -
Si bien el elemento de modelado que será presentado es la Clase, también pueden aparecer
en el diagrama de Clases, las Interfaces.
Aparte de esos dos (y la nota), no hay otro elemento de modelado que pueda participar de este
diagrama.

Una clase es una plantilla que define una colección de conceptos con las mismas
características.
Cada uno de los compartimientos es opcional, excepto el del nombre.
• Nombre de la clase: en la práctica, los nombres de clase son nombres cortos o
expresiones nominales extraídos del vocabulario del sistema que se está modelando.
El nombre de la clase se escribe con mayúscula, centrado y en negrita.
• Atributos: un atributo representa alguna propiedad del elemento que se está
modelando
• Operaciones: son los mensajes que los objetos de la clase entienden
• Responsabilidades: es un contrato o una obligación de una clase. Se utiliza cuando
aún no se ha definido completamente el comportamiento de la clase, en una etapa
previa al diseño.

- 68 -
Clase
Se muestran dos formas de escribir el nombre de una clase: escribiendo directamente su
nombre y escribiendo su nombre precedido de su ubicación (teatro es un paquete).
 Nombre simple: NombreDeClase
 Nombres de camino: paq1::paq2::NombreDeClase

Atributos
La única condición es que el nombre del atributo debe comenzar con minúsculas.
Los corchetes significan que el elemento es opcional, por lo que sólo el nombre es obligatorio.
La barra “/” indica que el atributo es derivado. Por ejemplo, la edad de una persona podría
derivarse de su fecha de nacimiento.
El atributo subrayado indica que el atributo es “de clase”. Esto significa que este atributo es
compartido por todas las instancias de la clase (también se lo conoce como “variable de
clase”). Por convención, se indica subrayado.
Algunas propiedades:
 changeable: no hay restricciones para modificar el valor del atributo.
 addOnly: para los atributos con multiplicidad mayor de uno (colecciones), se pueden
añadir valores adicionales, pero una vez creado, un valor no puede ser eliminado o
modificado.
 frozen: el valor del atributo no se puede modificar tras inicializar el objeto (una
constante)
A menos que se especifique lo contrario, los atributos siempre son changeable.

Visibilidad
UML ofrece una serie de elementos para especificar detalles para los atributos y las
operaciones. Desde fuera de un objeto sólo se puede manipular los datos por medio de
llamadas a operaciones –métodos- del objeto.
 Privado: (-) significa que sólo se puede usar en los objetos donde está definido el
atributo u operación.
 Protegido: (#) significa que sólo los objetos de las subclases de la clase a la que
pertenece el atributo u operación pueden utilizarlo.
 Paquete: ( ) significa que sólo los objetos del paquete en donde está definida la clase a
la que pertenece el atributo u operación pueden utilizarlo.
 Público: (+) significa que los objetos pertenecientes a cualquier clase puede utilizar el
atributo u operación.
No existe un valor por defecto para la visibilidad. Si ésta no se indica, está indefinida.

- 69 -
Operaciones
Sintaxis:
[visibilidad] nombre([lista de parámetros])[:tipo de retorno][ {propiedades}]

Parámetros:
[dirección] nombre:tipo [multiplicidad][=valor]

Donde dirección puede ser:

 in: la operación puede modificar el parámetro y el que llama no necesita volver a verlo.
 out: la operación coloca o cambia el parámetro y lo devuelve al que llama.
 inout: la operación utiliza el parámetro y puede cambiarlo para devolverlo.

El nombre del mensaje junto a sus parámetros (incluido el tipo de retorno, si lo hay) se conoce
como firma de la operación (signature).
Al igual que con los atributos, pueden especificarse mensajes a nivel de clase. Éstas se indican
con el subrayado.
 isQuery: indica que la operación no cambia el valor de ningún atributo. La operación es
una función pura sin efectos laterales.
 sequential: sólo puede llegar una llamada por vez. Los invocadores deben coordinarse
para que en el objeto sólo haya un único flujo al mismo tiempo.
 guarded: pueden llegar varias llamadas simultáneamente, pero sólo puede atenderse
una por vez.
 concurrent: pueden entrar múltiples llamadas al método provenientes de otros tantos
hilos y todas ellas se atienden concurrentemente.

Para organizar mejor las listas largas de atributos y operaciones, se pueden utilizar
estereotipos para anteponer a cada grupo una categoría descriptiva, sin que estas estén
predeterminadas.

- 70 -
Responsabilidades
Al modelar clases, un buen comienzo consiste en especificar las responsabilidades de los
elementos del vocabulario. Una clase puede tener cualquier número de responsabilidades,
aunque, en la práctica, cada clase bien estructurada tiene al menos una responsabilidad y a lo
sumo unas pocas. Al ir refinando los modelos, se traducirán esas responsabilidades en el
conjunto de atributos y mensajes que mejor satisfagan las responsabilidades de la clase.

Relaciones
Una relación es una conexión semántica entre objetos. Proveen un camino de comunicación
entre ellos. Algunas relaciones son:
 Asociación:

Se divide en 2:
o Agregación

o Composición

 Generalización

 Dependencia

Asociación
Dada una asociación entre dos clases, se puede navegar desde un objeto de una clase hasta
un objeto de la otra clase, y viceversa.
Es legal que ambos extremos de una asociación estén conectados a la misma clase. Esto
significa que, dado un objeto de la clase, se puede conectar con otros objetos de la misma
clase.
La navegabilidad en las asociaciones es bidireccional.

- 71 -
Rol: cuando una clase participa en una asociación, tiene un rol específico que juega en la
asociación. Un rol es simplemente la cara que la clase de un extremo de la asociación presenta
a la clase del otro extremo. Se puede nombrar explícitamente el rol que juega una clase en una
asociación. La misma clase puede jugar el mismo o diferentes roles en otras asociaciones.

Navegabilidad: indica qué objeto conoce a quien. En el caso presentado, un usuario conoce
una clave, pero una clave no conoce a un usuario.
Si se quiere bidireccionalidad puede indicarse indistintamente con una flecha en cada punta de
la asociación o sólo con la asociación, sin flechas en los finales.

Multiplicidad: el “cuántos” se denomina multiplicidad del rol de la asociación, y se escribe como

una expresión que se evalúa a un rango de valores o a un valor explícito.
Cuando se indica una multiplicidad en un extremo de una asociación, se está especificando
que cada objeto de la clase conoce a tantos objetos como los indicados en la multiplicidad en
este extremo opuesto.
Ante ausencia de cardinalidad se asume 1
En el siguiente ejemplo se muestra como indicar la multiplicidad: Exactamente uno, Cero o uno,
Muchos, Uno a más, Número exacto, Lista, Rango

Agregación
Una asociación entre dos clases representa una relación estructural entre iguales, es decir,
ambas clases están conceptualmente en el mismo nivel, sin ser ninguna más importante que la
otra.
La agregación sirve para modelar una relación “todo/parte”, en la cual una clase representa el
“todo”, que se compone de otros elementos (las “partes”). Este tipo de relación se denomina
agregación, la cual representa una relación del tipo “tiene-un”, o sea, un objeto del todo tiene
objetos de la parte.
El rombo vacío distingue el “todo” de la “parte”. Esto significa que la agregación simple no
cambia el significado de la navegación a través de la asociación entre el todo y sus partes, ni
liga la existencia del todo y sus partes.

- 72 -
Composición
Es una forma de agregación, con fuerte sentido de posesión y tiempo de vida coincidentes de
las partes con el conjunto. Notar que una parte siempre se asocia a un todo. NO PUEDE
PASAR que una parte se asocie a más de un todo.
Las palabras que mejor definen a este tipo de asociación son:
 exclusividad
 dependencia

Notación accesoria
Una asociación puede tener un nombre, que se utiliza para describir la naturaleza de la
relación. Para que no haya ambigüedad en su significado, se puede dar una dirección al
nombre por medio de una flecha que apunte en la dirección en la que se pretende que se lea el
nombre.
Nota: aunque una asociación puede tener un nombre, normalmente no se necesita incluirlo si
se proporcionan explícitamente nombres de rol para la asociación, excepto si se tiene un
modelo con muchas asociaciones y es necesario referirse a una o distinguir unas de otras. Esto
es esencialmente cierto cuando se tiene más de una asociación entre las mismas clases.

Generalización
La generalización representa a la relación “es-un”: un elemento concreto es-un elemento más
general. La generalización especifica que los objetos hijos se pueden emplear en cualquier
lugar que pueda aparecer el padre, pero no a la inversa. Una clase hija hereda las propiedades
de sus clases padres (atributos, asociaciones y operaciones). A menudo, no siempre, el hijo
añade atributos y operaciones a los que hereda de sus padres. Una operación de un hijo con la
misma firma que una operación del padre redefine la operación del padre.

- 73 -
 • Nota: Una generalización puede tener un nombre, aunque es raro que se necesiten los
nombres, a menos que se tenga un modelo con muchas generalizaciones y haya que
referirse a ellas o distinguirlas.
En UML, una clase puede tener ninguno, uno o más padres. Una clase sin padres y uno o más
hijos se denomina clase raíz o clase base. Una clase sin hijos se llama clase hoja. Una clase
con un único padre se dice que utiliza herencia simple; una clase con más de un padre se dice
que utiliza herencia múltiple.

Una generalización simple, sin adornos, es suficiente para la mayoría de las relaciones de
herencia que aparecen en el modelado. Pero si se quieren especificar ciertos matices, UML
aporta cuatro restricciones que pueden aplicarse a las generalizaciones.
• complete: especifica que todos los hijos en la generalización se han especificado en el
modelo (aunque puede que algunos se omitan en el diagrama) y no se permiten hijos
adicionales.
• incomplete: especifica que no se han especificado todos los hijos en la generalización
(incluso aunque se omitan algunos) y que se permiten hijos adicionales. Es la opción
por defecto.
• disjoint: especifica que los objetos del padre no pueden tener más de uno de los hijos
como tipo.
• overlapping: especifica que los objetos del padre pueden tener más de uno de los hijos
como tipo.
Nota: disjoint y overlapping se aplican en el contexto de herencia múltiple.

Dependencia
Representa un tipo de relación muy particular, en la que una clase es instanciada (su
instanciación es dependiente de otro objeto/clase).
El uso más particular de este tipo de relación es para denotar la dependencia que tiene una
clase de otra.

Ejemplo:
La creación del Objeto Formulario está condicionado a la instanciación proveniente desde el
objeto Sistema

- 74 -
Notas
Las notas permiten agregar comentarios que se pueden utilizar para describir, clarificar y hacer
observaciones sobre cualquier elemento de un modelo.
Se marca por medio de línea punteada al elemento al cual están ligados y por lo tanto,
comentan.
El comentario puede hacerse en lenguaje coloquial o en un lenguaje formal como lo es OCL.
Gráficamente, una nota se representa como un rectángulo con una esquina doblada, junto con
un comentario (no puede estar sin texto).

- 75 -
Módulo IV

POO con C#

- 76 -
1- POO con C#

C#
C# es un lenguaje de programación orientado a objetos que utiliza clases y estructuras para
implementar tipos como formularios Windows Forms, controles de interfaz de usuario y
estructuras de datos. Una aplicación de C# típica se compone de clases definidas por el
programador, junto con clases de .NET Framework.
C# ofrece varias maneras eficaces de definir clases, por ejemplo, proporcionar niveles de
acceso diferentes, heredar características de otras clases y permitir que el programador
especifique qué sucede cuando se crean o destruyen instancias de tipos.

Clases
En C#, una clase es un tipo de datos muy eficaz. Como las estructuras, las clases definen los
datos y el comportamiento del tipo de datos. Los programadores pueden crear objetos que son
instancias de una clase. A diferencia de las estructuras, las clases admiten herencia, que es
una parte fundamental de la programación orientada a objetos.

<modificadorDeVisibilidad> class <nombre>

{
<miembros>
}

Ejemplo

public class Alumno

{

Campos
Los campos almacenan los datos que una clase necesita para cumplir su cometido. Por
ejemplo, una clase que representara una fecha del calendario podría tener tres campos
enteros: uno para el mes, otro para el día y un tercero para el año. Los campos se declaran
dentro del bloque de la clase especificando el nivel de acceso del campo, seguido por el tipo
del campo, y seguido por el nombre del campo

<modificadorDeVisibilidad> <tipo> <nombre>;

Ejemplo

public int mes;

public int dia;
public int anio;

En este ejemplo se utilizan campos que son public, pero esto no se recomienda en la práctica.
Los campos generalmente deberían ser private. El acceso a campos por parte de clases
externas debería ser indirecto, por medio de métodos o propiedades

- 77 -
Propiedades
Las propiedades son miembros que ofrecen un mecanismo flexible para leer, escribir o calcular
los valores de campos privados. Se pueden utilizar las propiedades como si fuesen miembros
de datos públicos, aunque en realidad son métodos especiales denominados descriptores de
acceso. De este modo, se puede tener acceso a los datos con facilidad, a la vez que
proporciona la seguridad y flexibilidad de los métodos.
Son el mecanismo que C# provee para encapsular un campo de un objeto con un método de
lectura (get) y un método de escritura (set). El descriptor de acceso de una propiedad get se
utiliza para devolver el valor de la propiedad y el descriptor de acceso set se utiliza para
asignar un nuevo valor. Estos descriptores de acceso pueden tener niveles de acceso
diferentes. La palabra clave value se utiliza para definir el valor asignado por set.
Las propiedades que no implementan un método set son de sólo lectura.
La sintaxis de acceso es como una variable pública.

<modificadorDeVisibilidad> <tipo> <nombre>

{
get{ //Codigo con un valor de retorno del tipo <tipo> }
set{ //codigo }
}

Ejemplo

private string nombre; //campo

public string Nombre //Propiedad
{
get { return nombre;}
set { nombre = value;}
}

Opcionalmente el get o el set (pero no ambos) pueden cambiar la accesibilidad del mismo.
A diferencia de los campos, las propiedades no están clasificadas como variables. Las
propiedades tienen muchos usos: validan datos antes de permitir un cambio; exponen datos de
forma transparente en una clase donde se recuperan realmente los datos de otro origen, como
una base de datos; realizan una acción cuando se modifican datos, por ejemplo, provocar un
evento, o cambian el valor de otros campos.

public class Fechas

{
private int mes;
public int Mes
{
get { return mes;}
set {
if ((value > 0) && (value < 13))
{
mes = value;
}
else
{
throw new Exception(“Mes incorrecto”);
}
}
}
}

- 78 -
Métodos
Los métodos son un bloque de código que contiene una serie de instrucciones. En C#, cada
instrucción se ejecuta en el contexto de un método.
Los métodos se declaran en una clase o estructura especificando el nivel de acceso, el valor
devuelto, el nombre del método y los parámetros de método. Los parámetros de método se
incluyen entre paréntesis y separados por comas. Los paréntesis vacíos indican que el método
no requiere ningún parámetro.

<modificadorDeVisibilidad> <tipo> <nombre>(<Parámetros>)

{
//Código
}

 Donde <tipo> es el tipo de retorno o void si no retorna nada

 Puede no tener parámetros
 No se pueden escribir dos métodos con el mismo nombre, los mismos parámetros y
que retornen distintos tipos de valores.

Ejemplos
public void cambiarNombre(string nuevoNombre)
{
Nombre = nuevoNombre;
}
public int cumpleaños()
{
Edad = Edad + 1;
return Edad;
}
public string imprimirNombreApellido(string apellido)
{
return Nombre + ” “ + apellido;
}

Parámetros de los métodos

Los parámetros que un método recibe se proporcionan entre paréntesis, se debe especificar el
tipo de dato y nombre de cada parámetro.
Una variable de tipo de valor contiene directamente los datos, a diferencia de una variable de
tipo de referencia, que contiene una referencia a los datos. Por lo tanto, pasar una variable de
tipo de valor a un método significa pasar una copia de la variable al método. Cualquier cambio
en el parámetro que se produzca dentro del método no afectará a los datos originales
almacenados en la variable. Si se desea que el método llamado pueda cambiar el valor del
parámetro, deberá pasarlo por referencia, utilizando la palabra clave ref u out.

public void Cuadrado(ref int x)

{
x *= x ;
}

Sobre Carga
La sobrecarga consiste en crear más de un procedimiento, constructor de instancia o propiedad
en una clase con el mismo nombre y distintos tipos de argumento

- 79 -
La lista de argumentos DEBE ser diferente, es decir, no puede haber dos métodos que se
llamen igual con la misma lista de argumentos, aunque devuelvan datos de distinto tipo.
Cuando hablamos de argumentos nos referimos a la cantidad de parámetros y a su tipo de
dato, no al nombre del parámetro. El compilador sabrá a cuál de todas las sobrecargas nos
referimos por los argumentos que se le pasen en la llamada, pero no sería capaz de determinar
cuál de ellas debe ejecutar si tienen la misma lista de argumentos

public int Sumar(int x, int y)

{
return x + y ;
}
public int Sumar(int x, int y, int z)
{
return x + y + z;
}

Creación de Instancias
Para crear un objeto, debe crear una o varias instancias de una clase. Para ello se usa la
cláusula new

StringBuilder obj = new StringBuilder ();

Una vez creadas las instancias de una clase, puede asignar valores a las propiedades y los
campos de la instancia, así como invocar métodos de clase.

StringBuilder obj = new StringBuilder ();

obj.Capacity = 100;
obj.Append("Agregar un texto");

Modificadores de Acceso
Los modificadores son elementos del lenguaje que se colocan delante de la definición de
variables de instancia y métodos que alteran o condicionan el significado del elemento. Los
modificadores de acceso permiten al diseñador de una clase determinar quien accede a los
datos y métodos de la misma. En C#, por defecto, se considera que los métodos y variables de
instancia solo son accesibles desde el código interno de la clase.
Los miembros pueden ser:
 public: los miembros public pueden ser accedidos desde cualquier objeto o sección de
código, desde el mismo ensamblado o desde otro ensamblado con referencias.
 protected: desde una clase sólo puede accederse a miembros protected de objetos de
esa misma clase o de subclases suyas, o sea miembros en la línea de herencia.
 private: sólo pueden ser accedidos desde el código de la clase a la que pertenece. Es
lo considerado por defecto.
 internal: sólo pueden ser accedidos desde código perteneciente al ensamblado en que
se han definido.
 protected internal: sólo pueden ser accedidos desde código perteneciente al
ensamblado en que se han definido o desde clases que deriven de la clase donde se
ha definido.

También es posible aplicar modificadores de acceso a las clases. Los modificadores de acceso
permitidos son:
 public: es posible acceder a la clase desde cualquier ensamblado.

- 80 -
  internal: sólo es posible acceder a la clase desde el ensamblado donde se declaró. Es
lo considerado por defecto.

Estructuras
Las estructuras se definen mediante la palabra clave struct, por ejemplo

public struct Punto{

int x;
int y;
}

Casi todas las estructuras comparten la misma sintaxis que las clases, aunque están más
limitadas que éstas:
 Dentro de una declaración de estructura, los campos no se pueden inicializar a menos
que se declaren como constantes o estáticos.
 Una estructura no puede declarar un constructor predeterminado (es decir, un
constructor sin parámetros) ni un destructor.
 Las estructuras no pueden heredar de clases u otras estructuras.
 Las estructuras se copian en la asignación. Cuando se asigna una estructura a una
nueva variable, se copian todos los datos, y cualquier modificación que se realice en la
nueva copia no afecta a los datos de la copia original.
 Las estructuras son tipos de valor y las clases son tipos de referencia.
 A diferencia de las clases, se pueden crear instancias de las estructuras sin utilizar un
operador new.
 Las estructuras pueden declarar constructores que tienen parámetros.
 Una estructura no puede heredar de otra estructura o clase, ni puede ser la base de
una clase. Todas las estructuras heredan directamente de System.ValueType, que
hereda de System.Object.
 Una estructura puede implementar interfaces.
 Una estructura se puede utilizar como tipo que acepta valores null y se le puede
asignar un valor null.

Interfaces
Las interfaces describen un grupo de funcionalidades relacionadas que pueden pertenecer a
cualquier elemento class o struct. Para definir una interfaz, utilice la palabra clave interface,
como se muestra en el ejemplo siguiente.

public interface iPrueba{

int Metodo1(int x, int y);
void Metodo2(string param1);
}

Las interfaces están compuestas de métodos, propiedades, eventos, o cualquier combinación

de estos. Una interfaz no puede contener constantes, campos, operadores, constructores de
instancias, destructores o tipos. No puede contener miembros estáticos. Los miembros de
interfaz son automáticamente públicos y no pueden incluir ningún modificador de acceso
Cuando una clase o struct implementa una interfaz, dicha clase o struct proporciona una
implementación para todos los miembros que define la interfaz. La propia interfaz no
proporciona ninguna funcionalidad que una clase o struct pueda heredar de la manera en que
se puede heredar la funcionalidad de una clase base.

- 81 -
Constructores
Cada vez que se crea una clase o estructura, se llama a su constructor. Una clase o estructura
puede tener varios constructores que toman argumentos diferentes. Los constructores permiten
al programador establecer valores predeterminados, limitar la creación de instancias y escribir
código flexible y fácil de leer. En C# tienen el mismo nombre que la clase.
Si no proporciona un constructor para el objeto, C# creará uno de forma predeterminada, que
es el constructor sin parámetros, que crea instancias del objeto y establecer las variables
miembro con los valores predeterminados. Pueden sobre escribirse

public class Persona{

public Persona()
{
miPropiedad = 10;
}
}

Destructores
Los destructores se utilizan para destruir instancias de clases. Sólo se utilizan con clases. Una
clase sólo puede tener un destructor. Se invocan automáticamente. Un destructor no permite
modificadores de acceso ni tiene parámetros.
El destructor llama implícitamente al método Finalize en la clase base del objeto.
El programador no puede controlar cuándo se llama al destructor, porque esto lo determina el
recolector de elementos no utilizados (Garbage Collection). El recolector de elementos no
utilizados comprueba si hay objetos que ya no están siendo utilizados por ninguna aplicación.
Si considera un objeto elegible para su destrucción, llama al destructor (si existe) y reclama la
memoria utilizada para almacenar el objeto. También se llama a los destructores cuando se
cierra el programa.
Si la aplicación utiliza un recurso externo caro, también es recomendable liberar explícitamente
el recurso antes de que el recolector de elementos utilizados libere el objeto. Para ello debe
implementar un método Dispose desde la interfaz IDisposable que realiza la limpieza del
objeto necesaria. Esto puede mejorar considerablemente el rendimiento de la aplicación.
Aunque controle explícitamente los recursos, el destructor garantiza la liberación de recursos si
falla la llamada al método Dispose.

Garbage Collection
El recolector de elementos no utilizados de .NET Framework administra la asignación y
liberación de la memoria de la aplicación. Cada vez que se utiliza el operador new para crear
un objeto, el motor en tiempo de ejecución asigna al objeto memoria del montón (Heap)
administrado. Siempre que haya espacio de direcciones disponible en el montón nativo, el
motor en tiempo de ejecución continúa asignando espacio a los objetos nuevos. No obstante, la
memoria no es infinita. En ocasiones, el recolector de elementos no utilizados debe realizar una
recolección para liberar alguna memoria. El motor de optimización del recolector de elementos
no utilizados determina cuál es el mejor momento para realizar una recolección, según las
asignaciones que se estén realizando. Cuando el recolector de elementos no utilizados realiza
una recolección, comprueba si en el montón administrado hay objetos que la aplicación ya no
utiliza y realiza las operaciones necesarias para reclamar su memoria

Miembros Estáticos
Utilice el modificador static para declarar un miembro estático, que pertenece al propio tipo en
vez de a un objeto específico. El modificador static puede utilizarse con clases, campos,
métodos, propiedades, operadores, eventos y constructores, pero no puede utilizarse con
destructores o tipos que no sean clases.

- 82 -
No se puede hacer referencia a un miembro estático por medio de una instancia. En vez de
ello, se debe hacer referencia por medio del nombre de tipo.

public static class ClaseStatic

{
public static string MetodoStatico()
{
return "Método Estático";
}
}

// luego se usa SIN crear una instancia de la clase

string s = ClaseStatic.MetodoEstatico();

- 83 -
2- Herencia y Polimorfismo
Herencia
La herencia permite crear una nueva clase que reutiliza, extiende y modifica el comportamiento
que se define en otra clase. La clase cuyos miembros se heredan se denomina clase base y la
clase que hereda esos miembros se denomina clase derivada. Sin embargo, todas las clases
de C# heredan implícitamente de la clase Object que admite la jerarquía de clases .NET y
proporciona servicios de bajo nivel a todas las clases.
C# solo admite solo herencia simple. No admite herencia múltiple
Para que una clase herede a otra se coloca un signo de dos puntos después del nombre de la
clase al declararla.

Sintaxis
<modificadorDeVisibilidad> class <nombre> : <superclase>
{
}

La nueva clase (la clase derivada) obtiene todos los datos no privados y el comportamiento de
la clase base, además de todos los demás datos y comportamientos que define para sí misma.
La nueva clase tiene dos tipos efectivos: el tipo de la nueva clase y el tipo de la clase que
hereda.

Ejemplo
public class Persona
{
//Código
}
public class Alumno : Persona
{
//Código
}

this y base
La palabra clave base se utiliza para obtener acceso a los miembros de la clase base desde
una clase derivada. El acceso a una clase base sólo se permite en un constructor, en un
método de instancia o en un descriptor de acceso a una propiedad de instancia.
La palabra clave this hace referencia a la instancia actual de la clase y también se utiliza como
modificador del primer parámetro de un método de extensión.

public class ClaseBase

{
public string Metodo()
{
return "Metodo de la base";
}
}

public class ClaseDerivada : ClaseBase

{
public string MetodoDerivada()
{
base.Metodo();
this.Metodo();

- 84 -
 this.MetodoDerivada();
return "";
}
}

Cláusula Sealed y Abstract

De forma predeterminada, todas las clases se pueden heredar. Sin embargo, puede especificar
si una clase no se debe usar como clase base o bien crear una clase que solo se pueda usar
como clase base.
Nunca una clase abstracta podrá ser instanciada. Tiene métodos comunes a varias clases,
pero no puede ser una instancia en sí. Una clase abstracta puede contener métodos
abstractos, esto es, métodos que no tienen implementación. De esta forma, proporciona a sus
subclases la declaración de todos los métodos necesarios para implementar. Sin embargo, las
clases abstractas pueden dejar algunos detalles o toda la implementación de aquellos métodos
a sus subclases.
Los métodos abstractos son declarados pero no implementados. Si existe un método abstracto
entonces debemos declarar la clase como abstracta, y al declararla como tal no se pueden
crear instancias de ella. Sirven para definir conceptos incompletos, que deben ser completados
en las subclases de la clase abstracta.
Una clase abstracta puede tener métodos implementados

public abstract class Persona {

public abstract string TraerDatos();
}

Una clase sealed no se puede heredar. Un método sellado reemplaza un método en una clase
base.

public sealed class Persona {}

SobreEscritura (invalidación)
De forma predeterminada, una clase derivada hereda todos los miembros de su clase base. Si
desea cambiar el comportamiento del miembro heredado, debe sobre escribirlo. Es decir, se
puede definir una nueva implementación del método, la propiedad o el evento en la clase
derivada.
Para sobre escribir o invalidar un método se usa la cláusula override. La cláusula override
proporciona una nueva implementación de un miembro que se hereda de una clase base,
invalidando el método heredado. El método base reemplazado debe ser virtual, abstract u
override.

public class Persona

{
Public virtual string Metodo()
{
return "Metodo de la base";
}
}

public class Empleado : Persona

{
Public override string Metodo()
{
return "Metodo de la derivada";

- 85 -
 }
}

Conversiones (Casting)
Los operadores de conversión provistos por C# siguen la sintaxis:

<varTipoDestino> = (<tipoDestino>) <expresión>

Las conversiones se pueden hacer si:

El <tipoDestino> es superclase de la <expresión>

El <tipoDestino> y <expresión> tiene la misma interfaz
El <tipoDestino> sea del mismo tipo que la expresión

En los casos que no se pueden realizar el casteo devuelve InvalidCastException

En este ejemplo Alumno hereda de Persona por lo cual podemos crear un alumno y castearlo a
Persona pero no al revés.

Alumno alumno = new Alumno ();

Persona persona = (Persona) alumno;

Polimorfismo
A menudo se hace referencia al polimorfismo como el tercer pilar de la programación orientada
a objetos, tras la encapsulación y la herencia. El término polimorfismo es una palabra griega
que significa "con muchas formas".
El polimorfismo es una característica de los objetos que permite que un mismo mensaje pueda
ser respondido de distinta manera por objetos de distintas clases, generalmente de la misma
jerarquía. Así, el objeto emisor no tiene que saber de qué clase específica es el objeto a quien
le está enviando un mensaje, sólo necesita saber que el receptor puede responder a ese envío
de mensaje. En algunos casos puede suceder que varios tipos de objetos distintos hayan sido
definidos para responder a ese mensaje, lo que permite intercambiarlos sin que el objeto
emisor note la diferencia.
El uso del polimorfismo nos brinda una serie de ventajas a la hora de construir programas. En
primer lugar nos permite producir código genérico. Al utilizar esta técnica, el objeto emisor es
independiente del tipo específico del objeto receptor, lo que permite agregar nuevos tipos de
objetos que cumplan con el mismo protocolo sin impactar en el diseño del sistema.
Al utilizar objetos polimórficos decimos que trabajamos con un bajo nivel de acoplamiento; el
objeto emisor conoce lo mínimo indispensable del objeto al que le está enviando el mensaje
(no debe saber su tipo ni cómo implementa su comportamiento), lo cual brinda flexibilidad a
nuestro programa y evita la propagación de cambios locales en el resto del sistema.

Tiene dos aspectos que lo caracterizan:

 En tiempo de ejecución, los objetos de una clase derivada se pueden tratar como
objetos de una clase base en lugares como parámetros de método y colecciones o
matrices. Cuando esto sucede, el tipo declarado del objeto ya no es idéntico a su tipo
en tiempo de ejecución.
 Las clases base pueden definir e implementar métodos virtuales y las clases derivadas
pueden invalidarlos, lo que significa que proporcionan su propia definición e
implementación. En tiempo de ejecución, cuando el código de cliente llama al método,
CLR busca el tipo en tiempo de ejecución del objeto e invoca esta invalidación del

- 86 -
 método virtual. Así, en el código fuente puede llamar a un método de una clase base y
provocar la ejecución de la versión de clase derivada del método.
Los métodos virtuales permiten trabajar con grupos de objetos relacionados de una manera
uniforme. Por ejemplo, suponga que dispone de una aplicación de dibujo que permite a un
usuario crear varios tipos de formas en una superficie de dibujo. En tiempo de compilación no
conoce los tipos específicos de formas que creará el usuario. Sin embargo, la aplicación tiene
que realizar el seguimiento de los diferentes tipos de formas que se crean y tiene que
actualizarlos como respuesta a las acciones del mouse del usuario. Puede utilizar el
polimorfismo para resolver este problema en dos pasos básicos:
 Cree una jerarquía de clases en la que cada clase de forma específica derive de una
clase base común.
 Utilice un método virtual para invocar el método adecuado de una clase derivada a
través de una única llamada al método de clase base.

Ejemplo:
En primer lugar, cree una clase base llamada Formas y clases derivadas como Rectangulo,
Circulo y Triangulo. Incluya en la clase Formas un método virtual llamado Dibujar e invalídelo
en cada clase derivada para dibujar la forma determinada que representa la clase. Cree un
objeto List<Formas> y agregue elementos Circulo, Triangulo y Rectangulo a él. Utilice un bucle
foreach para recorrer en iteración la lista y llamar al método Dibujar en cada objeto Formas de
la lista. Aunque cada objeto de la lista tiene un tipo declarado de Formas, es el tipo en tiempo
de ejecución (la versión invalidada del método en cada clase derivada) el que se invocará.

public class Formas

{
public virtual string Dibujar()
{
return "Metodo Dibujar de la base";
}
}

public class Circulo : Formas

{
public override string Dibujar()
{
return "Dibuja un circulo";
}
}

public class Rectangulo : Formas

{
public override string Dibujar()
{
return "Dibuja un rectangulo";
}
}

public class Triangulo : Formas

{
public override string Dibujar()
{
return "Dibuja un triangulo";
}
}

- 87 -
public partial class Form1 : Form
{
private void button1_Click(object sender, EventArgs e)
{
List<Formas> lista = new List<Formas>();
lista.Add(new Rectangulo ());
lista.Add(new Triangulo());
lista.Add(new Circulo());

foreach (Formas s in lista)

{
MessageBox.Show( s.Dibujar());
}
}
}

- 88 -
3- Colecciones
Definición
.NET Framework ofrece clases especializadas para almacenamiento y recuperación de datos.
Estas clases proporcionan compatibilidad para pilas, colas, listas y tablas hash. La mayoría de
las clases de colección implementan las mismas interfaces, que se pueden heredar para crear
nuevas clases de colección que se ajusten a necesidades de almacenamiento de datos más
especializadas.
Las clases de colección tienen las propiedades siguientes:
 Las clases de colección están definidas como parte del espacio de nombres
System.Collections o System.Collections.Generic.
 La mayoría de las clases de colección derivan de las interfaces ICollection, IComparer,
IEnumerable, IList, IDictionary e IDictionaryEnumerator, y los tipos genéricos
equivalentes.
 Las clases de colección genéricas proporcionan una seguridad de tipos superior y, en
algunos casos, pueden proporcionar un rendimiento mayor, sobre todo cuando
almacenan tipos de valor
Los datos estrechamente relacionados se pueden tratar con más eficacia si se agrupan en una
colección. En lugar de escribir código independiente para tratar cada objeto individualmente,
puede usar el mismo código para procesar todos los elementos de una colección.
Al administrar una colección, utilice la clase Array y las clases System.Collections para
agregar, quitar y modificar elementos aislados o intervalos de elementos de la colección.
También se puede copiar una colección en otra.
Algunas clases Collections tienen capacidades de ordenación y la mayor parte están
indexadas. La administración de la memoria se controla automáticamente y la capacidad de
una colección se expande si es necesario. La sincronización proporciona seguridad para los
subprocesos cuando se tiene acceso a los miembros de una colección. Algunas clases
Collections pueden generar contenedores que hacen que la colección sea de sólo lectura o que
tenga un tamaño fijo. Algunas clases Collections pueden generar su propio enumerador que
facilita la iteración por los elementos.

Colecciones no Genéricas
Un objeto Collection almacena cada elemento en un Object; por tanto, la lista de elementos
que se pueden agregar es igual que la de cosas que se pueden almacenar en una variable de
objeto. Ésta incluye tipos de datos estándar, objetos y matrices, así como estructuras definidas
por el usuario e instancias de clase.
Puesto que el objeto Collection almacena cada elemento como un objeto, el tipo de referencia
que devuelve la propiedad Item es Object. Esto plantea el tema de cómo se puede tener
acceso a los miembros de la colección posteriormente, hay que convertir los datos al tipo de
dato correspondiente, con su correspondiente sobrecarga.
Algunos ejemplos de este tipo de collecciones: ArrayList, HashTable, etc.

Colecciones Genéricas
En general, es recomendable utilizar colecciones genéricas porque se obtiene la ventaja
inmediata de la seguridad de tipos sin necesidad de derivar de un tipo de colección base e
implementar miembros específicos de los tipos. Además, por lo general los tipos de colección
genéricos tienen un mejor rendimiento que los tipos de colección no genéricos
correspondientes (y mejor que el de los tipos derivados de tipos de colección base no
genéricos) cuando los elementos de la colección son tipos de valor, porque con los genéricos
no hay necesidad de realizar conversiones boxing de los elementos.
Los siguientes tipos genéricos corresponden a los tipos de colección existentes:
 List<T> es la clase genérica que se corresponde con ArrayList.

- 89 -
  Dictionary<TKey, TValue> es la clase genérica que se corresponde con Hashtable.
 Collection<T> es la clase genérica que se corresponde con CollectionBase.
Collection<T> se puede utilizar como clase base, pero a diferencia de CollectionBase,
no es abstracta. Esto facilita mucho su uso.
 ReadOnlyCollection<T> es la clase genérica que se corresponde con
ReadOnlyCollectionBase. ReadOnlyCollection<T> no es una clase abstracta y tiene un
constructor que facilita la exposición de un objeto List<T> como una colección de sólo
lectura.
 Las clases genéricas Queue<T>, Stack<T> y SortedList<TKey, TValue>
corresponden a las respectivas clases no genéricas que tienen los mismos nombres.

List<T>
Representa una lista de objetos con establecimiento inflexible de tipos a la que se puede
obtener acceso por índice. Proporciona métodos para buscar, ordenar y manipular listas.
La clase List<T> es el equivalente genérico de la clase ArrayList. Implementa la interfaz
genérica IList<T> mediante una matriz cuyo tamaño aumenta dinámicamente según se
requiera.
La clase List<T> utiliza un comparador de igualdad y un comparador de orden. No se garantiza
que el objeto List<T> esté ordenado. Debe ordenar List<T> antes de realizar operaciones que
requieran que dicho objeto List<T> esté ordenado.
Se puede obtener acceso a los elementos de esta colección utilizando un índice entero. Los
índices de esta colección están basados en cero.
List<T> acepta null como valor válido para los tipos de referencia y permite elementos
duplicados.

Ejemplo:

List<int> Numeros = new List<int>();

Numeros.Add(1);
Numeros.Add(2);

List<string> Datos = new List<string>();

Datos.Add("Buenos Aires");
Datos.Add("Córdoba");

foreach (int i in Numeros)

{
MessageBox.Show(i.ToString());
}

Dictionary<TKey, TValue>
Representa una colección de claves y valores.
 TKey: Tipo de las claves del diccionario.
 TValue: Tipo de los valores del diccionario.
La clase genérica Dictionary<TKey, TValue> proporciona una asignación de un conjunto de
claves a un conjunto de valores. Cada elemento que se agrega al diccionario está compuesto
de un valor y su clave asociada. Recuperar un valor utilizando su clave es muy rápido, porque
la clase Dictionary<TKey, TValue> se implementa como una tabla hash.
Mientras se utilice un objeto como clave en el diccionario Dictionary<TKey, TValue>, dicho
objeto no se debe modificar en modo alguno que afecte a su valor hash. Cada clave de un
diccionario Dictionary<TKey, TValue> debe ser única conforme al comparador de igualdad del

- 90 -
diccionario. Una clave no puede ser null, aunque un valor sí puede serlo si el tipo de valor
TValue es un tipo de referencia.

Dictionary<string, string> openWith = new Dictionary<string,

string>();
openWith.Add("txt", "notepad.exe");
openWith.Add("bmp", "paint.exe");
openWith.Add("dib", "paint.exe");
openWith.Add("rtf", "wordpad.exe");

// modifica el valor
openWith["rtf"] = "winword.exe";

- 91 -
 Módulo V

Introducción a XHTML y
Script

- 92 -
1- XHTML

Definición
XHTML significa lenguaje de marcado de hipertexto extendido.
Se utiliza para generar documentos y contenidos de hipertexto generalmente publicados en la
Web. Es además una reformulación del lenguaje HTML ahora compatible con XML.
Un lenguaje de marcado nos permite dejar indicaciones en un documento que sirven para
diferenciar distintos tipos de contenidos, estructuras o secciones. Por ejemplo existen
elementos o etiquetas que pueden "marcar" qué es un título, y su lugar en una jerarquía de
importancia, o advertir que una palabra debe estar enfatizada, o bien que una oración es
además un enlace hacia otro recurso, etc.
El XHTML está diseñado para que sea funcional no sólo a los navegadores sino a varios
dispositivos Web (teléfonos móviles, portátiles, etc.).

Las ventajas más evidentes que ofrece el migrar a XHTML son:

 Los documentos XHTML se establecen en base a las reglas XML. Por tanto, pueden
ser visualizados, editados y validados por cualquier herramienta estándar XML.
 Los documentos XHTML pueden escribirse para que funcionen igual o mejor que lo
hacían antes tanto en los agentes de usuarios conformes a HTML 4.0 como en los
nuevos agentes conformes a XHTML 1.0.
 Los documentos XHTML pueden contener aplicaciones (por ejemplo applets o scripts)
que se basen en DOM y que modifiquen la propia estructura del documento XHTML.
 Permite insertar en el documento XHTML nuestras propias marcas que no tienen por
qué estar definidas en el estándar general. Esto es lo que se llama modularización
XHTML.
 Se estima que para el año 2002 el 75% de los accesos a la Red se harán a través de
dispositivos que no son PC’s. XHTML está diseñado para poder ser visualizado en
cualquier tipo de plataforma.
 Hacer las páginas legibles por personas discapacitadas. Al no tener marcas que
indiquen forma de representación entremezcladas con el propio contenido, es mucho
más fácil construir agentes de usuario que lean ese contenido a personas invidentes o
lo pasen a otros formatos como Braille.

Diferencias con HTML 4.01

La siguiente lista muestra algunas reglas de XHTML 1.0 que lo diferencian de HTML 4.01.
Muchas de estas diferencias vienen por una aplicación del más estricto XML:
 Los elementos vacíos deben cerrarse siempre:
o Incorrecto: <br>
o Correcto: <br></br> o <br/> o <br />
Nota: Cualquiera de las tres formas es válida en XHTML
 Los elementos no vacíos también deben cerrarse siempre:
o Incorrecto: <p>Primer párrafo<p>Segundo párrafo
o Correcto: <p>Primer párrafo</p><p>Segundo párrafo</p>
 Los elementos anidados deben tener un correcto orden de apertura/cierre (el que se
abre último, debe cerrarse primero).
o Incorrecto: <em><strong>Texto</em></strong>
o Correcto: <em><strong>Texto</strong></em>
 Los valores de los atributos deben siempre ir encerrados entre comillas (simples o
dobles).
o Incorrecto: <td rowspan=3>
o Correcto: <td rowspan="3">
o Correcto: <td rowspan='3'>

- 93 -
  Los nombres de elementos y atributos deben ir en minúsculas. Esto se debe a que
XML diferencia mayúsculas de minúsculas
o Incorrecto: <A HREF="http://www.domname.com">Domname</A>
o Correcto: <a href="http://www.domname.com">Domname</a>
 No está permitida la minimización de atributos (se usa el nombre del atributo como
valor).
o Incorrecto: <textarea readonly>Solo-lectura</textarea>
o Correcto: <textarea readonly="readonly">Solo-lectura</textarea>
 Los atributos desaprobados en HTML 4.01 no forman parte de XHTML.
o Incorrecto: <font color="#0000FF">Blue text</font>
o Correcto: <span style="color: #0000FF;">Blue text</span>

Etiquetas y Atributos
En la escritura de los documentos se usan de etiquetas (tags) como principal elemento de
sintaxis, que para diferenciarse del contenido, están encerradas por paréntesis angulares <>.
Ejemplo del uso de etiquetas, con el elemento p (párrafo):

<p>Contenido del parrafo</p>

<p> marca el inicio de la sección que contendra un párrafo, </p> marca el final del párrafo.
Toda etiqueta abierta debe ser cerrada escribiendose de nuevo con el agregado de una barra
entre la palabra y el paréntesis de angular de apertura.
Algunos elementos que no llevan contenido se nos permite escribirlos de manera tal que la
apertura y el cierre se representan con una única etiqueta. El elemento br utilizado para el salto
de línea, se puede escribir así <br /> que es una simplificación de la forma también válida:
<br></br>.
Las etiquetas de apertura pueden contener atributos que especifican características
particulares de ésta. Los atributos tienen un nombre seguido de un igual y entre comillas el
valor de tal atributo.

Ejemplo del elemento a con atributos:

<a href="http://www.microsoft.com">Microsoft</a>

La etiqueta es <a>, el atributo es href y el valor es http://www.microsotf.com. Con esta etiqueta

se construyen los vínculos. Tanto los elementos, cómo los atributos y valores, deben escribirse
en letras minúsculas. Los valores de los atributos van obligatoriamente entre comillas (incluso
cuando estos valores sean números).
Los elementos soportan anidamiento con algunas restricciones.

Ejemplo de anidamiento con los elementos a e img:

<a href="http://www.example.com"><img src="ejemplo.gif"/></a>

El enlace que en el ejemplo anterior se lo habíamos aplicado a la palabra Microsoft ahora se lo

aplicamos a una segunda etiqueta (img) la cual tiene la finalidad de mostrar imagenes, por lo
que que la etiqueta más externa (elemento a) convierte a la imagen en un vínculo.

Primer documento XHTML

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"

"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">

- 94 -
<!--Este es un comentario y no sera tomado en cuenta por el navegador
-->
<html xmlns="http://www.w3.org/1999/xhtml" >
<head>
<title>Titulo de la pagina</title>
</head>
<body>
<p>
Primer documento XHTML, es decir un, Hola mundo</p>
</body>
</html>

Analizando el código línea a línea:

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"

"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">

Este es el encabezado que deberían llevar todos los documentos XHTML1.0 estríctos acordes
a las específicaciones de la W3C. Es un aviso para que el navegador o buscador sepa que tipo
de documento va a interpretar. En este caso el tipo de documento es strict.dtd, los elementos
utilizados serán sólo los incluídos en el lenguaje XHTML 1.0. Si se utilizan etiquetas antiguas y
se declara el documento cómo estricto, no se podrá validar la página XHTML.

Nota: El salto de línea a la mitad de la etiqueta no es interpretado y tampoco lo es en el

contenido a menos que lo explicite una etiqueta <br />. Simplemente se incluyen saltos de línea
para hacer el código más legible.

<!--Este es un comentario y no sera tomado en cuenta por el navegador

-->

Los comentarios comienzan con <!-- y terminan con --> (los saltos de línea no los quiebran). No
son tomados en cuenta por el navegador o buscador, es decir no se interpretan (por lo que no
se representan) y se utilizan frecuentemente para hacer aclaraciones en el código.

<html xmlns="http://www.w3.org/1999/xhtml" >

Aquí comienza al documento XHTML propiamente dicho. Todo documento debe llevar esta
etiqueta de apertura (<html>) y al finalizar debemos escribir la etiqueta de cierre que en el
ejemplo se encuentra al final del código (</html>). El atributo xmlns específica el tipo de
documento.

<head>
<title>Titulo de la pagina</title>
</head>

Con la etiqueta de apertura <head> comienza lo que se llama el encabezado de las páginas
web. La etiqueta <title> encierran el título de la página. Los navegadores suelen mostrarlo
cómo título de la ventana. También es utilizada por los buscadores cuando presentan
resultados de los documentos a sus usuarios.

<body>
<p>
Primer documento XHTML, es decir un, Hola mundo</p>
</body>

- 95 -
El cuerpo que comienza con <body> contiene todo el contenido que será representado por el
navegador. En nuestro ejemplo sólo utilizamos una etiqueta más, <p> que sirve para encerrar
párrafos.
Cerrando el cuerpo (</body>) y el documento XHTML (</html>) conseguimos nuestra primer
página.

Al probar el ejemplo deberíamos ver algo así:

Encabezados o títulos
Los encabezados o títulos se pueden obtener mediante 6 etiquetas diferentes: h1, h2, h3, h4,
h5 y h6 que tienen una jerarquía de importancia en la manera en que se representan por los
navegadores. Esto significa que h1 será la etiqueta del título de mayor importancia lo que se
traduce en, por ejemplo, un tamaño de letra mas grande, h2 representaría un subtítulo con letra
más pequeña y así sucesivamente hasta la etiqueta h6.

Ejemplo:

<body>
<h1>Encabezado con etiqueta h1</h1>
<h2>Encabezado con etiqueta h2</h2>
<h3>Encabezado con etiqueta h3</h3>
<h4>Encabezado con etiqueta h4</h4>
<h5>Encabezado con etiqueta h5</h5>
<h6>Encabezado con etiqueta h6</h6>
</body>

Al probar el ejemplo deberíamos ver algo así:

- 96 -
Elemento strong
Semánticamente strong marca contenido al que se le quiere dar más fuerza o importancia que
el resto. Los navegadores suelen formatearlo en una tipografía tipo negrita. Es un elemento de
línea.

Ejemplo:

<p>Este es un texto <strong>resaltado</strong></p>

Resultado:

Elemento em
El elemento em agrega énfasis al contenido. Al igual que strong es un elemento de línea.

Ejemplo

<p>Una corriente filosofica afirma que lo que progresa es la

<em>tecnologia</em>, el hombre no.</p>

Resultado:

- 97 -
Elemento span
Especifica un contenedor de línea para textos. No altera el contenido, pero pueden ser usados
para aplicar estilos.

Ejemplo:

<span>Provincias</span> <span>Buenos Aires</span> <span>mendoza</span>

Resultado:

Enlaces o Hipervínculos
Los enlaces son los que permiten la navegación por la Web, es decir que vayamos saltando
por diferentes páginas de un mismo sitio, o de sitios externos. La etiqueta utilizada para crear
un vínculo es a (anchor).
No necesariamente un enlace apuntará a una página web, puede por ejemplo apuntar a una
imagen, a un servidor FTP, a cualquier otro tipo de archivo, a un correo electrónico o incluso
puede apuntar a hacia otros sectores de la misma página (previamente marcando estos
sectores).

Ejemplo:

<a href="http://www.Microsoft.com">Página de Microsoft</a>

En el navegador se mostrará: “Página de Microsoft”. La dirección http://www.Microsoft.com es

el valor del atributo href, el texto “Página de Microsoft”, encerrada entre <a> y </a>, es lo que
suele llamarse el anchor text y es el contenido que será visible en el navegador.

Para crear un enlace hacia un correo electrónico debemos apuntar en el valor del atributo href
hacia una dirección de correo electrónico, pero es importante agregar al principio de la
dirección el mailto: que vendría a representar el protocolo (http://, ftp://, etc).

- 98 -
Ejemplo:

<a href="mailto:mail@example.com">Correo de ejemplo</a>

Como en el caso anterior, veremos en nuestro navegador: “Correo de ejemplo”. Si prueban el

enlace seguramente su navegador disparará el cliente de correo por defecto.

Muchas veces para enlaces entre páginas del mismo sitio y que tengan el mismo dominio, no
hace falta utilizar enlaces absolutos. Se puede crear un enlace de la siguiente manera:

<a href="subdirectorio/colegios.html">Ver los colegios</a>

Hay que destacar que en este caso hacer enlaces absolutos (escribiendo la dirección
completa) funcionará también.

Nota: Algunos buscadores recomiendan utilizar enlaces absolutos siempre que sea posible,
para mejorar la indexación por parte de sus motores.

También se pueden crear marcas (algunos las llaman anclas) y enlaces para poder navegar en
la misma página, sistema muy útil para crear un índice entre documentos largos.
La marca se realiza mediante el atributo id de la etiqueta a:

<h2><a id="privados"/>Colegios Privados</h2>

Se estableción un ancla llamada privados a la altura del título Colegios Privados ahora nos
hará falta colocar un enlace desde otro sector de la página que apunte hacia esa ancla. Para
esto:

<a href="#privados">Ir a Colegios Privados</a>

Se agrega el carácter numeral (#). Este se incluye ya que también podríamos construir el
enlace utilizando la dirección absoluta lo que implicaría que necesitamos una separación entre
las anclas y la dirección de la página, ya que la ancla tiene su propia dirección absoluta:
http://www.example.com/subdirectorio/colegios.html#privados.

- 99 -
Imagenes
Además de texto, se pueden incorporar al contenido de nuestros documentos XHTML archivos
de imagenes que pueden contener fotografías, dibujos, diagramas, etc.
Hay una seria discusión acerca de que formato de imagenes es conveniente utilizar para el
empleo en la web, que incluye temas variados y complejos cómo: algoritmos de compresión de
imagenes, patentes, calidad, y compatibilidad. Algunos de los mejores formatos a usar son las
imagenes libres de patentes PNG o los archivos JPEG o GIF.
El elemento para insertar imagenes es img. Su principal atributo es src (de source). Este
atributo lleva como valor la dirección (relativa o absoluta) de la ubicación de la imagen.

Ejemplo:
<img src="microsoft.png" alt="Microsoft" />

La barra al final es necesaria ya que en XHTML todos los elementos deben cerrarse aunque no
contengan contenido, por eso se utiliza esta sintaxis para abrir y cerrar el elemento en la misma
etiqueta.
El atributo alt se usa para explicar en palabras el contenido de la fotografía. Los navegadores
basados en texto mostrarán el valor del atributo en vez de la imagen, otros navegadores para
no videntes podrían leer y reproducir con un sintetizador el valor del atributo. Es muy
recomendable su uso, ya que además si la imagen por cualquier motivo no puede ser
mostrada, se presentará el valor de alt en lugar de la imagen.
Podemos además específicar la altura y el ancho de la imagen, mediante el uso de los
atributos height y width respectivamente.
En el ejemplo anterior se muestra cómo incorporar una imagen a un documento sin específicar
estos atributos, el problema de hacerlo de ese modo, es que el navegador no podrá calcular el
espacio que ocupará la imagen hasta que no termine de obtenerla. Esto podría resultar en una
carga más lenta del renderizado final de la página. Es muy conveniente averiguar el tamaño de
nuestras imagenes en píxeles y especificarlo en los atributos height y width.

Ejemplo:
<img src="microsoft.png" alt="Microsoft" height="40" width="40" />

Otro motivo para el uso de estos atributos, podría ser el cambio en las dimensiones y no usar el
tamaño de la imagen original, para eso, hay que tener en cuenta las siguientes
consideraciones:
 Si se achica el ancho y la altura, se hace sólo en la apariencia del documento. El
archivo mantendrá el tamaño original, por lo que podríamos estar gastando recursos
innecesariamente.
 Si se aumentan las dimensiones se podría lograr un efecto no deseado que es la
"pixelización" (algo así como una notable perdida de calidad) de la imagen.
 Se debería también mantener las proporciones al cambiar los valores originales de la
imagen mediante height y width, si no la imagen podría deformarse.
Lo conveniente sería editar y reajustar el tamaño de la imagen con algún software de edición
de imágenes.

El elemento img también soporta el atributo align, su uso no está recomendado, y se

recomienda el uso de la propiedad style de CSS.

<p>Este texto debería quedar a la izquiera de la imagen de Microsoft

<img src="microsoft.png" alt="Microsoft" height="40" width="40"
style="float:right "/></p>

- 100 -
Listas
Las listas ofrecen la posibilidad de presentar cierto tipo de información de una manera útil y
simple. No sólo para ordenarla, sino también entre otras cosas para jerarquizarla, o numerarla.
Para estos usos, XHTML nos permite construir diferentes tipos de listas, ya sea simples, o bien
compuestas utilizando anidamiento de etiquetas.

Listas ordenadas y númeradas: Al utilizar este tipo listas, los navegadores se encargarán de
agregar una numeración a cada item que por defecto suele ser decimal. El elemento ol
contiene los ítems de la lista que a su vez están contenidos por el elemento li. A cada ítem
introducido se le asignará un número empezando por 1.

Ejemplo:

<ol>
<li>Primera Opción</li>
<li>Segunda Opción</li>
<li>Tercera Opción</li>
</ol>

Listas desordenadas
Si se cambia el elemento ol por el elemento ul, se obtiene un efecto parecido, sólo que ésta
vez las listas no se presentan con ningún tipo de ordenamiento o numeración, sino con un
viñetado.

Ejemplo:

<ul>
<li>Primera Opción</li>
<li>Segunda Opción</li>
<li>Tercera Opción</li>
</ul>

Listas de definiciones
Con este tipo es posible construir listas de definiciones. Cada ítem de una lista de definición
contiene dos secciones, la primera es el contenido (ej. una palabra, una imagen, etc) a definir,
y la segunda la definición de la primera. Se construyen con el elemento dl.

- 101 -
Ejemplo:

<dl>
<dt>p</dt>
<dd>Elemento de bloque, para construir párrafos.</dd>
<dt>strong</dt>
<dd>Elemento de línea, para remarcar la importancia de un
contenido.</dd>
<dt>em</dt>
<dd>Elemento de línea, para enfátizar parte del contenido.</dd>
</dl>

El elemento dt marca el término a defirnir, y el elemento dd, marca la definición del anterior.

Elemento Table
A pesar de que las tablas HTML son fáciles de comprender y utilizar, son uno de los elementos
más polémicos de HTML. El problema de las tablas es que no siempre se utilizan
adecuadamente. Aunque parezca obvio, las tablas se deben utilizar para mostrar información
tabular, otros usos y abusos (como maquetación y diseño) se desaconsejan encarecidamente.
De nuevo: mantener por separado, el diseño del contenido.

Ejemplo:

<table>
<caption>Elementos XHTML</caption>
<thead>
<tr>
<th>ELEMENTO</th>
<th>TIPO</th>

- 102 -
 <th>SEMANTICA</th>
</tr>
</thead>
<tbody>
<tr>
<td>em</td>
<td>línea</td>
<td>mayor énfasis</td>
</tr>
<tr>
<td>strong</td>
<td>línea</td>
<td>mayor fuerza</td>
</tr>
<tr>
<td>pre</td>
<td>bloque</td>
<td>texto preformateado</td>
</tr>
</tbody>
</table>

Resultado

Los bordes no se ven ya que no están configurados. Para configurarlos se usa el atributo
border.
El elemento table da comienzo a la tabla. Dentro está el elemento caption que encierra el
título que llevará la tabla.
A partir de aquí se definen dos partes principales: thead dónde se ubica el encabezado, y
tbody que encierra a las celdas del cuerpo.
tr es el encargado de contener filas, el encabezado tiene una sola fila, cuyas celdas de
encabezado se contienen mediante tres etiquetas del elemento th.
Luego dentro del cuerpo (tbody) tenemos 3 filas más (tr) cuyas celdas se contienen mediante
el uso del elemento td.

El atributo summary se puede específicar dentro del elemento table, este permite agregar algo
de semántica, al ponerle como valor un resumen del contenido de la tabla para que pueda ser
reconocido por robots (ej. buscadores). Los navegadores no suelen representar summary.

- 103 -
Ejemplo:

<table summary="Elementos del lenguaje XHTML">...

Existe una tercera sección con el elemento tfoot, el cual determinará la sección del pie (al final
de la tabla).

Utilizamos un código parecido al anterior, pero con la sección foot y otros datos.

<table summary="Ventas Anuales">

<caption>Prueba Tablas</caption>
<thead>
<tr>
<th>Año</th>
<th>Ventas Anuales</th>
</tr>
</thead>
<tbody>
<tr>
<td>2010</td>
<td>5833</td>
</tr>
<tr>
<td>2011</td>
<td>7315</td>
</tr>
</tbody>
<tfoot>
<tr>
<th>Total</th>
<td>13148</td>
</tr>
</tfoot>
</table>

Resultado

- 104 -
En estos ejemplos se podría omitir marcar secciones (encabezado, cuerpo, pie) y la tabla
tendría el mismo aspecto, sin embargo marcar estas secciones no sólo la dotarán de un valor
semántico sino que también facilitará mucho la aplicación de estilos a estos grupos de celdas.

El atributo border controla la forma del borde.

Con el atributo colspan, es posible expandir celdas; fusionando estas con sus vecinas. El valor
que pueden tomar es numérico. El número representa la cantidad de celdas fusionadas. El
atributo que permite expandir las filas se llama rowspan. Define el número de celdas en la
columna situadas debajo de la actual que se unen a ésta.

Ejemplo:

<h4>Celdas con dos columnas y dos filas</h4>

<table border="1">
<tr>
<th>Nombre</th>
<th colspan="2">Telefono</th>
</tr>
<tr>
<td>Juan Perez</td>
<td>555 77 854</td>
<td>555 77 855</td>
</tr>
<tr>
<td rowspan="2">Donald Trump</td>
<td>555 11 789</td>
<td>555 11 790</td>
</tr>
<tr>
<td>555 11 791</td>
<td>555 11 792</td>
</tr>
</table>

Resultado:

- 105 -
Formularios
Los formularios permiten recibir información de parte del usuario. Su utilización permite
construir formularios de entrada de datos que podrían recibir información para almacenar en
una base de datos dentro del servidor, para luego por ejemplo, generar una página o una
cookie de manera dinámica.

Existen dos métodos de envío de información mediante formularios: post y get.

El método get envía información al servidor como parte de la URL. El servidor analiza la URL
pedida por el navegador y separa la información relevante para su posterior procesamiento:
http://www.example.com/busqueda?palabra=xhtml
El signo ? es el delimitador que permite separar la consulta de la URL, con lo cual lo que se
está pasando a la página es una variable llamada palabra con valor xhtml.
En muchos casos sencillos y para enviar cádenas de pocos carácteres este método funciona
bien, sin embargo para otros casos es mejor utilizar otro método de envio. Por ejemplo, si se
quisiera enviar una contraseña, no sería conveniente que la contraseña aparezca en la URL ya
que otras personas podrían ver esta información.
Generalmente en estos caso corresponde utilizar el método de envio post. Este método envía
la información como parte de la petición del navegador al servidor web (esta petición también
incluye la URL, sin embargo la información no formará parte de ella).

El elemento principal y obligatorio de todo formulario es form y sus dos atributos más
importantes son method y action. El primero específica el método de envio (get o bien post), y
en el segundo se ingresa la URL del recurso que contendrá la secuencia de comandos
encargada de hacer algo con esa información.
El atributo runat=”server” permite hacer referencia al formulario y los controles de la página
mediante programación en código del servidor, necesario en la programación Asp.Net

<form id="form1" runat="server">

Elemento input
Este elemento permite construir diferentes tipos de controles. El atributo type define el tipo de
control

Cuadros de texto
Permite recibir texto del usuario. El valor text en el atributo type indica que será un cuadro de
texto.

<form>
<p>Nombre: <input type="text" name="nombre"/></p>
<p>Apellido: <input type="text" name="apellido"/></p>
</form>

A continuación varias configuraciones que se pueden controlar con un cuadro de texto.

<form>
<p>E-mail:
<input type="text" name="mail" readonly="readonly"
value="example@example.com" />
<strong>readonly</strong>=<em>readonly</em> y
<strong>value</strong>=<em>example@example.com</em>.
</p>
<p>Contraseña:
<input type="password" name="password" />
<strong>type</strong>=<em>password</em>

- 106 -
 </p>
<p>Iniciales:
<input type="text name" name="inicial" size="5" maxlength="2" />
<strong>size</strong>=<em>3</em> y
<strong>maxlength</strong>=<em>2</em>
</p>
<p>No foco:
<input type="text" disabled="disabled" value="jo jo" />
<strong>disabled</strong>=<em>disabled</em> y
<strong>value</strong>=<em>jo jo</em>
</p>
</form>

Resultado:

Botones de radio
Estos botones se suelen presentar en grupo y permiten elegir una opción entre varias. Para
esto se específican valores iguales para el atributo name, mientras que para el type se utiliza
el valor radio.

Ejemplo:

<form>
<p>Sobre su edad:
<input type="radio" name="edad" value="mayor" />MAYOR
<input type="radio" name="edad" value="menor" />MENOR
</p>
<p>Su genero:
<input type="radio" name="genero" value="hombre" />HOMBRE
<input type="radio" name="genero" value="mujer" />MUJER
</p>
</form>

Resultado:

- 107 -
Al especificar un valor distinto para name, se crea un nuevo grupo, mientras que dentro de un
mismo grupo sólo podemos elegir una sola de las opciones.

Botón de comprobación checkbox

Permite marcar valores de tipo si/no.

Ejemplo:

<form>
<p>
<input name="fuma" type="checkbox" checked="checked" value="si" />
Fumador
<input name="deporte" type="checkbox" value="si" /> Deportista
</p>
</form>

Uno de los input lleva el atributo checked con el valor checked, de esta forma se indica que
debe aparecer marcado por defecto ni bien se presente el formulario.

Botones de envio y de reset

Cuando se quiere enviar un requerimiento al servidor, podemos utilizar un botón de envío
especificando el valor submit en el atributo type.

Probemos crear un cuadro de búsqueda para Google:

<form method="get" action="http://www.google.com/search">

<p>
<input name="q" type="text" />
<input type="submit" value="Busca en Google" /></p>

- 108 -
</form>

Resultado:

Al presionar el botón irá a la página de google. También se podria concatenar con ? el valor
pasado en el cuadro de texto para activar la busqueda de dicha palabra
Otro botón muy utilizado, es el de tipo reset que se encarga de deshacer todas las
modificaciones que haya hecho el usuario sobre el formulario, es decir regresa todos los
elementos anidados bajo el elemento form a los valores originales especificados en el
documento.

Ejemplo: Probar cambiar el texto dentro del cuadro y luego presionar Reset

<form>
<input type="text" value="Soy el original" />
<input type="reset" />
</form>

Cajas de texto
Las cajas de texto se suelen utilizar para incluir una cantidad de texto mayor y de varias líneas,
para la cual el input de type text no sería apropiado.

Ejemplo:

<form>
<textarea rows="10" cols="50" >Quedo adentro del
cuadro.</textarea>
</form>

Resultado:

- 109 -
Los atributos rows y cols, marcan la cantidad de líneas y el tamaño de ancho respectivamente,
de la caja.

Elemento select
Incluyendo el elemento select se puede armar una lista de selección múltiple, este elemento se
combina con el elemento option para ir agregando las diferentes opciones.

Ejemplo:

<form>
<p>Elija Provincia:
<select name="provincia">
<option>Buenos Aires</option>
<option>Córdoba</option>
<option>Mendoza</option>
<option>Salta</option>
</select>
</p>
</form>

Resultado:

- 110 -
Elemento label
Este elemento nos permite asociar una cadena de texto a un control del formulario. Esto
supone una cuota de semántica ya que se identifica al control con un texto y otra de
accesibilidad debido a que los navegadores permiten utilizar el control mediante el texto
asociado.

Ejemplo de código:

<form>
<p>
<label>
<input type="checkbox" />
Con label</label></p>
<p>
<input type="checkbox" />
Sin label</p>
</form>

Resultado:

En principio parecen identicas, pero prueben hacer clic sobre el texto “Con label”, al hacerlo la
casilla de la izquierda al texto se seleccionara. En cambio al hacer clic sobre “Sin label” no
ocurre nada.
Siempre que sea posible se recomienda utilizar el elemento label

Agrupando con fieldset

El elemento fieldset da la posibilidad de agrupar diferentes secciones bajo un marco que
puede llevar una descripción usando otro elemento llamado legend.

Ejemplo:

<form>
<fieldset>
<legend>Información personal</legend>
<label>
Nombre:
<input type="text" /></label>
<label>
Apellido:
<input type="text" /></label>
<label>
<input type="checkbox" />

- 111 -
 Soltero</label>
</fieldset>
<fieldset>
<legend>Información académica</legend>
<label>
Universidad:
<input type="text" /></label>
<label>
<input type="checkbox" />
Título obtenido</label>
</fieldset>
</form>

Resultado:

- 112 -
2- Estilos en XHTML
Estilos
Los estilos podemos definirlos en un archivo de texto plano independiente de nuestro
documento XHTML o bien incluirlo en el mismo marcado con el elemento style dentro de la
sección head o directamente sobre un elemento, usando también el elemento style.

Archivos de Hojas de Estilos en Cascada (css)

Las hojas de estilo son útiles para definir los atributos visuales en documentos HTML. Esto
permite definir el aspecto visual del documento, mientras que separa la parte semántica
(HTML) de la presentacional (style sheets).
El archivo, usualmente presenta la extensión "css" (por ejemplo, "basic.css") .
Para hacer referencia a un archivo CSS desde el documento HTML o XHTML, se puede usar el
elemento link en el encabezado del mismo (head). Esta declaración le dice al navegador,
dónde se pueden encontrar las declaraciones de estilo de este documento.

<link type="text/css" href="StyleSheet.css" rel="Stylesheet" />

Las propiedades y sus valores son definidos usando una sintaxis de CSS simple.

nombre-propiedad: valor-propiedad;

De este modo se pueden definir muchos pares de valores y propiedades en un mismo bloque,
dado que una definición básica es separada de la próxima por un punto y coma. Un conjunto
de propiedades puede entonces ser aplicado, por ejemplo, a un elemento, lo que establecerá el
aspecto visual de ese elemento dondequiera que aparezca en el documento.

En el siguiente ejemplo un conjunto de propiedades visuales es definido para el elemento

elemento XHTML p. Para lograr esto, el nombre del elemento debe aparecer antes de la
declaración de propiedades, las cuales irán encerradas entre llaves ("{" y "}").

p {
padding: 10px;
border-style: solid;
border-color: blue;
border-width: 2px;
background-color: #9EC7EB;
color: white;
font-family: arial,helvetica;
font-size: 11px;
font-weight: bold;
}

Al declarar este código todos los párrafos tomarán estas propiedades.

- 113 -
Clases en CSS
Una clase en CSS es una forma de agrupar propiedades que luego pueden ser aplicadas a un
elemento específico usando su atributo class. Estos grupos reciben nombres y pueden ser
definidos exclusivamente para un elemento o para cualquiera. Para definir una clase, se debe
escribir el elemento para el cual está declarado, seguido por un punto y el nombre de la clase.
El bloque de propiedades va encerrado entre llaves como en los ejemplos anteriores.

En el siguiente ejemplo se definen tres clases: la primera llamada "importante" para el elemento
"p", la segunda llamada "diminuto" para cualquier elemento y la tercera llamada "grande" para
cualquier elemento también.

p.importante {
color: red;
}
*.diminuto {
font-size: 8px;
}.grande {
font-size: 12px;
}

El uso de un asterisco en lugar del elemento indica que esta clase puede ser aplicada a
cualquier elemento (es lo mismo que no usar nada). También tener en cuenta que la primera
declaración no especifica que la clase debe ser automáticamente aplicada a los elementos "p"
del documento; sólo los elementos "p" con el valor "importante" en su atributo "class" serán
afectados por este estilo. La clase “importante” solo funcionará con elementos “p”.

<p class="importante">Texto importante</p>

<p class="diminuto">Este texto será muy pequeño</p>
<p class="grande">Este, en cambio, será grande</p>

Resultado:

El atributo class también soporta listas de clases separadas por espacios como valor, lo cual
puede ser muy útil para aplicar muchas propiedades de diferentes clases a un solo elementos
de una vez.

<p class="importante grande">Texto importante y grande</p>

- 114 -
Estilos Incluido en la sección Head

Ejemplo

<head runat="server">
<title>Untitled Page</title>
<style type="text/css">
.Nombre
{
color: #FF0000;
text-decoration: underline;
}
.Opciones
{
color: blue;
font-size: 80%;
}
</style>
</head>
<body>
<span class="Nombre">Provincias</span> <span
class="Opciones">Buenos Aires</span> <span
class="Opciones">mendoza</span>
</body>

Resultado:

Estilos en el mismo elemento

Ejemplo:

<body>
<span style="color: #FF0000; text-decoration:
underline;">Provincias</span> <span style=" color: blue; font-size:
80%;">Buenos Aires</span>
</body>

Herencia de Estilos
Tener en cuenta que los elementos contenidos por otros elementos heredan el estilo de sus
padres aunque no haya sido definido para ellos mismos.

<body style="color:red; font-size:12">

<p>Algún texto</p>
</body>

- 115 -
El estilo está definido a nivel del body, pero se aplica al elemento “p” ya que este no tiene
definido su propio estilo.

Resultado:

- 116 -
3- Scripts
Definición
Los scripts son un conjunto de instrucciones generalmente almacenadas en un archivo de texto
que deben ser interpretados línea a línea en tiempo real para su ejecución.
Los scripts pueden estar embebidos en otro lenguaje para aumentar las funcionalidades de
este, como es el caso de código HTML o XHTML.

Javascript
JavaScript es un lenguaje interpretado orientado a las páginas web, con una sintaxis semejante
a la del lenguaje Java o C. Se utiliza en páginas web, para realizar tareas y operaciones en el
marco de la aplicación cliente. No se necesitan licencias para usarlo.
El elemento script coloca un script dentro de un documento. Este elemento puede aparecer
cualquier número de veces en el head o en el body de un documento HTML. Su atributo más
importante es type que especifica el lenguaje de scripts de los contenidos. El lenguaje de
scripts se especifica como un tipo de contenido (p.ej., "text/javascript"). Se debe proporcionar
un valor para este atributo. No hay valor por defecto.

Ejemplo

<html>
<body>
Esto es texto normal de un documento.
<script type=”text/javascript”>
document.write(“Texto generado desde Java Script”);
</script>
</body>
</html>

Resultado

Se puede utilizar el atributo src para especificar la localización de un script externo,

normalmente un archivo .js.

Ejemplo:

- 117 -
<html>
<head>
<script type="text/javascript" src="MiScript.js”></script>
</head>
<body>
</body>
</html>

Instrucciones Javascripts
Java Script es sensible a mayúsculas y minúsculas. Son comandos de instrucción para el
navegador. Lo normal es escribir ; (punto y coma) al final de una instrucción.
Las instrucciones pueden agruparse en bloques. Estos se inician y terminan con llaves ({})
Se pueden incorporar elementos HTML.

Ejemplo:

<script type="text/javascript">
{
document.write("<h1>Este es el encabezado</h1>");
document.write("<p>Este es un párrafo.</p>");
document.write("<p>Este es otro párrafo</p>");
}
</script>

Resultado:

Los comentarios hacen más fácil de entender el código Java Script, son partes del programa
que sirven para explicar y aclarar. Barra doble “//”, es válida solo para comentarios de una sola
línea. Barra y asterisco “/*” y “*/”, donde se considera como comentario todo lo que se
encuentre entre los dos símbolos. Se utiliza para comentar múltiples líneas.

Ejemplo:

<script type="text/javascript">
/* Escritura de cabecera
Para probar un comentario de bloque */
document.write("<h1>Esto es una cabecera</h1>");
// Escribir dos parrafos
document.write("<p>Este es un párrafo.</p>");
document.write("<p>Este es otro párrafo.</p>");

- 118 -
</script>

Variables
Las variables javascript son sensibles a mayúsculas y minúsculas. La variable “MIVAR” no es lo
mismo que la variable “mivar”. En javascript los nombres de las variables deben empezar con
una letra o con un guión bajo “_”.
Hay cuatro tipos de datos que pueden almacenarse en una variable Javascript:
 Números (enteros, decimales, etc).
 Letras y números (cadenas de caracteres).
 Valores lógicos (True y false).
 Objetos (una ventana, un texto, un formulario, etc).

var Num = 2;
var miVar = 12.34;
var miCadena = 'Hola, mundo!';
var miCadena = "Hola, mundo!";
var miVar = True;
Num = Num + 1; // Num es 3

Operadores aritméticos
Se utilizan para calcular valores entre variables o constantes. Sea Y = 5, en la siguiente tabla
se tiene:

Operador Descripción Ejemplo Resultado

+ Suma x=y+2 x=7
- Resta x=y-2 x=3
* Multiplicación x=y*2 x=10
/ División x=y/2 x=2.5
% Modulo (Resto de la división) x=y%2 x=1
++ Incremento x=++y x=6
-- Decremento x=--y x=4

Operadores de Asignación
Este tipo de operador se utiliza para asignar valores a las variables. Sea Y = 5, para la tabla
siguiente se tiene:

Operador Ejemplo Es igual a Result ado

= x=y x=5

+= x+=y x=x+y x=15

-= x-=y x=x-y x=5

- 119 -
 *= x*=y x=x*y x=50

/= x/=y x=x/y x=2

%= x%=y x=x%y x=0

Operadores de Comparación
En javascript se pueden comparar variables de distinto tipo, pues es capaz de forzar
conversiones. Devuelve dos tipos de resultado True (Verdadero) o False (Valso). Sera X = 5,
se tiene la siguiente tabla:

Operador Descripción Ejemplo Devuelve

== Es igual a x==8 FALSE
=== Es exactamente igual a x===5 TRUE
(valor y tipo) x==="5" FALSE
!= No es igual x!=8 TRUE
> Es mayor que x>8 FALSE
< Es menor que x<8 TRUE
>= Es mayor o igual a x>=8 FALSE
<= Es menor o igual a x<=8 TRUE

Operadores Lógicos
Los operadores lógicos devuelven un valor binario. Sea x = 4; y = 6, tenemos la tabla:

Operador Descripción Ejemplo

&& Y (x < 10 && y > 1) es

TRUE
|| O (x==5 || y==5) es
FALSE
¡ No es ¡(x==y) es TRUE

Método Alert()
El método Alert muestra una ventana con un mensaje y un botón de Ok.

Ejemplo:

alert("Mensaje");

Resultado:

- 120 -
Método getElementById
Devuelve una referencia al primer objeto que cumpla con el valor del atributo Id o Name

Ejemplo general:

<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<title>Prueba</title>
<style type="text/css">
.style1
{
width: 100%;
}
</style>
</head>
<body>
<table class="style1">
<tr>
<td>
<input id="Text1" type="text" /></td>
</tr>
<tr>
<td>
<input id="Text2" type="text" /></td>
</tr>
<tr>
<td>
<input id="Button1" type="button" value="Sumar"
onclick="Sumar()" /></td>
</tr>
<tr>
<td>
Total:
<input id="Text3" type="text" /></td>
</tr>
</table>
</body>
<script type='text/javascript' >
function Sumar() {
var dato1 = document.getElementById("Text1").value;
var dato2 = document.getElementById("Text2").value;
if (dato1 == "")
dato1 = "0";

- 121 -
 if (dato2 == "")
dato2 = "0";

if (isNaN(dato1) || isNaN(dato2))
alert("Los valores deben ser numérico");
else {
var Suma = parseFloat(dato1) + parseFloat(dato2);
document.getElementById ("Text3").value = Suma;
}
}
</script>
</html>

- 122 -