Programación NET Unidad 3

Desarrollo de Software
6º semestre
Programación .NET II
Unidad 3. Manipulación de errores y conjuntos de objetos
Clave:
15143530
Universidad Abierta y a Distancia de México

UnADM
México, Ciudad de México, enero del 2023

Índice
Unidad 3. Manipulación de errores y conjuntos de objetos ................................................... 3

Presentación de la unidad ...................................................................................................... 3
Logros…………....................................................................................................................... 4
Competencia específica ......................................................................................................... 4
3.1. Control de errores en C Sharp ........................................................................................ 4
3.1.1. Uso de los comandos para el control de errores: try, catch ........................................ 6
3.1.2. Desarrollo de controles de errores personalizados ...................................................22
3.2. Conjuntos de objetos .....................................................................................................29
3.2.1. Arreglos .......................................................................................................................30
3.2.2. Colecciones ................................................................................................................45
Cierre de la unidad… ............................................................................................................63
Para saber más.....................................................................................................................64
Fuentes de consulta..............................................................................................................65
UNADM | DCEIT | DS | DPRN2 2

Presentación de la unidad
Bienvenido a la tercera unidad de Programación en .Net II.
Ahora aprenderás conceptos fundamentales de la programación orientada a objetos con un

enfoque de utilización del lenguaje C Sharp.
“Buscar errores y manejarlos adecuadamente es un principio fundamental para diseñar software

correctamente”, ((Ferguson, Patterson y Beres, 2005, pág. 359). En teoría cuando se escribe un
código se pretende que todo esté correctamente escrito y funcione. En el mundo real esto
raramente es cierto. Es más, algunos errores no son previstos ni controlados en el momento de
programar; por ejemplo, si la conexión de red se interrumpe los servidores de bases de datos
dejan de funcionar, y los archivos de disco pueden no contar con los contenidos que las
aplicaciones consideran que contienen. Esto también debe ser controlado y tratar de no dejar al
usuario final con una aplicación detenida, sin ninguna información acerca de qué hacer en ciertos
casos (la clásica pantalla azul cuando una aplicación entra en una situación no controlada). Es
importante revisar este tema porque permitirá controlar programas ante situación inesperadas.
En la segunda parte de la unidad, se revisará el tema de tablas, vectores, matrices o array (que
algunos autores traducen por arreglo), que son un conjunto de elementos del mismo tipo,
tendrán el mismo nombre y ocuparán un espacio contiguo en la memoria de la computadora. La
trascendencia de este tema es el aprender a manipular un conjunto de objetos con un mismo
nombre, lo que permite referirse a varios elementos semejantes que contengan información
diferente. Si se planteara esa situación con los conocimientos actuales de .NET, sería necesario
crear una variable con nombre diferente por cada dato que se necesitara.

Se concluirá esta parte trabajando con colecciones, el siguiente paso de los arreglos, donde es
posible guardar con un mismo nombre un conjunto de objetos diferentes (de diferentes tipos), y
no es necesario especificar un tamaño fijo.
Estos dos conceptos: errores y conjunto de objetos, te serán de gran utilidad en el desarrollo de
tu carrera.
Logros
Al término de esta unidad lograrás:

• Entender el concepto de manejo de errores y utilizar la técnica de excepción.
• Programar tus propias excepciones para el manejo de errores muy personales.
• Entender el concepto de arreglos y la forma de construirlos dentro de C Sharp.
• Manejar los métodos que se necesitan para manipular un conjunto de objetos.
• Definir y comprender la utilidad de las colecciones.
Competencia específica
Crea aplicaciones confiables mediante el control de estados no esperados, utilizando el control

de errores de la plataforma .NET y emplea la herramienta colecciones ara la construcción de
grupos de objetos relacionados, mediante estructuras estáticas o dinámicas con base en los
requerimientos propios del sistema a resolver.
3.1. Control de errores en C Sharp

La herramienta de .Net que se utiliza para el control de errores en tiempo de ejecución es el

common language runtime (entorno en tiempo de ejecución de lenguaje común, CLR). Uno de
los principales objetivos del CLR .NET, respecto a los errores en tiempo de ejecución, es evitarlos
(como la gestión automática de la memoria) o al menos capturarlos en tiempo de ejecución
(mediante un sistema fuertemente tipado) (Archer, 2010). Aun así, hay algunos errores que sólo
pueden ser capturados en tiempo de ejecución, para éstos existe un mecanismo llamado
excepciones.
Las excepciones son el procedimiento recomendado en la plataforma .NET, para controlar los
errores que se produzcan durante la ejecución de las aplicaciones (divisiones por cero, lectura de
archivos no disponibles, datos incorrectamente teclados, etcétera). Esto es una diferencia
respecto a su implementación en otros lenguajes, como el caso de C++ tradicional, lo que
proporciona una cierta homogeneidad, consistencia y sencillez, entre los diferentes lenguajes
que la componen.
Tradicionalmente, el sistema que en otros lenguajes y plataformas se ha usado para informar

estos errores consiste, simplemente, en hacer que los métodos devolvieran códigos que
informasen sobre si se han ejecutado correctamente o, en caso contrario, cuál fue el error
(González, s. f.).
Una excepción en el ámbito de la programación (recordemos que las excepciones son un control
de errores utilizados por todos los lenguajes actuales de programación), se define como
“cualquier condición de error o comportamiento inesperado que se ha detectado en un
programa en ejecución”, la podemos encontrar en la base de conocimientos de Microsoft (MSDN,
2013f):
Frente al anterior método de capturar errores en los lenguajes de programación, las excepciones
proporcionan las dos ventajas siguientes:

• Claridad: el uso de códigos especiales para informar del error suele dificultar la legibilidad de
la fuente, en tanto que se mezclan las instrucciones de la lógica de éste con las del
tratamiento de los errores que pudiesen producirse durante la ejecución.
• Más información: a partir del valor de un código de error puede ser difícil deducir sus causas;
conseguirlo muchas veces implica consultar la documentación proporcionada por el
fabricante sobre el método que lo provocó, pero puede que no especifique claramente su
causa. Por el contrario, una excepción es un objeto que cuenta con campos que describen las
causas del error, y a cuyo tipo suele dársele un nombre que resuma claramente su causa, el
cual está indicado por las clases que definen el Framework.
Por estas ventajas, en la actualidad la mayoría de los lenguajes manejan los errores con base en
estas características. A continuación, se abordarán cómo manejar esta tecnología de control de
errores.
3.1.1. Uso de los comandos para el control de errores: try, catch
El manejo de las excepciones se conforma de tres comandos que consisten en las palabras
reservadas: try, catch y finally (Archer, 2010).
La base de conocimiento de Microsoft (MSDN, 2013m) define el uso de los comandos try, catch
y finally de la siguiente manera: “consiste en obtener y utilizar recursos en un bloque try, tratar
circunstancias excepcionales en el bloque catch y liberar los recursos en el bloque finally”, esto
se puede explicar de una manera sencilla en el siguiente diagrama:
Se escribe el código que debe ser controlado con respecto a,

o en relación con, los errores en tiempo de ejecución.
Bloque try {..}
Por ejemplo:
A = B / C;

Bloque catch {…} Se escribe el código que se ejecutará cuando se produzca un

error en el bloque try.
Por ejemplo:
Console.WriteLine (“Error la variable C no puede ser “0”);
Se escribe el código que se ejecutará independientemente de

Bloque finally {…} si se produce un error o no en el bloque catch.
Por ejemplo:
Console.WriteLine (“El código continua ejecutándose”);
Se deben respetar las siguientes reglas en cuanto al uso de comandos para el control de errores:
1. Sólo puede haber un bloque try.
2. Al menos deberá existir un bloque catch por cada bloque try, pero puede haber más de uno
para controlar diferentes errores.
3. El bloque finally es opcional, se puede o no incluir según las necesidades del objeto. Por
ejemplo: cuando se manejan bases de datos es necesario cerrarlas, exista o no un error en los
procesos de operación de la información. El bloque finally en estas situaciones es sumamente
útil.
La forma en que funcionan estos bloques es sencilla y directa. Cuando una instrucción fracasa en
su objetivo y no puede continuar (se detecta una situación excepcional), devuelve un objeto
excepción. Este objeto excepción deberá ser capturado (cachado) por el bloque catch, en donde
se decide qué acción se debe tomar; es decir, el manejo que se debe hacer del error o la forma
en que se abordará.

Es necesario especificar qué tipo de errores (excepciones) se espera que ocurran para ser
capturados.
A continuación, se expone un ejemplo para entenderlo:
En un proyecto de desarrollo de un objeto, es necesario leer un número entero desde el teclado

y guardarlo en una variable de tipo int. Esto se puede realizar con el siguiente código.
Si se ejecuta el programa escribiendo un número 3 cuando la aplicación lo solicite, la salida es el

siguiente número:
Escribe un número entero: 3

El número escrito fue: 3
Se puede argumentar lo siguiente: “este programa se ejecuta correctamente”; Se infiere que es
un programa escrito de forma correcta.
Siguiendo con la situación propuesta, se plantea que el usuario no escriba un número, sino la
palabra hola. El programa se detiene de forma inesperada y envía la siguiente ventana:

Figura 1. Ejemplo de ejecución incorrecta del programa
Ahora se puede argumentar que “el programa se ejecuta de forma incorrecta”. Se infiere que es
un programa escrito de manera incorrecta.
En este caso, completamente fuera del control del desarrollador, el programa no puede forzar al
usuario a que escriba de forma correcta lo que se le solicita. Este tipo de problemas deben ser
analizados con más detalle por el desarrollador, porque, posiblemente, algunas de las capturas
del usuario final sean malintencionadas (el hecho de escribir palabras en lugar de números); pero
en ocasiones puede tratarse de errores de percepción; por ejemplo, en lugar de 30 se escribe 3O
(el número tres y la letra O). Si se ejecuta de esta forma, el error es el mismo; es decir, es un error
de captura aun cuando no haya sido con mala intención.
Es tarea del desarrollador controlar este tipo de errores y así evitar que el programa se detenga
de forma inesperada; para ello deberá proporcionar una serie de opciones con el fin de que el
programa se autocontrole, y si debe terminar lo realice de forma controlada o, como dicen
algunos autores, de forma limpia (Ferguson, Patterson y Beres, 2005).

En el ejemplo se deben colocar estas instrucciones entre bloques try y catch, para que controlen
de forma correcta las acciones de escribir un número en formato inadecuado, y no esperar que
el programa se detenga de manera repentina. Aquí es necesario reparar en un cuestionamiento
importante: ¿qué tipo de error se espera?
Eso puede verse en la siguiente imagen, que corresponde a la parte superior de la figura anterior.
Figura 2. Ejemplo de aviso de ejecución incorrecta del programa
En este caso se espera un error del tipo FormatException, que puede traducirse como Excepción
por un mal formato. Se puede controlar si se reescribe el programa de la siguiente manera:
Si se ejecuta el programa y se escribe la palabra hola, la salida será la siguiente:
Escribe un número entero: hola

Escribiste el dato 'hola' el cual no es un número
Sin aparecer la pantalla de error.
Pero si el programa se ejecutara tecleando el número 3, la salida sería la misma que se observó
anteriormente:
Escribe un número entero: 3

El número escrito fue: 3
Se puede observar que en el programa se han agregado dos bloques al reescribir el código,
después de identificado el error Excepción por un mal formato:
La parte try
En ella se escribe el código que puede producir errores en el momento de la ejecución.
El bloque catch
En este caso se envía al usuario un comentario en el que se indica que se produjo un error.
Al agregar este control se obtiene un programa que permite, al identificar un error, terminar de
forma controlada su ejecución.

Se puede observar en el código que la instrucción:
Esta es la instrucción que detiene el programa para poder observar los resultados (hasta que no
se presione la tecla [enter]). Se debe ejecutar sin importar lo que ocurra, una manera clara que
indicará esto se muestra a continuación:
Puede observarse que el comportamiento es exactamente igual que el programa anterior, pero
se ha controlado el error y codificado su operación de una manera más clara acorde con los
estándares de .NET. El bloque finally es muy utilizado por aplicaciones que deben cerrar de

manera correcta, independientemente de si se ejecutaron o no con errores. Un caso típico es

cuando se cierran bases de datos después de haber operado sobre la información contenida.
En el bloque catch se observa esta instrucción:
Se espera capturar un error del tipo FormatException, que será devuelto en un objeto llamado
fe (puede ser cualquier nombre válido de variable en C Sharp). Una buena práctica de
programación es utilizar las letras mayúsculas que compongan la excepción, según la base de
datos de MSDN (2013g). Este objeto tiene una gran cantidad de métodos que permite conocer
con mucho detalle el error que se produjo, en qué parte del programa apareció, etcétera.
Siempre se debe capturar el objeto que contiene información del error aunque, como en este
caso, no se utiliza por ser un ejemplo muy sencillo; pero con instrucciones como fe.toString(), se
podría contar con una explicación más amplia del error.
Se ejecuta nuevamente el programa, pero en esta ocasión se teclea el número 3.1 y se observa
el siguiente error:
Escribe un número entero: 3.1

Escribiste el dato '3.1' el cual no es un número
Esto no es un error porque 3.1 sí es un número. No es un número entero, pero sí es número. Para
concluir, puede decirse que la claridad y el control de los mensajes de error es entera
responsabilidad del desarrollador. Ahora que se cuenta con elementos para tener una mejor idea
sobre el comportamiento de las excepciones en C Sharp mediante .NET, es conveniente definir
una serie de conceptos importantes para utilizarlos de manera eficiente.
Si se tiene un programa que llama a un objeto y el objeto llama a un método que lanza una
excepción, se inicia un proceso recursivo. Primero se espera que el método que lanzó la
excepción tenga código para su control; si no lo tiene se espera que el objeto procese la

excepción; si este no tiene código para su control, se espera que el programa inicial que llamó al
objeto controle el problema; si éste no tiene código de control, el programa se detiene y muestra
la ventana de error. A esto se le conoce como propagación de la excepción. (Archer, 2010).

Figura 2. Esquema de propagación de excepción

Las excepciones, finalmente, son objetos y tienen toda una jerarquía de herencia. Existe una gran
cantidad para controlar cualquier situación inesperada en la ejecución de un programa.
Algunos de estos objetos se pueden observar en el siguiente diagrama:
Object
Exception
ExcepcionesPropias SystemException IOException
ArithmeticException ArgumentException FileNotFoundException
DivideByZeroException ArgumentNullException
Figura 3.Diagrama de excepciones.
Basado en Diagrama basado en la jerarquía indicada en MSDN (2013i)
Esta jerarquía muestra, de manera muy simplificada, la complejidad de los objetos que se pueden
recuperar en la instrucción catch.
Se considera importante realizar la siguiente aclaración sobre el diagrama:

Indica que son excepciones creadas por quien realiza el objeto,
ExcepcionesPropias
y pueden ser desarrolladas a partir de cualquier punto de la
jerarquía. Sólo por ejemplificar se hereda de Exception. En el
siguiente punto se tratará este tema con más profundidad.
Por otra parte, es recomendable que todas las instrucciones del tipo IO (input/output) sobre los
medios de recursos de hardware (disco duro, memorias USB, impresoras, etcétera.), deben ser
utilizadas entre los bloques try y catch (Michaellis, 2010).

A continuación, se propone un ejemplo de este proceso, donde se desarrollará un programa que

escriba en un archivo de texto en el disco C, en un directorio llamado puntonet un archivo de
nombre información.txt, este archivo tendrá como contenido la palabra “HOLA”. El código se
muestra a continuación.
Si se ejecuta el programa, es posible darse cuenta de que en el directorio (debe crearse como un
primer paso) existe un archivo llamado temp.txt y contiene la palabra hola. Se puede ejecutar
sin los bloques try y catch, pero la recomendación de los autores es utilizar esta sintaxis porque
otorga una mayor seguridad en la funcionalidad.
Si se borra del disco duro el directorio puntonet y se ejecuta el programa. Se observará el

siguiente error:

System.IO.DirectoryNotFoundException: No se puede encontrar una

parte de la ruta
de acceso 'c:\puntonet\temp.txt'.
en System.IO.__Error.WinIOError(Int32 errorCode, String
maybeFullPath)
en System.IO.FileStream.Init(String path, FileMode mode,
FileAccess access, I
nt32 rights, Boolean useRights, FileShare share, Int32
bufferSize, FileOptions o
ptions, SECURITY_ATTRIBUTES secAttrs, String msgPath, Boolean
bFromProxy, Boolea
n useLongPath, Boolean checkHost)
en System.IO.FileStream..ctor(String path, FileMode mode,
FileAccess access)
en EscribirArchivo.Program.Main(String[] args) en
c:\WorkSpaceVisualStudio\Un
iversidad UnNAD\EscribirArchivo\EscribirArchivo\Program.cs:línea
12
Se observa que se ha producido una excepción en particular:
DirectoryNotFoundException (error: el directorio no fue

encontrado).
En conclusión, el resultado previsto es un error muy general: IOExcepcion (excepción en general

de entrada y salida), pero debería ser más específico: DirectoryNotFoundException (excepción
al no encontrase el directorio). Esto se logra al modificar el programa de la siguiente manera.

El mensaje que ahora aparece es: Error: Debes crear primero el directorio. También se observará
en el código que se cuenta con dos salidas para el error. La primera es para uno muy específico,
la no existencia del directorio donde se creará el archivo; mientras que el segundo es muy
general, para cualquiera producido en el momento de ingresar al disco duro.
Este orden es muy importante. Cuando una instrucción try tiene varios catch, deben ser
ordenados desde los errores muy específicos hasta los más generales. Supóngase que se cambia
el orden de las instrucciones catch de la forma en que se indica en el siguiente código:

Se observa un error indicado por el compilador, que señalará que una cláusula catch previa ya
detecta todas las excepciones de este tipo o de tipo superior. Según lo indica Ferguson,
Patterson y Beres (2005, pág.363), “Los catch deben ser ordenados de la captura del error más
específico al error más general”.
Regresando al código de la representación anterior, y ejecutar de nuevo el programa para que se

cree el archivo de texto. Se quitará el permiso de escritura sobre ese archivo. Esto no es un tema
de programación, pero el proceso es muy sencillo, y permite ejemplificar la captura de otros
errores en C Sharp.
Si se realizan los siguientes pasos:
1. Entrar a la ventana de comandos de MS-DOS y escribir:
C:\windows\system32\attrib c:\puntonet\temp.txt +r
2. Al regresar al programa y ejecutarlo se observará que aparece una ventana con el siguiente
error:

Figura 3. Error de acceso de ruta
Se observa que se cuenta con una nueva excepción que no se ha controlado, y salta a las dos
instrucciones catch.
Esta nueva excepción es de un tipo nuevo, pertenece a las excepciones de control de seguridad
impuestas por el sistema operativo, para asegurar que no se dañarán archivos en el sistema. Son
parte de las credenciales (así se llaman los permisos) que proporciona la clave del usuario, por
medio del cual se ingresa al sistema Windows. Su control se muestra en el siguiente código:

El compilador ayuda a colocar la excepción en el punto adecuado; marca error si se pone en otro
lugar.
Para terminar con este subtema, es de resaltarla importancia de controlar el flujo sin errores de
un programa, lo que permitirá que la aplicación se mantenga estable cuando los usuarios, de
manera intencional o no, introduzcan datos erróneos. No olvides ejecutar, desde la ventana de
MS-DOS, el siguiente comando para permitir que se escriba sobre el archivo:
C:\windows\system32\attrib c:\puntonet\temp.txt -r
3.1.2. Desarrollo de controles de errores personalizados

Como se observó en el subtema anterior, el control de situaciones no esperadas (errores) es de

suma importancia en el desarrollo de software confiable, pues permitirá confiar a la ejecución
de un programa no sólo el manejo seguro de la información, sino incluso tareas consideradas
críticas, como el manejo de equipos médicos o los vehículos de la actualidad.
En C Sharp ese control de errores, o control de excepciones, se basa en los comandos try, catch
y finally. Igualmente, como se comentó en el tema anterior, existen dos categorías de
excepciones bajo la clase Exception, en C Sharp: las predefinidas del entorno de ejecución
(common language runtime, CLR) que derivan de System.Exception, y las definidas por el usuario
en la aplicación. Existen decenas de excepciones que pueden ser controladas desde C Sharp y
predefinidas por el CLR; algunas de ellas se muestran a continuación:
Excepción Descripción
ArithmeticException Desbordamiento por una operación aritmética.
DivideByZeroException Error por una división entre cero.
FileNotFoundException El archivo no fue encontrado.
FormatException El formato del dato es incorrecto.
IndexOutOfRangeException El índice es mayor que el tamaño de la matriz o colección
utilizada.
IOException Errores de entrada y salida de información.
NullReferenceException Un dato miembro sin inicializar.
OverflowException El dato no puede guardar el valor que se le indica.
OutOfMemoryException Se terminó la memoria.
Tabla 1. Tabla. Listado de algunas excepciones en C Sharp. Nota: la lista completa se puede consultar en la base de
conocimientos de MSDN (2013 h).
En esta breve lista se puede observar el grado de control sobre los errores posibles al programar
en C Sharp. Aun así, en ocasiones puede requerirse la creación de excepciones propias por dos
razones:

1. Se trata de un error nuevo y, por lo tanto, no considerado en las excepciones estándares que
proporciona la plataforma .Net.
2. Se desea controlar situaciones posibles en la aplicación, con base en el estándar de
excepciones propuesto por .Net.
La primera situación es un tanto difícil de que ocurra, pues la biblioteca proporcionada por el
lenguaje es muy completa. La segunda es muy recurrente en la industria de desarrollo de
software, porque se refiere al control de situaciones específicas del negocio donde se utilizará el
programa; por ejemplo: si la aplicación se ejecutará en una escuela donde la calificación mínima
aprobatoria es de 7.0, esa es una regla del negocio de esa escuela en particular.
Si se desea que los usuarios distingan, mediante programación, ciertas condiciones de error de
otras, es posible crear sus propias excepciones definidas por ellos mismos; .NET Framework
proporciona una jerarquía de clases de excepción que, en última instancia, deriva de la clase base
Exception. Cuando se creen es recomendable finalizar el nombre de la clase definida por el
usuario con la palabra "Excepción" (MSDN, 2013e).
En MSDN (2013e) se recomienda que, si se define una nueva excepción, se debe implementar
tres constructores; tal como se muestra en el ejemplo:

Como puede observarse, se hereda de ApplicationException. Se puede heredar de Exception,

pero Microsoft menciona que la manera correcta es de ApplicationException, porque Exception
se produce por la interacción con el Framework .Net; pero ApplicationException se produce por
la interacción con un usuario. “Esta excepción supone un medio para establecer diferencias entre
excepciones definidas por aplicaciones y excepciones definidas por el sistema” (MSDN, 2013a).
Se debe llamar a estos tres constructores porque están definidos en la clase padre:
ApplicationException. Al sobreescribirlos, se agrega una nueva excepción a la biblioteca
proporcionada por C Sharp.
En resumen, las sugerencias que propone Microsoft (Michaellis, 2010) para el desarrollo de
excepciones propias son las siguientes:
1. Finaliza el nombre de tu clase personalizada excepción con el sufijo Exception, por

ejemplo: ErrorEnEdadException, SueldoNoEncontradoException, etcétera.
2. Si la frase está compuesta de varias palabras, inicia cada una de ellas con letra mayúscula,
como se ve en los ejemplos anteriores.

3. La excepción debe ser serializable (proceso de codificación donde un objeto se convierte

en un conjunto de bytes, y se puede almacenar en un medio como el disco duro o la
memoria USB). Si se hereda de Exception o de ApplicationException ya no es necesario
hacer ese proceso.
4. Se recomienda implementar tres constructores básicos: el primero sin parámetros, el
segundo con un mensaje como parámetro, y el tercero con posibilidad de pasar una
excepción interna anidada.
Se exponen los conceptos mencionados mediante el siguiente ejemplo:
En una empresa se desarrolla un programa donde uno de los datos a capturar es la edad del
trabajador, que debe estar entre los 18 y los 65 años (valores válidos autorizados por el IMSS
para desempeñarse en un puesto administrativo). Se requiere desarrollar una excepción que sea
lanzada cuando se capture un valor de edad que pase de este rango, en los dos sentidos, para
valores de edad menores de 18 años y mayores de 65. Se iniciará llamándola
EdadFueraDeRangoException. La excepción que resolvería este problema se muestra a
continuación.

La primera clase, EdadFueraDeRangoException, se hereda de AplicationException. Como se

indicó en las recomendaciones de Microsoft, se implementaron los tres constructores indicados
(polimorfismo en los constructores, visto en la unidad 2).
La segunda clase, program, en su programa principal main, captura la excepción

EdadFueraDeRango. La parte try llama un método leerEdad, éste captura la excepción del
sistema FormatException.

En el bloque finally se hace una revisión de la edad, si está fuera del rango indicado por el IMSS,
se lanza una excepción; el comando throw es el propuesto por C Sharp para lanzarlas. Es posible
lanzar una excepción con cualquiera de los tres constructores. Esto permite personalizar el error
generado por esta aplicación.
Ahora se requiere integrar la siguiente modificación: el IMSS permite que una persona trabaje si
tiene más de 18 años y menos de 65. Pero por las características de la empresa, en un puesto la
edad permitida debe ser entre 25 y 40 años. Es posible utilizar esta misma excepción si se
modifica el lanzamiento con el siguiente código.
La excepción se ha vuelto muy general, lo que permite que una misma sirva para capturar
diferentes situaciones.

Para concluir este tema, debe hacerse énfasis en que, aunque el sistema de excepciones de C#
es una herramienta muy eficiente que permite, hasta cierto punto, controlar imprevistos, nada
puede sustituir a una programación cuidadosa. El propio Stroustrup (1997), científico de la
computación y catedrático en la Universidad A&M de Texas, quien desarrolló el lenguaje C++,
advierte que “Aunque las excepciones se pueden usar para sistematizar el manejo de errores,
cuando se adopta este esquema, debe prestarse atención para que cuando se lance una
excepción no cause más problemas de los que pretende resolver. Es decir, se debe atender la
seguridad de las excepciones. Curiosamente, las consideraciones sobre seguridad del mecanismo
de excepciones conducen frecuentemente a un código más simple y manejable”, (Stroustrup,
1997, pág. 345.
Con las excepciones, además de tener un mejor control sobre los errores, también se tendrá un
código más simple.
3.2. Conjuntos de objetos
El almacenamiento de grupos de elementos de datos relacionados es un requisito básico de casi

todas las aplicaciones de software; este grupo de elementos, también llamados conjunto de
objetos, se pueden guardar en la memoria de la computadora mediante dos formas: arreglos y
colecciones.
Es importante este almacenamiento porque un gran porcentaje de las aplicaciones desarrolladas

a nivel mundial están dedicadas al proceso de la información, y los conjuntos de objetos que
guardan información son importantes.
Un conjunto de objetos es un grupo de objetos de software, similares en características, pero

diferentes en su contenido. Ejemplo: un objeto alumno sería una entidad de software que guarda

el nombre, su número de control. Un conjunto de objetos alumnos sería una lista de ellos en la
que se representan el número de control y nombre.
En este tema se trabajará con ambos conceptos con base en la propuesta de C Sharp para el
manejo de la información en conjuntos de datos, como se indicó en el Tema 3.1. Control de
errores en C Sharp. Es necesario asegurarse de que el código, al ejecutarse, capture todos los
errores. Esto es sumamente importante en relación con un conjunto de objetos.
3.2.1. Arreglos
Los arreglos son conjuntos de objetos que tienen un mismo tipo, nombre, y son controlados por
un índice que los identifica (Deitel y Deitel, 2007). Pueden tener cualquier longitud y almacenar
miles o millones de datos; la condición es que el tamaño se debe decidir al momento de crear el
arreglo.
Imagina los arreglos como un grupo de cajas que son exactamente iguales, donde se guardarán
datos. Para poder identificarlas, tendrán un número que inicia en cero y termina en “n”. A ese
número se le llamará índice porque permite identificar cada caja. Como todos los elementos
tienen el mismo nombre sólo se identifican con un número. Pueden almacenar tipos de
referencia y de valor. El primero describe el lugar donde está el dato guardado, pero no lo
almacena. De almacenar el dato se encarga el segundo tipo, el de valor (MSDN, 2013ñ).
Esto se puede comprender mejor mediante un ejemplo. Visualiza la memoria de tu computadora

como un conjunto de celdas contiguas. Si cuentas con 2GB de memoria RAM, tendrás 2 147 483
648 celdas numeradas, desde la cero hasta la 2 147 483 647. A cada celda le cabe un byte (un
número entre cero y 255). Si se añade que en la celda 2 345 450 guardas un número 100,
almacenar una referencia significaría guardar el número 2 345 450 que es la posición de una

celda, guardar su valor significaría guardar el número 100 que tiene esa celda. Es decir, se tienen
que realizar dos pasos para descubrir la cantidad que se guarda en ese lugar:
1. Ir al número de celda.
2. Ver qué número guarda esa celda.
Guardar un valor significa que se está sólo almacenado un dato, sin importar en dónde se
almacena en la memoria.
Los arreglos se clasifican de la siguiente manera:
a) Unidimensionales
Conjunto de elementos que sólo tiene un índice. Algunos autores los llaman vectores. Se pueden
definir de dos maneras: la primera se conforma de la siguiente sintaxis (MSDN, 2013n):
Tipo [ ] Nombre;
Nombre = new Tipo [numero_de_elementos];
La segunda la indica C Sharp, la cual permite hacer en sólo un paso las dos instrucciones
anteriores:
Tipo [ ] Nombre = new Tipo[numero_de_elementos]
Un ejemplo de definición de un arreglo de esta manera se muestra a continuación:
Que según lo anterior es lo mismo a

Se define un arreglo con una sola instrucción. Este arreglo es de cinco elementos, todos ellos
llamados dato, diferenciados por un índice: dato[0], dato[1], dato[2], dato[3], dato[4]. Los
arreglos en C Sharp inician en 0.
La segunda forma de definir un arreglo unidimensional es la siguiente:
Tipo [ ] dato = new Tipo [ ] { datos . . . } ;
O también:
Tipo [ ] dato = { datos . . . } ;
En este caso, el número de datos indican el tamaño del arreglo. A continuación se expone un
ejemplo de cómo se define esto:
Que sería similar a:
En ambos casos se define un arreglo de cinco elementos llamados dato, que contienen los
números: 2, 3, 6, 8, y 2. Esto se puede representar de la siguiente manera: dato[0]=2, dato[1]=3,
dato[2]=6, dato[3]=8 y dato[4]=2.

En el primer caso sólo se define el arreglo, pero todos ellos inicializados con un cero. En el
segundo, también se define un arreglo, pero inicializado con los valores que están encerrados
entre llaves. Nuestros arreglos tendrán un valor iniciar, ambos casos son válidos en C Sharp.
b) Multidimensionales
Un arreglo multidimensional con dos dimensiones se define como un conjunto de elementos en

el que, para hacer referencia a uno de ellos, se debe indicar su fila y la columna donde está
situado (Nash, 2010). Estas características, tener una fila y una columna, se llaman matrices (en
matemáticas, una matriz es un conjunto de números ordenados en una tabla, y para identificarlos
se necesita hacer referencia a su fila y columna).
Conceptualmente, un arreglo multidimensional con dos dimensiones se asemeja a una

cuadrícula, también llamada matriz.
El siguiente ejemplo muestra una matriz de tres filas y tres columnas.
Figura 4. Ejemplo de matriz de 3 filas y 2 columnas
Un arreglo multidimensional con tres dimensiones se asemeja a un cubo. Las dimensiones

pueden continuar, aunque no se representen de una manera conceptual (no existen ejemplos en

nuestro mundo real en donde podamos comparar más de tres dimensiones). No existe un límite
para el número de dimensiones que pueden ser representadas en arreglos, pero sí es
conveniente considerar que el incremento de consumo de memoria es exponencial. Observa la
siguiente tabla; en todas las dimensiones se suponen 10 elementos:
Dimensiones Producto Elementos
1 10 10
2 10X10 100
3 10X10X10 1 000
4 10X10X10x10 10 000
5 10X10X10X10x10 100 000
Tabla 2. Dimensiones
Como se puede observar, el número de dimensiones aumenta de forma exponencial los registros
que se necesitan en memoria, (recuerda que, finalmente, todo dato se representa por un espacio
en la memoria RAM). Si aumentamos las dimensiones, aumentamos el consumo de este espacio.
Respecto a la forma de representación, un arreglo de dos dimensiones se puede declarar
mediante el siguiente formato en C Sharp:
Tipo [ , ] dato;
dato = new Tipo [filas, columnas]
O bien:
Tipo [ , ] dato = new Tipo [filas, columnas]
Donde filas y columnas son el número de elementos que se quieren declarar en el arreglo. Un
ejemplo sería éste:

Equivalente a:
Si se requiere definir una matriz de tres filas por cuatro columnas, los elementos se representan
de esta manera:
dato[0,0], dato[0,1], dato[0,2], dato[0,3]

El mismo dato también puede declararse de la siguiente manera:
Tipo [ , ] dato = { Datos }
Un ejemplo de esto es lo siguiente:
La forma de definir un dato es sólo cuestión de estilos del programador. Para el compilador de C
Sharp el proceso es indistinto.
Si se define un arreglo de tres filas por cuatro columnas con estos elementos: dato[0,0]=2 y
dato[1,2]=0, es posible definir arreglos de cualquier número de dimensiones. Recuerda que el
límite es el rápido agotamiento de la memoria.

Existe el concepto de matriz escalonada, que es una variación del arreglo multidimensional, una
matriz de matrices. Es una matriz unidimensional, y cada elemento en sí mismo es una matriz.
No es necesario que todas sean del mismo tamaño (MSDN, 2013j).
A continuación, se expone un ejemplo:
Se define un arreglo de tres elementos, pero el primero de ellos tiene cinco; el segundo, ocho; y
el tercero, tres. A esto se le conoce como una matriz escalonada, y son llamadas así por su
similitud con el mismo concepto en matemáticas.
Se propone un ejemplo más para entender mejor estos conceptos: en una investigación de corte
ambiental se requiere tomar la presión barométrica, la temperatura máxima y la temperatura
mínima de cinco ciudades de la república mexicana en un día determinado.
Numero Ciudad
1 México, D. F.
2 Puebla, Pue.
3 Xalapa, Ver.
4 Tepic, Nay.
5 Mérida, Yuc.
Tabla 2. Grupo de ciudades
Se desarrollará un programa que solicite los datos al usuario y después los muestre en forma de
una tabla que tenga el siguiente formato:

Índice Ciudad Presión Temp. Temp.

máx. mín.
Tabla3. Formato
Y así sucesivamente. El código se muestra a continuación:


Si se ejecuta la aplicación se obtendrá la siguiente salida:
Para la ciudad: México, D. F.

Cuál es su presión barométrica: 585
Cuál es su temperatura máxima: 26
Cuál es su temperatura mínima: 19
Para la ciudad: Puebla, Pue.

Para la ciudad: Xalapa, Ver.


Para la ciudad: Tepic, Nay.

Para la ciudad: Mérida, Yuc.

Núm. Ciudad Presión Temp. Temp.
sucesivo máx. mín.
1 México D.F. 585 26 19
2 Puebla. Pue. 593 27 15
3 Xalapa, Ver. 862 28 12
4 Tepic. Nay. 746 32 20
5 Mérida, Yuc. 1016 28 18
Tabla 4. Captura
Sin embargo, de manera general, no existe ninguna limitante para crear arreglos de cualquier
tipo, en este caso doubles y string. Los arreglos representan una información a la que se accede
a través de uno o más índices, dependiendo del número de dimensiones.
¿Qué pasa si se define un arreglo de tres elementos y se desea acceder al número cinco? En el
siguiente ejemplo se creará un objeto llamado alumno, el cual tendrá como datos miembro el
nombre y edad del alumno, de tipo string e int, respectivamente. Se realizará un constructor que
recibirá los dos datos y sólo se le integrarán dos propiedades get para recuperar ambos datos.

Al definir la clase alumno con los requerimientos dados en la propuesta, se observará el siguiente
código:
Se crea el programa que lea los datos de tres alumnos y que nos permita consultar uno de ellos
al solicitar el número del alumno. La primera línea debe tener la siguiente instrucción e indicar
que se utilizarán métodos de la clase System para leer datos:

Si se ejecuta la aplicación, se da de alta a tres alumnos y se solicitan los datos del índice dos y
uno, se obtendrá la siguiente salida:
Dame el nombre del alumno 0: MANUEL

Dame la edad del alumno 0: 20

Dame el nombre del alumno 1: JUAN

Dame el nombre del alumno 2: PEDRO
1.- Mostrar datos de un alumno
2.- Terminar
Tu opción: 1
Escribe el índice del alumno: 2
El alumno número: 2
El nombre es: PEDRO
La edad es: 25

2.- Terminar
Tu opción: 1
Escribe el índice del alumno: 1
El alumno número: 1
El nombre es: JUAN
La edad es: 35

2.- Terminar
Tu opción: 2
Si con los mismos datos se solicita el índice cuatro, es posible observar el siguiente error:

Figura 5. Excepción no controlada por un arreglo fuera de rango
Como se revisó en el Tema 3.1. Control de errores en C Sharp, es necesario que se controlen los
errores generados al manejar arreglos. Existen varias excepciones asociadas con el manejo de
esta información, una de ellas es IndexOutOfRangeException, generada por solicitar un número
de índice mayor que los elementos definidos en la inicialización del arreglo, caso presentado en
la imagen anterior.
Para finalizar este tema, se revisará el concepto de objeto que tienen los arreglos en C Sharp.
Como lo indica la base de conocimientos de Microsoft (MSDN, 2013ñ), en C# los arreglos son
realmente objetos. Cuando se define un arreglo de cualquier número de dimensiones se está
definiendo un objeto que, además de tener datos, tendrá métodos que permitirán manejar la
información.
El siguiente ejemplo muestra algunas funciones propias que aparecen al definir un arreglo:

Como se observa, el arreglo a tiene propiedades como Length, y métodos como Average() o
Sum(); existen muchos otros métodos y propiedades que puedes consultar en la base de
conocimientos MSDN de Microsoft. Con el simple hecho de definir un arreglo, se está definiendo
un objeto, y podrá disponer de métodos que permitirán manipular los datos.
Para concluir, se recuerda la definición de arreglo, según Ferguson (2005): conjunto finito de
datos, todos ellos del mismo tipo, con un mismo nombre e identificados por un índice.
3.2.2. Colecciones
Según el tema anterior, un arreglo es un conjunto finito de datos, todos ellos del mismo tipo, con
un mismo nombre e identificados por un índice (Ferguson, Patterson y Beres, 2005). Un conjunto
finito de datos implica un problema. Imagina que te solicitan hacer un programa en el que
almacenarás, en un arreglo, diferentes tipos de productos producidos por una empresa. Cuando
se te pide hacer el programa, la empresa produce cinco tipos diferentes; te dicen que el
incremento de nuevos tipos es un proceso muy lento por la gran cantidad de trámites que se
deben hacer, que aumentan a razón de uno o dos como máximo cada año. Una solución que
propones es crear un arreglo de 20 elementos; con lo cual das una vida promedio a tu programa
de 10 años, según los datos estadísticos dados por los requisitos de la empresa. Imagina que, por
alguna razón no identificada, durante la toma de los requerimientos, ellos registran 20 productos

en sólo dos años. Inmediatamente tu programa tendrá problemas porque no podrá controlar 25
productos, pues está diseñado en un arreglo de sólo 20.
El problema anterior se presenta porque los arreglos son finitos; es decir, en el momento que
son definidos y antes de usarlos, se debe decidir el número de datos que se tendrán, el cual no
puede cambiar durante toda la vida del arreglo.
Una colección es una forma sencilla, pero no finita, de expresar un arreglo. Esto no significa que
sea infinito, sino que no se tiene por qué definir al inicio de su uso cuántos elementos se tendrán;
es decir, se puede agregar elemento tras elemento según se requiera; por supuesto existe un
límite establecido según la memoria de la computadora, el disco duro, el microprocesador,
etcétera. El término colección es traducido por muchos autores como contenedor. Es una
herramienta proporcionada por .NET Framework, compuesta por clases especializadas para
almacenamiento y recuperación de datos (Liberty, 2001).
Las colecciones son un conjunto de clases que permiten almacenar y recuperar datos siguiendo
conceptos de estructuras de datos, tales como listas, pilas, colas, árboles, diccionarios, etcétera.
Al seleccionar una de ellas, es posible guardar información dentro de la estructura, sin
preocuparse de la forma en cómo se realiza esto y cuándo se recupera, porque no es necesario
conocer los detalles de esta operación. Como lo indican Deitel y Deitel (2007), .NET Framework
proporciona una serie de componentes reutilizables llamados colecciones, que están
normalizadas para que las aplicaciones se puedan compartir con facilidad, sin tener que
preocuparse por los detalles de su implementación. Están escritas para una amplia reutilización,
diseñadas para su ejecución rápida y uso eficiente de la memoria.
Existen varias clases (o colecciones) definidas por el Framework de .NET, algunas de las más
importantes son listas y diccionarios, que se explicarán con detalle a continuación porque son el
fundamento del resto de las colecciones. La primera guarda datos en forma de objetos, la
segunda en forma de pares de valores compuestos por llave-valor. El resto funciona bajo alguno

de estos dos principios, y sólo cambian algunas características; por ejemplo, si están ordenadas
o no, si se recuperan en el mismo orden en que se inserta la información, etcétera.
List
Es equivalente al concepto de una lista doblemente ligada. En esta clase o colección se utilizará
una lista y el tipo de elementos que ésta puede guardar. Automáticamente, el Framework de
.NET proporcionará una serie de propiedades y métodos que permitirán manipular los datos (los
que tú ingreses en la lista), tales como la longitud, buscar o borrar un elemento, ordenarlo,
encontrar el máximo, el mínimo, etcétera. El siguiente código es un ejemplo de su uso.
Todos los programas deberán llevar al inicio la siguiente instrucción:
Esto indica al compilador que se utilizarán las colecciones. El código se muestra a continuación:

Diccionario

Es una colección de elementos conformados por un par, que tiene la siguiente estructura: Llave
→ Valor.
La información no es recuperada por un índice, sino por un valor llave, tal como sucede en el
siguiente ejemplo: se desarrollará un diccionario conformado por el par, número de control (un
valor entero) y nombre (una cadena). Se da de alta la siguiente tabla:
Llave Valor
345 Juan
245 Miguel
123 Ángel
667 Pedro
Tabla 5. Ejemplo de información de un diccionario
Si se guarda esta información en un diccionario y se desea recuperar algún dato, no es posible

preguntar qué información existe en el registro dos, porque no se maneja de esa manera. La
pregunta debe plantearse de esta forma: si tengo la llave 123, ¿a qué valor le corresponde?
Existe una serie de reglas para el manejo de los diccionarios en C Sharp.
Las llaves no pueden repetirse, pero no es trascendente si se repiten los valores. La referencia
sólo se hace por la llave. Por ejemplo, en la tabla anterior puede ser posible tener otro alumno
de nombre Ángel, pero debe tener otra llave para identificarlo. No es posible tener dos llaves
iguales que identifiquen a dos personas diferentes, sería similar a pensar que existen dos
personas con la misma CURP; por eso la CURP es una clave única de identificación de las personas,
en otras palabras es nuestra llave.
A continuación se plantearán algunos ejemplos del uso de colección diccionario:


Existen otros contenedores en C Sharp para el manejo de la información. A continuación, se

mencionan algunos de los más usados.
Queue (cola)
“Representa una colección de objetos de tipo primero en entrar, primero en salir” (MSDN,
2013b).

Son útiles para guardar información en el orden en que fueron recibidas, simulan una cola de
personas ante una caja y son atendidas en el orden que llegaron. Los objetos almacenados en
Queue se insertan en un extremo y se quitan del otro.
Se utiliza el método Enqueue para poner en la cola un dato, Dequeue para quitarlo, Peek para
localizar el siguiente elemento, entre muchos otros.
A continuación se expone un ejemplo de uso:
Si se ejecuta el programa, la salida será:
Lista de datos guardados

0 Archivo.Txt
1 Archivo.Pdf
2 Archivo.Doc

3 Archivo.Ppt
Stack (pila)
Representa una colección LIFO (último en entrar, primero en salir) de tamaño variable, de
instancias del mismo tipo (MSDN, 2013d).
Las pilas son útiles para almacenar información y procesar la última que llegó. Los objetos
almacenados en un Stack se insertan en un extremo y se quitan en el otro. Proporciona una serie
de métodos para el manejo de la información con base en la filosofía de la pila. Los métodos más
importantes son Count, que indica cuántos elementos se tiene en un contenedor; push, que
guarda un elemento al inicio de la pila; pop, que recupera el primer elemento al inicio de la pila.
Existe también el método toArray, que convierte el contenido en un arreglo.
Se expone a continuación un ejemplo de uso de pilas:

Si se ejecuta este programa, la salida será:

Lista de datos guardados
0 Archivo.Ptt 2 Archivo.Pdf
1 Archivo.Doc 3 Archivo.Txt
Se observa que las primeras en mostrarse fueron las últimas en ser impresas.
SortedList (lista ordenada)
Representa una colección de pares clave/valor que se ordenan conforme a la clave (MSDN,
2013c).
La clase genérica SortedList es un árbol de búsqueda binaria, que mantiene la información

constantemente ordenada con base, precisamente, en el concepto de árbol binario. Este
contenedor ya provee mecanismos para mantenerse constantemente balanceado, y en el
caso de eliminar elementos (que internamente se representan como nodos de un árbol),
también el balanceo será de manera automática.
SortedList requiere la implementación de un comparador para ordenar y realizar

comparaciones (MSDN, 2013 c).
Un comparador es una clase que le indicará a la colección cómo se deben ordenar los
objetos. Hasta este momento no se ha tenido necesidad de indicar cómo se deben ordenar
los objetos dentro de una colección, porque los datos utilizados se ordenan de manera

natural, numérica o alfabética. Pero en el caso de que se cuente con una colección con los
datos de un alumno tales como nombre, edad, sexo, semestre y carrera, es necesario crear
una clase especial que le indique a la colección por cuál de los cinco campos debe ser
ordenado, o también si se necesita una combinación de ellos (es posible que por necesidad
deba ordenarse según sexo y edad). Por ejemplo, las listas de alumnos se ordenan por
apellido paterno, apellido materno y nombre. Se usan tres campos, a esa clase se le llama
comparador.
Un ejemplo de lo dicho es el siguiente: se requiere hacer una colección que guarde los datos
de los autos en un lote a la venta. Se conoce la placa, marca, modelo, color, año y un precio
estimado de venta. Se necesita listarlos por placa, modelo o precio; ésta última
característica en dos opciones: de menor a mayor, o de mayor a menor. Para lo anterior se
necesitará el uso de un SortList.
La clase Auto tendría el siguiente código:


Se necesitan definir cuatro comparadores para tener las cuatro diferentes formas de
ordenamiento solicitadas: 1) por placa; 2) por modelo o precio, pero éste en dos opciones:
3) de menor a mayor, y 4) de mayor a menor: tal como se muestra a continuación.
Comparador por placa:
Comparador por modelo:
Comparador por precio descendente:

Comparador por precio ascendente:
Si en el lote de autos se cuenta con los siguientes modelos:

Placa Marca Modelo Color Año Precio
YCS3932 Nissan Centra Lujo Perla 2000 $95,000.00
YTR1010 Ford Focus Básico Rojo 2001 $80,000.00
YFG2100 Volkswagen Golf Estándar Azul acero 2000 $65,000.00
YUH2010 Toyota Corola Típico Blanco 2005 $90,000.00
YAT1101 Honda Civic Sedan Gris plata 2010 $98,000.00
Tabla 6. Existencias
El programa principal mostrará el lote ordenado por placa, modelo, precio ascendente y
descendente. Esto se observa en el siguiente código, en el que se utiliza un List para generar
los resultados.


En el momento de la ejecución del programa, se muestra la siguiente salida:
YCS3932 Nissan
Centra Lujo Perla 2000 95000
YTR1010 Ford
Focus Básico Rojo 2001 80000
YFG2100 Volkswagen

Golf Estándar Azul Acero 2000 65000

YUH2010 Toyota
Corola Típico Blanco 2005 90000
YAT1101 Honda
Civic Sedan Gris Plata 2010 98000
YAT1101 Honda
YCS3932 Nissan
YFG2100 Volkswagen
YTR1010 Ford
YUH2010 Toyota
YCS3932 Nissan
YAT1101 Honda
YUH2010 Toyota
YTR1010 Ford
YFG2100 Volkswagen
YFG2100 Volkswagen

YTR1010 Ford
YUH2010 Toyota
YCS3932 Nissan
YAT1101 Honda
YAT1101 Honda
YCS3932 Nissan
YUH2010 Toyota
YTR1010 Ford
YFG2100 Volkswagen
¿Cómo funciona el comparador que utiliza SortedList?
Su lógica de funcionamiento requiere indicaciones de cómo se ordenan dos de los valores

que ingresarán al SortedList, y el método Sort lo aplicará a todo el conjunto de elementos
dentro de la colección. Se plantea un ejemplo: en la clase del lote de autos ahora se desea
desarrollar un comparador para ordenar por modelo.
Con base en el modelo de dos autos, se nombrará auto1 y auto2, se comparará el modelo
del auto1 con el del auto2 (comparación alfanumérica donde A es menor que B, y así

sucesivamente, ANGEL es menor que MANUEL por las iniciales). Si son iguales, se regresa
un 0; si el modelo del auto1 es mayor que el del auto2, regresará un número positivo que
indica que no se deben intercambiar de posición; si es lo contrario, el auto1 resulta menor
que el auto2, se regresa un número negativo que indica que se deben intercambiar. Es
importante notar que se debe devolver un valor positivo o negativo, no importa el número
en sí. Esto se codifica de la siguiente manera:
Es muy fácil obtener el valor positivo con base en una resta, cuando se trata de comparar
valores numéricos. En las cadenas se utiliza el método compareTo, de las que devuelve un
-1, +1 o cero. De esta manera se comparan cadenas.
Se concluye este tema con una recapitulación acerca de la utilidad de las colecciones, que
permiten contener una gran cantidad de datos sin necesidad de definir su número desde
el inicio. La información se guarda sin preocuparse por los límites de almacenamiento y los
métodos de manejo de información, porque ya se encuentran implementados; es posible
tener acceso a ellos de forma directa con sólo invocarlos.
Cierre de la unidad
Con esta unidad concluye tu asignatura Programación .NET II. Los temas que se abordaron
redondean tus conocimientos de programación orientados a objetos y te muestran la
importancia de los conocimientos previos, tales como la estructura de datos.

El tema de control de errores nos permite crear aplicaciones estables, donde se controlen
situaciones especiales que pueden provocar que alguna aplicación interrumpa su ejecución
en forma inesperada.
El tema de conjunto de objetos te permite visualizar la forma en que una aplicación puede
manejar mayores volúmenes de información.
Con estos dos temas has redondeado tus conocimientos de C Sharp, es momento de una
reflexión de todos lo visto. Es recomendable que investigues más sobre objetos,
constructores, polimorfismo, sobrecarga, herencia y sobreescritura. Revisa su interacción
con el control de errores.
Para saber más
En esta sección encontrarás algunos recursos que es recomendable consultes, pues

encontrarás más información acerca de los principales conceptos revisados en la unidad,
tales como control de errores, colecciones y arreglos:
• Como refuerzo al aprendizaje sobre excepciones, se recomienda estudiar el

siguiente artículo: Microsoft. (2022). Excepciones y control de excepciones.
Recuperado de https://docs.microsoft.com/es-
es/dotnet/csharp/fundamentals/exceptions/
• Se recomienda el siguiente artículo que recopila todas las colecciones de objetos del
lenguaje C#: Microsoft. (2022). Colecciones y estructuras de datos. Recuperado de
https://docs.microsoft.com/es-es/dotnet/standard/collections/

Referencia muy completa de las colecciones que proporciona C Sharp:

• Referencia de las excepciones que proporciona C Sharp: Microsoft. (2013). Jerarquía
de excepciones. Recuperado de http://msdn.microsoft.com/es-
es/library/z4c5tckx%28v=VS.80%29.aspx
Referencia muy completa de los usos de try-catch que nos proporciona C Sharp:
• MSDN. (2022). Try-catch-finally (Referencia de C#). Recuperado de
https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/try-
catch-finally
El libro de José Antonio González Seco, El lenguaje de programación C#, es un desarrollo

libre. Aunque es una versión muy anterior, los conceptos fundamentales no han
cambiado. Se encuentra disponible en la sección Material de apoyo y también lo puedes
obtener de:
http://di002.edv.uniovi.es/~cueva/investigacion/lineas/lenguajes/lenguajeCsharp.pdf
• Consulta el manual completo de C Sharp (MSDN, 2013) disponible en la siguiente

dirección: http://msdn.microsoft.com/es-es/library/zkxk2fwf%28v=vs.90%29.aspx
• En este sitio web, también puedes encontrar tutoriales muy completos de C SHARP,
consulta la siguiente dirección: https://www.w3schools.com/cs/
Fuentes de consulta
• Archer, T. (2010). A fondo C#, 2010. Madrid: McGraw-Hill.

• Deitel, M. y Deitel, P. (2007). Cómo programar en C Sharp, 2a. ed. Madrid:

Pearson.
• Ferguson, J., Patterson, B. y Beres, J. (2005). La biblia de C#. Madrid: Anaya.
• Gibbs, W. (1994). Software’s Chronic Crisis. Recuperado de:

https://www.jstor.org/stable/24942840
• González, J. (s. f.). Lenguaje de programación en C#. Recuperado de:

http://dis.um.es/~bmoros/privado/bibliografia/LibroCsharp.pdf
• Liberty, J. (2001). Programming C#. Estados Unidos: O’reilly.
• Michaellis, M. (2010). Essential C# 4.0. Estados Unidos: Addison Wesley.
• Microsoft Corporation. (1999-2007). C# Language Specification Version 3.0.

Recuperado de: https://n9.cl/csharp
• Microsoft. (2022). Excepciones y control de excepciones. Recuperado de

https://docs.microsoft.com/es-es/dotnet/csharp/fundamentals/exceptions/
• Microsoft. (2022). Colecciones y estructuras de datos. Recuperado de

https://docs.microsoft.com/es-es/dotnet/standard/collections/
• MSDN. (2013a). ApplicationException (Clase). Recuperado de:

https://docs.microsoft.com/en-
us/dotnet/api/system.applicationexception?view=netframework-4.8
• (2013b). Clase genérica Queue. Recuperado de http://msdn.microsoft.com/es-

es/library/7977ey2c%28v=vs.80%29.aspx

• (2013c). Clase genérica SortedList. Recuperado de

http://msdn.microsoft.com/es-es/library/ms132319%28v=vs.80%29.aspx
• (2013d). Clase genérica Stack. Recuperado de http://msdn.microsoft.com/es-

es/library/3278tedw%28v=vs.80%29.aspx
• (2013e). Cómo: Crear excepciones definidas por el usuario. Recuperado de:

https://docs.microsoft.com/es-es/dotnet/standard/exceptions/how-to-create-
user-defined-exceptions
• (2013f). Controlar y generar excepciones. Recuperado de

http://msdn.microsoft.com/es-es/library/5b2yeyab.aspx
• (2013g). Excepciones. Recuperado de: http://msdn.microsoft.com/es-

es/library/vstudio/dd489406(v=vs.100).aspx
• (2013h). Exception (Clase). Recuperado de http://msdn.microsoft.com/es-

es/library/system.exception.aspx
• (2013i). Jerarquía de excepciones. Recuperado de

https://learn.microsoft.com/es-es/dotnet/csharp/language-reference/language-
specification/exceptions
• (2013j). Matrices y colecciones (Visual C# Express). Recuperado de:

http://msdn.microsoft.com/es-es/library/9ct4ey7x%28v=vs.90%29.aspx
• (2013k). Manual del lenguaje C#. Recuperado de http://msdn.microsoft.com/es-

es/library/zkxk2fwf%28v=vs.90%29.aspx

• (2013l). System.Collections.Generic (Espacio de nombres). Recuperado de

http://msdn.microsoft.com/es-es/library/System.Collections.Generic.aspx
• (2013m). Try-catch (Referencia de C#). Recuperado de

http://msdn.microsoft.com/es-es/library/0yd65esw%28v=vs.110%29.aspx
• (2013n). Try-catch-finally (Referencia de C#). Recuperado de

http://msdn.microsoft.com/es-es/library/dszsf989.aspx
• (2013n). Tutorial de matrices. Recuperado de: http://csharp-

facilito.blogspot.com/2013/07/matrices-en-c-sharp.html
• Nash, T. (2010), Accelerated C# 2010, Estados Unidos de América: Apress.
• Sharp, J. (2010). Microsoft Visual C# 2010. Estados Unidos de América:

Microsoft Press.
• Stroustrup, B. (1997). The C++ Programming Language, 3a. ed. Estados Unidos:
Addison-Wesley.
• Troelsen A. (2010). Pro C# 2010 and the .NET 4 Platform. Estados Unidos de
América: Apress.

Programación NET Unidad 3

Cargado por

Copyright:

Formatos disponibles

Programación NET Unidad 3

Cargado por

Información del documento

Descripción original:

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Programación NET Unidad 3

Cargado por

Copyright:

Formatos disponibles

Desarrollo de Software

Unidad 3. Manipulación de errores y conjuntos de objetos

Universidad Abierta y a Distancia de México

México, Ciudad de México, enero del 2023

Unidad 3. Manipulación de errores y conjuntos de objetos ................................................... 3

UNADM | DCEIT | DS | DPRN2 2

Unidad 3. Manipulación de errores y conjuntos de objetos

Bienvenido a la tercera unidad de Programación en .Net II.

Ahora aprenderás conceptos fundamentales de la programación orientada a objetos con un

“Buscar errores y manejarlos adecuadamente es un principio fundamental para diseñar software

UNADM | DCEIT | DS | DPRN2 3

Al término de esta unidad lograrás:

Crea aplicaciones confiables mediante el control de estados no esperados, utilizando el control

3.1. Control de errores en C Sharp

UNADM | DCEIT | DS | DPRN2 4

La herramienta de .Net que se utiliza para el control de errores en tiempo de ejecución es el

Tradicionalmente, el sistema que en otros lenguajes y plataformas se ha usado para informar

UNADM | DCEIT | DS | DPRN2 5

Se escribe el código que debe ser controlado con respecto a,

UNADM | DCEIT | DS | DPRN2 6

Bloque catch {…} Se escribe el código que se ejecutará cuando se produzca un

Console.WriteLine (“Error la variable C no puede ser “0”);

Se escribe el código que se ejecutará independientemente de

Console.WriteLine (“El código continua ejecutándose”);

1. Sólo puede haber un bloque try.

UNADM | DCEIT | DS | DPRN2 7

A continuación, se expone un ejemplo para entenderlo:

En un proyecto de desarrollo de un objeto, es necesario leer un número entero desde el teclado

Si se ejecuta el programa escribiendo un número 3 cuando la aplicación lo solicite, la salida es el

Escribe un número entero: 3

UNADM | DCEIT | DS | DPRN2 8

Figura 1. Ejemplo de ejecución incorrecta del programa

UNADM | DCEIT | DS | DPRN2 9

Figura 2. Ejemplo de aviso de ejecución incorrecta del programa

Si se ejecuta el programa y se escribe la palabra hola, la salida será la siguiente:

Escribe un número entero: hola

UNADM | DCEIT | DS | DPRN2 10

Escribiste el dato 'hola' el cual no es un número

Sin aparecer la pantalla de error.

Escribe un número entero: 3

En ella se escribe el código que puede producir errores en el momento de la ejecución.

UNADM | DCEIT | DS | DPRN2 11

Se puede observar en el código que la instrucción:

UNADM | DCEIT | DS | DPRN2 12

manera correcta, independientemente de si se ejecutaron o no con errores. Un caso típico es

En el bloque catch se observa esta instrucción:

Escribe un número entero: 3.1

UNADM | DCEIT | DS | DPRN2 13

UNADM | DCEIT | DS | DPRN2 14

Figura 2. Esquema de propagación de excepción

UNADM | DCEIT | DS | DPRN2 15

Algunos de estos objetos se pueden observar en el siguiente diagrama:

ExcepcionesPropias SystemException IOException

ArithmeticException ArgumentException FileNotFoundException

Se considera importante realizar la siguiente aclaración sobre el diagrama:

UNADM | DCEIT | DS | DPRN2 16

A continuación, se propone un ejemplo de este proceso, donde se desarrollará un programa que

Si se borra del disco duro el directorio puntonet y se ejecuta el programa. Se observará el

UNADM | DCEIT | DS | DPRN2 17