Unidad 3 Manipulacion de errores y conjuntos de objetos

Vista previa del material en texto

Programación .NET II 
Unidad 3. Manipulación de errores y conjuntos de objetos 
 1 División de Ciencias Exactas, Ingeniería y Tecnología | Ingeniería en Desarrollo de Software 
 
 
 
 
Ingeniería en Desarrollo de Software 
 
8º Cuatrimestre 
 
 
 
Programa de la asignatura: 
Programación .NET II 
 
 
 
Unidad 3. Manipulación de errores y conjuntos de objetos 
 
 
 
Clave: 
150930934 
 
 
 
Universidad Abierta y a Distancia de México 
UnADM 
 
 
 
Programación .NET II 
Unidad 3. Manipulación de errores y conjuntos de objetos 
 2 División de Ciencias Exactas, Ingeniería y Tecnología | Ingeniería en Desarrollo de Software 
 
Índice 
 
Unidad 3. Manipulación de errores y conjuntos de objetos ................................................ 3 
Presentación de la unidad ................................................................................................. 3 
Propósitos .......................................................................................................................... 4 
Competencia específica ..................................................................................................... 4 
3.1. Control de errores en CSharp ..................................................................................... 4 
3.1.1. Uso de los comandos para el control de errores: “try”, “catch” ................................. 5 
3.1.2. Desarrollo de controles de errores personalizados ................................................ 20 
Actividad 1. La crisis del software .................................................................................... 25 
Actividad 2. Manejo seguro de un objeto ......................................................................... 26 
3.2. Conjunto de objetos .................................................................................................. 27 
3.2.1. Arreglos ................................................................................................................. 28 
Actividad 3. Conjuntos de objetos mediante arreglos en C Sharp .................................... 40 
3.2.2. Colecciones ........................................................................................................... 41 
Actividad 4. Conjuntos de objetos mediante colecciones en C Sharp .............................. 59 
Autoevaluación ................................................................................................................ 60 
Evidencia de aprendizaje. Control de errores en grupo de objetos en C Sharp................ 60 
Para saber más ............................................................................................................... 62 
Fuentes de consulta ........................................................................................................ 62 
 
 
 
Programación .NET II 
Unidad 3. Manipulación de errores y conjuntos de objetos 
 3 División de Ciencias Exactas, Ingeniería y Tecnología | Ingeniería en Desarrollo de Software 
Unidad 3. Manipulación de errores y conjuntos de objetos 
 
Presentación de la unidad 
 
Bienvenido a la nueva unidad de programación en .Net.II. 
 
En esta Unidad III Manipulación de errores y conjuntos de objetos en el lenguaje de 
programación CSharp aprenderás conceptos fundamentales de la programación orientada 
a objetos con un enfoque de utilización del lenguaje CSharp. 
 
“Buscar errores y manejarlos adecuadamente es un principio fundamental para diseñar 
software correctamente”, (Ferguson, 2005), 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 (como por ejemplo una 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, todos los 
cuales son del mismo tipo. Estos elementos tendrán todos ellos 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 el poder 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 que es el siguiente paso de los arreglos 
donde es posible guardar con un mismo nombre un conjunto de objetos diferentes (de 
diferentes tipos) y además en donde 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, preparándote con esta última unidad a la finalización del curso de 
programación de .NET II y alistándote para el siguiente curso de programación.NET III 
 
 
 
 
Programación .NET II 
Unidad 3. Manipulación de errores y conjuntos de objetos 
 4 División de Ciencias Exactas, Ingeniería y Tecnología | Ingeniería en Desarrollo de Software 
Propósitos 
 
Al finalizar el estudio de esta unidad podrás: 
 Entender el concepto de manejo de errores utilizando 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 CSharp. 
 Manejar los métodos que se necesitan para manipular un conjunto de objetos. 
 Definir y comprender la utilidad de las colecciones. 
 
 
Competencia específica 
 
Crear aplicaciones estables controlando los estados no esperados utilizando el control de 
errores de la plataforma .NET y su manipulación en grupos de objetos empleando la 
herramienta de colecciones. 
 
 
3.1. Control de errores en CSharp 
 
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, 
por sus siglas en inglés Common Language Runtime CLR), uno de los principales 
objetivos del Common Language Runtime .NET respecto a los errores en tiempo de 
ejecución, se aplica bien para evitarlos (como la gestión automática de la memoria) o al 
menos capturarlos en tiempo de ejecución (como por ejemplo mediante un sistema 
fuertemente tipado) (Archer,2010). Aun así algunos errores que sólo pueden ser 
capturados en tiempo de ejecución, para estos errores de tiempo de ejecución 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 componen la plataforma .NET. 
 
Tradicionalmente, el sistema que en otros lenguajes y plataformas se ha venido usando 
para informar estos errores consistían simplemente en hacer que los métodos en cuya 
ejecución pudiesen producirse devolvieran códigos que informasen sobre si se han 
 
Programación.NET II 
Unidad 3. Manipulación de errores y conjuntos de objetos 
 5 División de Ciencias Exactas, Ingeniería y Tecnología | Ingeniería en Desarrollo de Software 
ejecutado correctamente o, en caso contrario, sobre cuál fue el error producido, 
(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, 2013 f): 
 
Las excepciones proporcionan principalmente las dos siguientes ventajas novedosas 
frente al anterior método de capturar errores en los lenguajes de programación. 
 
 Claridad: El uso de códigos especiales para informar de error suele dificultar la 
legibilidad de la fuente en tanto que se mezclan las instrucciones propias de la lógica 
del mismo con las instrucciones propias del tratamiento de los errores que pudiesen 
producirse durante su ejecución. 
 
 Más información: A partir del valor de un código de error puede ser difícil deducir las 
causas del mismo y conseguirlo, muchas veces implica el tener que consultar la 
documentación proporcionada por el fabricante sobre el método que lo provocó y que 
puede incluso 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 nombre está 
indicado por las clases que definen el framework. 
 
Por estas ventajas, en la actualidad la mayoría de los lenguajes manejan sus errores 
siguiendo esta característica. A continuación se abordarán los temas acerca de 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, 2013 m) 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: 
 
 
 
Programación .NET II 
Unidad 3. Manipulación de errores y conjuntos de objetos 
 6 División de Ciencias Exactas, Ingeniería y Tecnología | Ingeniería en Desarrollo de Software 
Bloque try { 
 
 
 
 
 
 
} 
 
 
Bloque catch { 
 
 
 
 
 
 
 
 
} 
 
Bloque finally { 
 
 
 
 
 
 
 
} 
 
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 
En este bloque se escribe el código que debe ser controlado 
respecto a o en relación a los errores en tiempo de ejecución. 
Por ejemplo: 
A = B / C; 
En este bloque 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”); 
En esta parte se escribe el código que se ejecutará indistintamente se 
produzca un error o no en el bloque catch. 
 
Por ejemplo: 
 
Console.WriteLine(“El código continua ejecutándose”); 
 
Programación .NET II 
Unidad 3. Manipulación de errores y conjuntos de objetos 
 7 División de Ciencias Exactas, Ingeniería y Tecnología | Ingeniería en Desarrollo de Software 
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 –esto significa que 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á el error. 
 
Es necesario especificar qué tipo de errores (excepciones), se espera que ocurran para 
ser capturados. 
 
A continuación se expone un ejemplo simple para entender esto. 
 
Se plantea la siguiente situación: 
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 de una manera sencilla 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 
 
Programación .NET II 
Unidad 3. Manipulación de errores y conjuntos de objetos 
 8 División de Ciencias Exactas, Ingeniería y Tecnología | Ingeniería en Desarrollo de Software 
Se puede argumentar lo siguiente “este programa se ejecuta correctamente”, infiriendo 
por lo tanto que es un programa correctamente escrito. 
 
Siguiendo con la situación propuesta se plantea que el usuario no escriba un número sino 
la palabra “Hola”. A continuación se expone lo que ocurre con el programa. 
El programa se detiene de forma inesperada enviando la siguiente ventana: 
 
 
Ejemplo de ejecución incorrecta del programa (Elaboración del autor: Manuel Panzi 
Utrera). 
 
Ahora se puede argumentar lo siguiente: “el programa se ejecuta de forma incorrecta”, 
infiriendo por lo tanto que es un programa incorrectamente escrito. 
 
Realmente en este caso no se refiere a un programa escrito de forma correcta o 
incorrecta es un programa que debe ser lo suficientemente desarrollado como para poder 
controlar situaciones inesperadas (y en este caso completamente fuera del control del 
desarrollador, un programa no puede forzar a un usuario del programa 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 por ejemplo: el hecho de escribir palabras en lugar de números, 
pero en ocasiones pueden tratarse de errores de percepción por ejemplo en lugar de 
escribir 30 escribimos 3O (3 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 labor importante del desarrollador controlar este tipo de errores evitando que el 
programa se detenga de forma inesperada sino por el contrario deberá proporcionar una 
 
Programación .NET II 
Unidad 3. Manipulación de errores y conjuntos de objetos 
 9 División de Ciencias Exactas, Ingeniería y Tecnología | Ingeniería en Desarrollo de Software 
serie de opciones para que el programa se autocontrole y si debe terminar esto lo realice 
de forma controlada o como dicen algunos autores, de forma limpia (Ferguson, 2005) 
 
En el caso ejemplo se deben colocar estas instrucciones entre bloques try y catch para 
que controlen de forma adecuada las acciones de escribir un número en formato 
inadecuado y no esperar que el programa se detenga inesperadamente. Aquí es 
necesario enfatizar o reparar en un cuestionamiento importante: ¿Qué tipo de error se 
espera? 
 
Eso se puede ver en la parte superior de la pantalla que se muestra en la figura anterior. 
 
 
 
En este caso se espera un error del tipo FormatException, que se puede traducir como 
“Exception por un mal formato”, este se puede controlar, si se re-escribe elprograma 
de la siguiente manera: 
 
 
 
Programación .NET II 
Unidad 3. Manipulación de errores y conjuntos de objetos 
 10 División de Ciencias Exactas, Ingeniería y Tecnología | Ingeniería en Desarrollo de Software 
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' 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 siguiente, 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 2 bloques al re-escribir el código 
después de identificado el error “Exception 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” 
 
 
 
Donde en este caso se envía al usuario un comentario indicando 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: 
 
 
 
Programación .NET II 
Unidad 3. Manipulación de errores y conjuntos de objetos 
 11 División de Ciencias Exactas, Ingeniería y Tecnología | Ingeniería en Desarrollo de Software 
Recordando la Unidad 1, esta es la instrucción que detiene el programa para poder 
observar los resultados del mismo (detiene la ejecución del programa mientras no se 
presione la tecla [enter], para continuar), se debe ejecutar sin importar lo que ocurra, una 
manera clara que indicará esto, se muestra en el siguiente programa. 
 
 
 
Si se ejecuta esta aplicación se puede observar que el comportamiento es exactamente 
igual que el programa anterior pero se ha controlado el error y codificado su operación de 
una manera clara y más acorde con los estándares de .NET 
 
El bloque “finally” es muy utilizado por aplicaciones que deben cerrar aplicaciones de 
manera correcta independientemente de si se ejecutaron con errores o sin ellos. Un caso 
típico es cuando se cierran bases de datos después de haber operado sobre su 
información contenida. 
 
 
 
 
Programación .NET II 
Unidad 3. Manipulación de errores y conjuntos de objetos 
 12 División de Ciencias Exactas, Ingeniería y Tecnología | Ingeniería en Desarrollo de Software 
Regresando al bloque catch, se observa la instrucción: 
 
 
 
Se espera capturar un error del tipo FormatException, en realidad este error será 
devuelto en un objeto que se ha llamado fe (el nombre puede ser cualquier nombre válido 
de variable en C Sharp, tema revisado en la asignatura Programación.NET I) una buena 
práctica de programación es utilizar las letras mayúsculas que compongan la excepción, 
base de datos de MSDN (2013 g). 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. 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' no es un número 
 
Pero si se observa, esto no es un error porque 3.1 sí es un número, no es un número 
entero pero sí es número. Se finaliza esta parte concluyendo que la claridad de los 
mensajes de error y el control de los mismos es entera responsabilidad del 
desarrollador. 
 
Ahora que se cuenta con elementos para tener una mejor y mayor idea del 
comportamiento de las excepciones en Csharp mediante .NET, es conveniente definir una 
serie de conceptos importantes para poderlas utilizar eficientemente. 
 
Si se tiene un programa que llama a un objeto y el objeto llama a un método y éste lanza 
una excepción, se inicia un proceso recursivo esperando primero 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 este no tiene código de control el 
programa se detiene mostrando la ventana de error. A esto se le conoce como 
propagación de la excepción. (Archer, 2010). 
 
 
Programación .NET II 
Unidad 3. Manipulación de errores y conjuntos de objetos 
 13 División de Ciencias Exactas, Ingeniería y Tecnología | Ingeniería en Desarrollo de Software 
Esquema de propagación de excepción (Elaboración del autor: Manuel Panzi Utrera) 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
No 
Si 
Inicio de un proceso 
recursivo 
Programa que 
llama a un objeto 
El objeto llama a 
un método 
El método lanza una 
excepción 
Se controla 
el error El método cuenta 
con código de 
control 
Continúa 
ejecución 
El objeto cuenta 
con código de 
control 
Se controla 
el error 
Continúa 
ejecución 
Si 
Si 
El programa 
cuenta con código 
de control No 
Se controla 
el error 
Continúa 
ejecución 
El programa se 
detiene 
inesperadamente 
Fin 
No 
 
Programación .NET II 
Unidad 3. Manipulación de errores y conjuntos de objetos 
 14 División de Ciencias Exactas, Ingeniería y Tecnología | Ingeniería en Desarrollo de Software 
Las excepciones finalmente son objetos y tienen toda una jerarquía de herencia, existen 
una gran cantidad de ellas para controlar cualquier situación inesperada en la ejecución 
de un programa. 
 
Algunos de estos objetos se pueden observar en el siguiente diagrama: 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Diagrama realizado a partir de la jerarquía indicada en: (MSDN, 2013 i) 
 
Esta jerarquía no se muestra de forma completa sólo muestra de una forma muy 
simplificada la complejidad de los objetos que se pueden recuperar en la instrucción 
“catch”, 
 
A continuación se señala una indicación importante: 
 
 
 
 
Indica que son excepciones creadas por quien realiza el 
objeto y pueden ser desarrolladas a partir de cualquier 
punto de la jerarquía. Sólo por ejemplificar se está 
heredando 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.), 
deben ser utilizadas entre los bloques “try” y “catch” (Michaellis, 2010). 
Object 
Exception 
ExcepcionesPropias SystemException IOException 
ArithmeticException ArgumentException 
DivideByZeroException ArgumentNullException 
FileNotFoundException 
ExcepcionesPropias 
 
Programación .NET II 
Unidad 3. Manipulación de errores y conjuntos de objetos 
 15 División de Ciencias Exactas, Ingeniería y Tecnología | Ingeniería en Desarrollo de Software 
A continuación se expone un ejemplo sencillo para ejemplificar este proceso: se 
desarrollará un programa que escriba en un archivo de texto en el disco “C:”, en el 
directorio “puntonet” llamado información.txt, la palabra “HOLA”. Esto se muestra a 
continuación. 
 
 
 
 
Si se ejecuta el programa es posible darse cuenta de que en el directorio (“se debe crear 
como un primer paso), existe un archivo llamado temp.txt y contiene la palabra “HOLA”. 
Este programa se puede ejecutar sin los bloques “try” y “catch”, pero siguiendo la 
recomendación de los autores es conveniente utilizar esta sintaxis que 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 dela 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 
 
Programación .NET II 
Unidad 3. Manipulación de errores y conjuntos de objetos 
 16 División de Ciencias Exactas, Ingeniería y Tecnología | Ingeniería en Desarrollo de Software 
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, se puede traducir como “Error: el directorio no fue 
encontrado.” 
 
Esto lleva a la conclusión que se espera capturar un error muy general (IOExcepcion = 
Excepción en general de entrada y salida), y se debe ser más específico 
(DirectoryNotFoundException = Excepción al no encontrase el directorio). Al modificar el 
programa de la siguiente manera. 
 
 
 
Programación .NET II 
Unidad 3. Manipulación de errores y conjuntos de objetos 
 17 División de Ciencias Exactas, Ingeniería y Tecnología | Ingeniería en Desarrollo de Software 
Al ejecutar programa se podrá observar que ahora el error que 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 un error muy específico de la no existencia del 
directorio donde se creará el archivo y el segundo muy general para cualquier tipo de 
error producido en el momento en el que se está ingresando al disco duro. 
 
Este orden es muy importante. Cuando una instrucción try tiene varios catch estos deben 
ser ordenados desde errores muy específicos hacia errores más generales. Si se cambia 
el orden de las instrucciones catch de la forma en como se indica en el siguiente código: 
 
 
 
Se observará un error indicado por el compilador donde señalará que: “una clausula 
catch previa ya detecta todas las excepciones de este tipo o de tipo superior”. 
Según lo indica Ferguson (2005), “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 CSharp. 
 
Si se realizan los siguientes pasos: 
 
 
Programación .NET II 
Unidad 3. Manipulación de errores y conjuntos de objetos 
 18 División de Ciencias Exactas, Ingeniería y Tecnología | Ingeniería en Desarrollo de Software 
1.-Entrar a la ventana de comandos de MS-DOS y escribir la siguiente instrucción: 
 
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: 
 
 
Error de acceso de ruta. (Elaboración del autor: Manuel Panzi Utrera). 
 
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 nuevo tipo, son excepciones de control de seguridad 
impuestas por el sistema operativo para asegurar que no se dañarán archivos en el 
sistema. Estas excepciones de seguridad pertenecen a las credenciales (así se llaman los 
permisos) que proporcionan la clave del usuario por medio del cual se ingresa al sistema 
Windows. Su control se muestra en el siguiente código. 
 
 
Programación .NET II 
Unidad 3. Manipulación de errores y conjuntos de objetos 
 19 División de Ciencias Exactas, Ingeniería y Tecnología | Ingeniería en Desarrollo de Software 
 
 
 
El compilador ayuda a colocar la excepción en el punto adecuado, marcando un error si 
se pone en otro lugar. 
 
Se finaliza este tema sólo resaltando la 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. Finalmente no olvides desde la 
ventana de ms-dos ejecutar el siguiente comando para permitir que se escriba sobre el 
archivo: 
 
C:\windows\system32\attrib c:\puntonet\temp.txt -r 
 
 
 
Programación .NET II 
Unidad 3. Manipulación de errores y conjuntos de objetos 
 20 División de Ciencias Exactas, Ingeniería y Tecnología | Ingeniería en Desarrollo de Software 
3.1.2. Desarrollo de controles de errores personalizados 
 
Como se observó en el tema anterior el control de situaciones no esperadas (errores), es 
de suma importancia en el desarrollo de software confiable pues, permitirá confiar la 
ejecución de un programa no sólo al manejo seguro de la información sino incluso dejarlo 
a cargo de tareas consideradas críticas como se vio en la actividad 1, donde los 
programas controlan equipos médicos o las actuales computadoras que controlan los 
vehículos de la actualidad. 
 
En C Sharp ese control de errores llamado más exactamente control de excepciones, está 
controlado como se observó, por 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 CSharp: 
 
Las predefinidas del entorno de ejecución (Common Language Runtime, CLR) y son 
derivadas de System.Exception, y las definidas por el usuario en la aplicación. 
Existen decenas de excepciones que pueden ser controladas desde CSharp predefinidas 
por el CLR y algunas de ellas se muestran en la siguiente lista: 
 
Excepción Descripción 
ArithmeticException Desbordamiento por una operación aritmética 
DivideByZeroException Error por una división por cero 
FileNotFoundException El archivo no fue encontrado 
FormatException El formato del dato es incorrecto 
IndexOutOfRangeException Se usa un índice mayor que el tamaño de la matriz o 
colección utilizada 
IOException Errores de entrada y salida de información 
NullReferenceException Se utilizó un dato miembro sin inicializar 
OverflowException El dato no puede guardar el valor que se le indica 
OutOfMemoryException Se terminó la memoria 
Listado de algunas excepciones en C Sharp, la lista completa se puede consultar en la 
base de conocimientos de MSDN (2013 h). 
 
En esta breve lista se puede observar el grado control que sobre los errores posibles al 
programar en CSharp. Aun así en ocasiones puede requerirse la creación de excepciones 
propias por dos razones: 
1. Se trata de un error nuevo no considerado en las excepciones estándares que 
proporciona la plataforma .Net 
2. Se desea controlar situaciones posibles en la aplicación siguiendo el estándar de 
excepciones propuesto por .Net. 
 
 
Programación .NET II 
Unidad 3. Manipulación de errores y conjuntos de objetos 
 21 División de Ciencias Exactas, Ingeniería y Tecnología | Ingeniería en Desarrollo de Software 
La primera situación es un tanto difícil de que ocurra, realmente la biblioteca 
proporcionada por el lenguaje es muy completa. La segunda es una situación muy 
recurrente en la industria de desarrollo de software. Controlar situaciones particulares de 
las reglas del negocio donde se va a utilizar el programa que se está desarrollando, es 
decir, las condiciones propias de la funcionalidad de la empresa u organización para quien 
se esté desarrollando el programa, por ejemplo: si una aplicación se ejecutará en una 
escuela donde la calificación mínima aprobatoria es de 70, esa es una regla del negocio 
de esa escuela en particular. 
 
Si se desea que los usuarios puedan distinguir, mediante programación, ciertascondiciones de error de otras, es posible crear sus propias excepciones definidas por el 
usuario. .NET Framework proporciona una jerarquía de clases de excepción que, en 
última instancia, derivan de la clase base Exception. Cuando se creen excepciones 
personalizadas, es recomendable finalizar el nombre de la clase de la excepción definida 
por el usuario con la palabra "Excepción" (MSDN, 2013 e). 
 
Se recomienda también por Microsoft (MSDN, 2013 e) que si se define una nueva 
excepción ésta debe implementar 3 constructores. Como se muestra en el ejemplo: 
 
 
 
Se observa que se hereda de: “ApplicationException”, se puede heredar de “Exception”, 
pero Microsoft recomienda 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, 2013 a). 
 
 
Programación .NET II 
Unidad 3. Manipulación de errores y conjuntos de objetos 
 22 División de Ciencias Exactas, Ingeniería y Tecnología | Ingeniería en Desarrollo de Software 
Se debe llamar a estos tres constructores porque ellos están definidos en la clase padre: 
“ApplicationException”, al sobre-escribirlos se está agregando una nueva excepción a la 
biblioteca proporcionada por CSharp. 
 
Resumiendo 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. 
 
2. Si la frase está compuesta de varias palabras inicia cada una de ellas con letra 
mayúscula, como se ve en los ejemplos de la sugerencia anterior. 
 
3. La excepción debe ser serializable (es un proceso de codificación en donde un objeto 
se convierte a 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, esto es lo más recomendable. 
 
4. Se recomienda implementar tres constructores básicos: el primero sin parámetros, 
el segundo con un mensaje como parámetro y un tercero con posibilidad de pasar una 
excepción interna anidada. 
 
Se exponen los conceptos mencionados mediante el siguiente ejemplo: 
 
En una empresa se está desarrollando un programa donde uno de los datos a capturar es 
la edad del trabajador. Esta edad debe estar comprendida entre los18 y los 65 años que 
son los valores válidos autorizados por el IMSS que puede tener una persona 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. 
 
 
Programación .NET II 
Unidad 3. Manipulación de errores y conjuntos de objetos 
 23 División de Ciencias Exactas, Ingeniería y Tecnología | Ingeniería en Desarrollo de Software 
 
 
La primera clase “EdadFueraDeRangoException”, como se puede observar, se hereda 
de “AplicationException”. También como se indicó en las recomendaciones de Microsoft 
se implementaron los tres constructores indicados (esto como recordarás en la unidad 2 
es un concepto de polimorfismo en los constructores). 
 
 
 
Programación .NET II 
Unidad 3. Manipulación de errores y conjuntos de objetos 
 24 División de Ciencias Exactas, Ingeniería y Tecnología | Ingeniería en Desarrollo de Software 
 
} 
 
La segunda clase “program”, en su programa principal “main”, se captura la excepción 
“EdadFueraDeRango”, se puede ver que en la parte try manda a llamar un método 
“leerEdad”, este método captura la excepción del sistema “FormatException”. 
 
En el bloque finally hacemos una revisión de la edad, si esta está fuera del rango 
indicado por el IMSS lanzamos una excepción, el comando throw, es el comando 
propuesto por CSharp para lanzar excepciones. Es posible lanzar una excepción 
utilizando cualquiera de los tres constructores. Esto permite personalizar el error generado 
por esta aplicación. 
 
 
 
Si se requiere integrar a la aplicación 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 ese puesto la edad permitida debe ser entre 25 y 40 años. Para integrar esta 
 
Programación .NET II 
Unidad 3. Manipulación de errores y conjuntos de objetos 
 25 División de Ciencias Exactas, Ingeniería y Tecnología | Ingeniería en Desarrollo de Software 
modificación, es posible utilizar esta misma excepción modificando el lanzamiento de la 
excepción con el siguiente código. 
 
 
 
Ahora la excepción se ha vuelto muy general, permitiendo que una misma sirva para 
capturar diferentes situaciones. 
 
Se concluye este tema enfatizando que aunque el sistema de excepciones de C# es una 
herramienta muy eficiente que permite hasta cierto punto, controlar imprevistos. A pesar 
de ello, nada puede sustituir a una programación cuidadosa. El propio Stroustrup (1997) 
(Bjarne Stroustrup, es un científico de la computación y catedrático en la Universidad A&M 
de Texas, desarrollo el lenguaje C++), advierte en su libro: The C++ Programming 
Language: "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". 
 
Resumiendo, además de tener un mejor control sobre los errores con las excepciones 
también finalmente se tendrá un código más simple. 
 
 
Actividad 1. La crisis del software 
 
 
El propósito de esta actividad es que analices un tipo de error mediante un caso y lo 
relaciones con los conceptos de errores de formato, errores de captura, situaciones 
inesperadas revisados en este tema. 
 
1. Revisa el planteamiento que te hará llegar tu Facilitador (a). 
 
2. Investiga las causas y consecuencias del tipo de error ocurrido. 
 
3. Redacta en media cuartilla un reporte donde menciones el tipo de error 
ocurrido: de formato, por error de captura o situaciones inesperadas, integrando 
sus características y argumentando por qué consideras que representa el tipo 
 
Programación .NET II 
Unidad 3. Manipulación de errores y conjuntos de objetos 
 26 División de Ciencias Exactas, Ingeniería y Tecnología | Ingeniería en Desarrollo de Software 
de error mencionado. 
 
 
4. Guarda la actividad con el nombre DPRN2_U3_A1_XXYZ. Sustituye las XX por 
las dos primeras letras de tu primer nombre, la Y por tu primer apellido y la Z por 
tu segundo apellido. 
 
5. Coloca tu trabajo en la opción de trabajo Base de Datos. 
 
6. Comenta el reporte como mínimo de uno de tus compañeros, respecto a su 
actividad sobre el tipo de error identificado. Recuerda que tus comentarios no 
deben ser agresivos sino constructivos 
 
*Consulta la rúbrica para elaborar el cuadro comparativo que encontrarás en el archivo 
Criterios de evaluación de las actividades de la Unidad 3 para conocer los parámetros 
de evaluación de esta actividad. 
 
 
 
 
 
Actividad 2. Manejo seguro de un objeto 
 
El propósito de la actividad es que soluciones un problema en donde sea necesario dar 
seguridad a la ejecución de un programa en CSharp utilizando excepciones. 
 
Para el desarrollo de la actividad tu Facilitador (a) te hará llegar unproblema y las 
indicaciones generales, debes asegurarte de que controlas todas las opciones de error 
para lo cual realizarás los siguientes pasos: 
 
1. Construye una clase del tipo que se requiera según el planteamiento del 
problema. 
 
2. Integra los datos miembro. 
 
3. Integra propiedades de lectura y escritura para cada dato miembro. 
 
4. Desarrolla un programa que construya objetos, solicite los datos del usuario y 
utilizando las propiedades del objeto guarde los datos en él. 
 
5. Construye las excepciones necesarias para controlar las reglas del negocio 
indicadas en el planteamiento. 
 
6. Integra a tu programa el control de las reglas del negocio construidas en el paso 
anterior. 
 
Programación .NET II 
Unidad 3. Manipulación de errores y conjuntos de objetos 
 27 División de Ciencias Exactas, Ingeniería y Tecnología | Ingeniería en Desarrollo de Software 
7. Integra un archivo de texto en el cual muestres las capturas de pantalla de cada 
uno de los pasos de este proceso. 
 
8. Una vez realizado tu programa, empaca todo tu proyecto en un archivo .zip 
incluyendo el archivo de texto con las capturas de pantalla del procedimiento 
realizado. 
 
9. Guarda la actividad con el nombre DPRN2_U3_A2_XXYZ. Sustituye las XX por 
las dos primeras letras de tu primer nombre, la Y por tu primer apellido y la Z por 
tu segundo apellido. 
 
10. Envía el archivo a tu Facilitador(a) para recibir retroalimentación mediante la 
herramienta Tarea. 
 
*No olvides, consultar el documento Criterios de evaluación de las actividades de la 
Unidad 3 para conocer los parámetros de esta actividad. 
 
 
 
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 de dos formas 
principales de almacenarlos son mediante arreglos y colecciones. 
 
Es importante este almacenamiento porque un gran porcentaje de nuestras aplicaciones 
desarrolladas a nivel mundial están dedicadas al proceso de la información donde los 
conjuntos de objetos que guardan información son importantes. 
 
¿Cómo podemos definir a un conjunto de objetos?, recordemos que matemáticamente un 
conjunto es un grupo de elementos, un conjunto de objetos por lo tanto es un grupo de 
objetos de software similares en características pero diferentes en su contenido. 
 
Un ejemplo sencillo sería: 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 
donde se representa su número de control y su nombre. 
 
En este tema trabajaremos con ambos conceptos mediante la propuesta de CSharp para 
el manejo de la información en conjuntos de datos, como se indicó en el tema 3.1. Control 
 
Programación .NET II 
Unidad 3. Manipulación de errores y conjuntos de objetos 
 28 División de Ciencias Exactas, Ingeniería y Tecnología | Ingeniería en Desarrollo de Software 
de errores en CSharp, 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. 
 
Continúa con este nuevo tema. 
 
 
3.2.1. Arreglos 
 
Los arreglos son conjuntos de objetos que tienen un mismo tipo y nombre además de que 
son controlados por un índice que los identifica (Deitel & Deitel, 2007). Los arreglos 
pueden tener cualquier longitud, pueden almacenar miles o millones de datos, pero la 
condición es que este tamaño se debe decidir al momento de crear el arreglo. Como se 
comentó en la definición se tiene acceso a cada elemento del arreglo utilizando un índice, 
que es un número entero que indica la posición del dato al que se esté refiriendo. 
 
Imagina los arreglos como una grupo de cajas, cada una de ellas exactamente iguales 
donde se guardarán datos, esas cajas para poderlas identificar tendrán un número que 
inicia en 0 y termina en un número “n”, a ese número se le llamará índice porque permite 
identificar cada caja. De igual manera en un arreglo como todos los elementos se llaman 
iguales solo se identifican con un número. 
Los arreglos pueden almacenar tipos de referencia y tipos de valor. Un tipo de referencia 
describe el lugar donde está el dato guardado pero no almacena propiamente ese dato, 
eso “almacenar el dato”, son los tipos 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 en una computadora con 
2GB de memoria RAM, tendrás 2,147,483,648, celdas numeradas desde la 0 hasta la 
2,147,483,647. A cada celda le cabe un byte (un número entre 0 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. Con lo anterior significa que para guardar una 
referencia se tienen que realizar dos pasos para descubrir la cantidad que se guarda en 
ese lugar. 
 
1.- Primero ir a ese número de celda y 
2.-Después 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: 
 
 
Programación .NET II 
Unidad 3. Manipulación de errores y conjuntos de objetos 
 29 División de Ciencias Exactas, Ingeniería y Tecnología | Ingeniería en Desarrollo de Software 
a) Arreglos unidimensionales 
Es un conjunto de elementos que sólo tienen un índice. Algunos autores les llaman 
vectores. Se pueden definir de dos maneras la primera se conforma de la siguiente 
sintaxis (MSDN, 2013 n). 
 
Tipo [ ] Nombre; 
Nombre = new Tipo [numero_de_elementos] ; 
 
La segunda forma es la que indica CSharp, la cual permite hacerlo en un único 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 está definiendo un arreglo utilizando una sola instrucción. Este arreglo de 5 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 . . . } ; 
 
También se puede definir de la siguiente manera: 
 
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: 
 
 
Programación .NET II 
Unidad 3. Manipulación de errores y conjuntos de objetos 
 30 División de Ciencias Exactas, Ingeniería y Tecnología | Ingeniería en Desarrollo de Software 
 
 
En ambos casos se está definiendo un arreglo de cinco elementos llamados todos ellos 
dato, conteniendo 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 está definiendo el arreglo pero todos ellos inicializados con un 
cero. En el segundo caso también se está definiendo un arreglo pero además 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) Arreglos multidimensionales. 
 
Un arreglo multidimensional con dos dimensiones se define como un conjunto de 
elementos donde para hacer referencia a uno de ellos se debe indicar su fila y la columna 
donde está situada, según Trey Nash (2010). Esta característica de tener una fila y una 
columna se llaman matrices (recordar que en matemáticas una matriz es un conjuntode 
números ordenados en una tabla donde para identificar cada elemento se necesita hacer 
una referencia a su fila y su columna donde están situados, esta similitud les asigna este 
nombre). 
Conceptualmente, un arreglo multidimensional con dos dimensiones se asemeja a una 
cuadrícula, también es llamada matriz por ser similares a las matrices matemáticas. 
 
El siguiente ejemplo muestra una matriz de 3 filas y 3 columnas. 
 
 
 
 
Programación .NET II 
Unidad 3. Manipulación de errores y conjuntos de objetos 
 31 División de Ciencias Exactas, Ingeniería y Tecnología | Ingeniería en Desarrollo de Software 
Un arreglo multidimensional con tres dimensiones se asemeja a un cubo. Las 
dimensiones pueden continuar aunque no se pueden representar de una manera 
conceptual, (no existen ejemplos en nuestro mundo real donde podamos comparar más 
de 3 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 suponemos 10 elementos por dimensión. 
 
 Dimensiones Producto Elementos 
 1 10 10 
 2 10X10 100 
 3 10X10X10 1,000 
 4 10X10X10x10 10,000 
 5 10X10X10X10x10 100,000 
Tabla de dimensiones. 
 
Como se puede observar en la tabla anterior, el número de dimensiones aumenta de 
forma exponencial los registros que se necesitan en memoria, (recordar que finalmente 
todo dato se representa por un espacio en memoria RAM de la computadora), si 
aumentamos las dimensiones aumentamos en consumo de este espacio. 
 
Respecto a la forma de representación, un arreglo de dos dimensiones se puede declarar 
mediante el siguiente formato en CSharp: 
Tipo [ , ] dato; 
dato = new Tipo [filas, columnas] 
 
o 
 
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: 
 
 
 
Que sería equivalente a: 
 
 
 
Programación .NET II 
Unidad 3. Manipulación de errores y conjuntos de objetos 
 32 División de Ciencias Exactas, Ingeniería y Tecnología | Ingeniería en Desarrollo de Software 
Si se requiere definir una matriz de 3 filas x 4 columnas, los elementos se representan de 
esta manera: 
dato[0,0], dato[0,1], dato[0,2], dato[0,3] 
dato[1,0], dato[1,1], dato[1,2], dato[1,3] 
dato[2,0], dato[2,1], dato[2,2], dato[2,3] 
 
También se puede declarar de la siguiente manera, el mismo dato: 
 
Tipo [ , ] dato = { Datos } 
 
Un ejemplo de esto es lo siguiente: 
 
 
La forma de definir un dato solo es una cuestión de estilos del programador. Para el 
compilador de C Sharp es indistinto el proceso. 
 
Si se define un arreglo de 3 filas por 4 columnas en donde el elemento dato[0,0]=2 y el 
elemento dato[1,2]=0. 
En ese mismo sentido es posible definir arreglos de cualquier número de dimensiones, 
recordando que el límite es el rápido agotamiento de la memoria. 
 
Existe el concepto de matriz escalonada, es una variación del arreglo multidimensional 
es la matriz escalonada: una matriz de matrices. Una matriz escalonada es una matriz 
unidimensional y cada elemento en sí mismo es una matriz. No es necesario que todas 
las matrices de elementos sean del mismo tamaño (MSDN, 2013 j). 
 
Se expone a continuación un ejemplo de cómo definir esto: 
 
 
 
 
Si se define un arreglo de tres elementos, pero el primero de ellos tiene 5 elementos, el 
segundo 8 y el tercero 3. A esto se le conoce como una matriz escalonada, y son 
llamadas así por su similitud al concepto de las matrices escalonadas en matemáticas. 
 
Se propone un ejemplo, para entender más estos conceptos: En una situación específica 
por ejemplo una investigación de corte ambiental, se requiere tomar la presión 
 
Programación .NET II 
Unidad 3. Manipulación de errores y conjuntos de objetos 
 33 División de Ciencias Exactas, Ingeniería y Tecnología | Ingeniería en Desarrollo de Software 
barométrica, la temperatura máxima y la temperatura mínima de 5 ciudades de la 
república mexicana en un día determinado. El grupo de ciudades se muestra en la 
siguiente tabla: 
 
 Numero Ciudad 
 1 México, D.F. 
 2 Puebla, Pue. 
 3 Xalapa, Ver. 
 4 Tepic, Nay. 
 5 Mérida, Yuc. 
 
Se desarrollará un programa que solicite los datos al usuario y después los muestre en 
forma de tabla que tenga el siguiente formato: 
 
 Índice Ciudad Presión Temp Max. Temp. Min. 
 1 México, D,F; 585 15 29 
 
Y así sucesivamente. 
El código se muestra a continuación: 
 
 
 
 
Programación .NET II 
Unidad 3. Manipulación de errores y conjuntos de objetos 
 34 División de Ciencias Exactas, Ingeniería y Tecnología | Ingeniería en Desarrollo de Software 
 
 
 
 
 
 
Programación .NET II 
Unidad 3. Manipulación de errores y conjuntos de objetos 
 35 División de Ciencias Exactas, Ingeniería y Tecnología | Ingeniería en Desarrollo de Software 
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. 
Cuál es su presión barométrica: 593 
Cuál es su temperatura máxima: 27 
Cuál es su temperatura mínima: 15 
 
Para la ciudad: Xalapa, Ver. 
Cuál es su presión barométrica: 862 
Cuál es su temperatura máxima: 28 
Cuál es su temperatura mínima: 12 
 
Para la ciudad: Tepic, Nay. 
Cuál es su presión barométrica: 746 
Cuál es su temperatura máxima: 32 
Cuál es su temperatura mínima: 20 
 
Para la ciudad: Mérida, Yuc. 
Cuál es su presión barométrica: 1016 
Cuál es su temperatura máxima: 28 
Cuál es su temperatura mínima: 18 
 
Tabla capturada 
 
 No. 
Sucesivo 
Ciudad Presión Temp. 
Max. 
Temp. 
Min. 
 
 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 
 
Como se observa en este ejemplo es posible manejar arreglos de cualquier tipo, en este 
caso son doubles y string pero de manera general no existe ninguna limitante para 
generar arreglos de cualquier tipo, los arreglos representan una información a la que 
finalmente se accede a través de uno o más índices, dependiendo del número de 
dimensiones. 
 
Programación .NET II 
Unidad 3. Manipulación de errores y conjuntos de objetos 
 36 División de Ciencias Exactas, Ingeniería y Tecnología | Ingeniería en Desarrollo de Software 
¿Qué pasa si se define un arreglo de 3 elementos y se desea acceder el elemento 
número 5? Se plantea esto en el siguiente ejemplo. Se creará un objeto llamado alumno 
el cual tendrá como datos miembro el nombre del alumno y su edad de tipo string e int, 
respectivamente. Se realizará un constructor que recibirá los dos datos y sólo se le 
integrarán 2 propiedades get para recuperar ambos datos. Esto se puede observar en el 
siguiente código. 
 
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 después nos permita consultar a 
uno de ellos solicitando el número del alumno y que muestre esa información. El código 
se muestra a continuación. 
 
La primera línea del programa debe tener la siguiente instrucción, indicando que se 
utilizarán métodos de la clase System para leer datos. 
 
 
 
 
Programación .NET II 
Unidad 3. Manipulación de errores y conjuntos de objetos 
 37 División de Ciencias Exactas, Ingeniería y Tecnología | Ingeniería en Desarrollo de Software 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Programación .NET II 
Unidad 3. Manipulación de errores y conjuntos de objetos 
 38 División de Ciencias Exactas, Ingeniería y Tecnología | Ingeniería en Desarrollo de Software 
 
 
Si se ejecuta la aplicación y se da de alta a tres alumnos y sesolicitan los datos del índice 
2 y el índice 1 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 la edad del alumno: 1 35 
Dame el nombre del alumno: 2 PEDRO 
Dame la edad del alumno: 2 25 
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 
 
1.- Mostrar datos de un alumno 
2.- Terminar 
Tu opción: 1 
Escribe el índice del alumno: 1 
El alumno numero: 1 
El nombre es: JUAN 
La edad es: 35 
 
1.- Mostrar datos de un alumno 
2.- Terminar 
Tu opción: 2 
 
 
Programación .NET II 
Unidad 3. Manipulación de errores y conjuntos de objetos 
 39 División de Ciencias Exactas, Ingeniería y Tecnología | Ingeniería en Desarrollo de Software 
Si con los mismos datos se solicita el índice 4 es posible observar el siguiente error: 
 
Imagen de una excepción no controlada por un arreglo fuera de rango (Elaboración del 
autor: Manuel Panzi Utrera) 
 
Como se revisó en el tema 3.1. Control de errores en CSharp, 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 a los 
elementos definidos en la inicialización del arreglo, que es el caso que se está 
presentando de error en la superior. 
 
Se finalizará este tema revisando el concepto de objeto que tienen los arreglos en 
cCSharp. 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 realmente se está definiendo un objeto que además de tener datos tendrá 
métodos que permiten manejar la información. 
 
El siguiente ejemplo muestra algunas funciones propias que aparecen al definir un 
arreglo: 
 
 
Programación .NET II 
Unidad 3. Manipulación de errores y conjuntos de objetos 
 40 División de Ciencias Exactas, Ingeniería y Tecnología | Ingeniería en Desarrollo de Software 
 
 
Como se observa el arreglo “a” tiene propiedades como “Length” y métodos como 
“Average()” o “Sum()”, existen otros muchos métodos y propiedades, estos los puedes 
consultar en la base de conocimientos MSN de Microsoft, pero para este tema esto aclara 
el concepto anterior, 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. 
 
Se concluye recordando la definición de arreglo según Ferguson (2005): son un conjunto 
finito de datos todos ellos del mismo tipo, con un mismo nombre e identificados por un 
índice. 
 
 
Actividad 3. Conjuntos de objetos mediante arreglos en C Sharp 
 
El propósito de la actividad es que soluciones un problema en donde sea necesario 
manejar arreglos en un programa en CSharp. 
 
Para el desarrollo de la actividad tu Facilitador (a) te hará llegar un problema donde 
debes utilizar arreglos de 2 dimensiones. 
 
1. Construye un programa y define una matriz de acuerdo con las indicaciones de 
tu Facilitador (a) 
 
2. Integra un archivo de texto en el cual muestres las capturas de pantalla de la 
forma como funcionó tu programa. 
 
3. Integra un tu programa las funciones necesarias para que solicite todos los datos 
desde el teclado que llenen la matriz. 
 
4. Desarrolla las operaciones matemáticas sobre la matriz. 
 
5. Integra a tu programa la salida sobre la matriz resultado, coloca en cada renglón 
separado por espacios a los valores que conforman las diferentes filas de la 
matriz. 
 
Programación .NET II 
Unidad 3. Manipulación de errores y conjuntos de objetos 
 41 División de Ciencias Exactas, Ingeniería y Tecnología | Ingeniería en Desarrollo de Software 
 
6. Integra un archivo de texto en el cual muestres las capturas de pantalla de cada 
uno de los pasos de este proceso. 
 
7. Una vez realizado tu programa, empaca todo tu proyecto en un archivo .zip 
incluyendo el archivo de texto con las capturas de pantalla del procedimiento 
realizado. 
 
8. Guarda la actividad con el nombre DPRN2_U3_A3_XXYZ. Sustituye las XX por 
las dos primeras letras de tu primer nombre, la Y por tu primer apellido y la Z por 
tu segundo apellido. 
 
9. Envía el archivo a tu Facilitador(a) para recibir retroalimentación mediante la 
herramienta Tareas 
 
*No olvides, consultar el documento Criterios de evaluación de las actividades de la 
Unidad 3 para conocer los parámetros de esta actividad. 
 
 
 
3.2.2. Colecciones 
 
El tema anterior se concluyó con la definición de arreglo: son un conjunto finito de datos 
todos ellos del mismo tipo, con un mismo nombre e identificados por un índice. Ferguson 
J. (2005). En esta definición un punto muy importante y que se relaciona con las 
colecciones es el que se defina como un “conjunto finito de datos”, esto implica un 
problema, imagina que te solicitan hacer un programa donde almacenarás en un arreglo 
diferentes tipos de productos producidos por una empresa. En el momento que tú llegas 
se producen 5 tipos diferentes y te dicen que el incremento de nuevos tipos es un proceso 
muy lento por la gran cantidad de trámites que se debe hacer que aumentan a razón de 1 
o 2 como máximo cada año. Una solución que tú propones es crear un arreglo de 20 
elementos dándole una vida promedio a tu programa de unos 10 años, siguiendo 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 estando 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 los definimos y antes de usarlos se debe decidir el número de datos que se tendrán 
de ese tipo y este número no puede cambiar durante toda la vida del arreglo. 
 
 
Programación .NET II 
Unidad 3. Manipulación de errores y conjuntos de objetos 
 42 División de Ciencias Exactas, Ingeniería y Tecnología | Ingeniería en Desarrollo de Software 
Una colección es una forma sencilla de expresar un arreglo pero no finito (esto no 
significa que sea infinito sino que simplemente no se tiene por qué definir al inicio de su 
uso cuántos elementos se tendrán, es decir que, se puede agregar elemento tras 
elemento según se requiera, por supuesto, existe un límite, por ello no es infinito ese 
límite lo da la memoria de la computadora, el disco duro, el microprocesador, etc.,), el 
término colección es traducido por muchos autores como contenedor. Está es una 
herramienta proporcionada por el .NET Framework, son 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 los conceptos que viste en tu materia de estructuras de datos (“listas”, “pilas”, 
“colas”, “arboles”, “diccionarios”, etc.). Al seleccionar una de ellas es posible simplemente 
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 indicaDeitel & Deitel (2007). NET Framework proporciona una serie 
de componentes reutilizables llamados colecciones. Las colecciones están normalizadas 
para que las aplicaciones se puedan compartir con facilidad, sin tener que preocuparse 
por los detalles de su implementación. Estas colecciones están escritas para una amplia 
reutilización. Está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 sóloestas se explicarán con detalle 
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 de las colecciones funcionan bajo alguno de estos dos principios y 
sólo cambian algunas características tales como: si están ordenadas o no, si se recuperan 
en el mismo orden en que se inserta información, etcétera. 
 
List: Es equivalente a el concepto de una lista doblemente ligada (tema que revisaste en 
tu materia de Estructura de datos). Se puede decir que 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 esos datos (los que tú le ingreses a la lista), tales como la longitud, buscar un 
elemento, borrar un elemento, ordenarlo, encontrar el máximo, encontrar el mínimo, 
etcétera. El siguiente código es un ejemplo de uso de una clase lista o List. 
 
Todos los programas deberán llevar al inicio la siguiente instrucción: 
 
 
 
 
Programación .NET II 
Unidad 3. Manipulación de errores y conjuntos de objetos 
 43 División de Ciencias Exactas, Ingeniería y Tecnología | Ingeniería en Desarrollo de Software 
La cual indica al compilador que se utilizarán las colecciones. El código se muestra a 
continuación 
 
 
 
 
 
 
 
 
 
 
Programación .NET II 
Unidad 3. Manipulación de errores y conjuntos de objetos 
 44 División de Ciencias Exactas, Ingeniería y Tecnología | Ingeniería en Desarrollo de Software 
 
 
 
 
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. Se explicará con el 
siguiente ejemplo: se desarrollará un diccionario conformado por el par, numero de control 
(que es un valor entero) y nombre (que es una cadena). Se da de alta la siguiente tabla: 
 
 Llave Valor 
 345 Juan 
 245 Miguel 
 123 Ángel 
 667 Pedro 
Tabla ejemplo de información de un diccionario (Elaboración del autor: Manuel Panzi 
Utrera) 
 
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 2 porque no se maneja de esa 
 
Programación .NET II 
Unidad 3. Manipulación de errores y conjuntos de objetos 
 45 División de Ciencias Exactas, Ingeniería y Tecnología | Ingeniería en Desarrollo de Software 
manera. La pregunta debe plantearse de esta forma: si tengo la llave 123 ¿a qué valor le 
corresponde? 
 
Existen una serie de reglas para el manejo de los diccionarios en CSharp. 
 
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: “Angel” pero este debe tener otra llave para identificarlo. Lo 
que no es posible es tener dos llaves iguales que identifiquen a dos personas diferentes 
sería similar a pensar que existen dos personas diferentes con el mismo CURP, por eso el 
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 en el 
siguiente código: 
 
 
 
 
 
 
Programación .NET II 
Unidad 3. Manipulación de errores y conjuntos de objetos 
 46 División de Ciencias Exactas, Ingeniería y Tecnología | Ingeniería en Desarrollo de Software 
 
 
 
 
 
 
 
Programación .NET II 
Unidad 3. Manipulación de errores y conjuntos de objetos 
 47 División de Ciencias Exactas, Ingeniería y Tecnología | Ingeniería en Desarrollo de Software 
 
 
Existen otros contenedores en C Sharp para el manejo de la información, se mencionarán 
algunos de los más comúnmente usados. 
 
Queue (cola) 
“Representa una colección de objetos de tipo primero en entrar, primero en salir” (MSDN, 
2013 b) 
 
Las colas son útiles para guardar información en el orden en que fueron recibidas, 
simulan una cola de personas ante una caja por ejemplo. 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, el método Dequeue para 
quitar el primer elemento de la cola, el método Peek para localizar el siguiente elemento 
de la cola y el método Dequeue para quitarlo de la cola. Entre muchos otros métodos. 
 
A continuación se expone un ejemplo de uso: 
 
Programación .NET II 
Unidad 3. Manipulación de errores y conjuntos de objetos 
 48 División de Ciencias Exactas, Ingeniería y Tecnología | Ingeniería en Desarrollo de Software 
 
 
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, 2013 d) 
 
Las pilas son útiles para almacenar información y procesar la última que llego. Los objetos 
almacenados en un Stack se insertan en un extremo y se quitan en el mismo, proporciona 
una serie de métodos para el manejo de la información siguiendo 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 
 
Programación .NET II 
Unidad 3. Manipulación de errores y conjuntos de objetos 
 49 División de Ciencias Exactas, Ingeniería y Tecnología | Ingeniería en Desarrollo de Software 
elemento al inicio de la pila. Existe también el método toArray que convierte el contenido 
en un arreglo. 
 
S expone a continuación un ejemplo de uso de pilas. 
 
 
Si se ejecuta este programa la salida que se muestra es la siguiente: 
Lista de datos guardados 
0 Archivo.Ptt 
1 Archivo.Doc 
2 Archivo.Pdf 
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, 2013 c). 
 
La clase genérica SortedList es un árbol de búsqueda binaria, que mantiene la 
información constantemente ordenada utilizando precisamente ese concepto de árbol 
binario. Este contenedor ya provee mecanismos para mantenerse constantemente 
 
Programación .NET II 
Unidad 3. Manipulación de errores y conjuntos de objetos 
 50 División de Ciencias Exactas, Ingeniería y Tecnología | Ingeniería en Desarrollo de Software 
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 no es más que una clase que le indicará a la colección como se deben 
ordenar los objetos dentro de él. 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 que 
sutilizados se ordenan de manera natural, los números enteros por su orden numérico y 
las cadenas por el orden alfabético. 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 5 campos 
debe ser ordenado o si se necesita una combinación de ellos, (es posible que por 
necesidad se deba ordenar por sexo y edad).Por ejemplo las listas de alumnos se 
ordenan de manera común por apellido paterno, apellido materno y nombre. Estamos 
usando tres campos A esa clase se le llama comparador. 
 
Se expone a continuación un ejemplo para entender el concepto.En el supuesto caso de que se requiera hacer una colección que guarde los datos de los 
autos que están a la venta en un lote. De los autos se conoce: La placa, la marca, el 
modelo (Tsuru de lujo, Focus automático, etc.), el color, el año y un precio estimado de 
venta. Nosotros necesitamos poder listarlos por placa, por modelo o por precio pero este 
en dos opciones de menor a mayor o de mayor a menor. Este ejemplo de uso de un 
SortList en código se representa a continuación. 
 
La clase Auto tendría el siguiente código: 
 
 
Programación .NET II 
Unidad 3. Manipulación de errores y conjuntos de objetos 
 51 División de Ciencias Exactas, Ingeniería y Tecnología | Ingeniería en Desarrollo de Software 
 
 
 
 
 
Programación .NET II 
Unidad 3. Manipulación de errores y conjuntos de objetos 
 52 División de Ciencias Exactas, Ingeniería y Tecnología | Ingeniería en Desarrollo de Software 
 
 
 
 
 
Se necesitan definir 4 comparadores para poder tener las 4 diferentes formas de 
ordenamiento, solicitadas: 1.- Por placa, 2.- por modelo o por precio pero este en dos 
opciones de 3.- menor a mayor o 4.- de mayor a menor. Esto se muestra a continuación: 
 
 
 
 
 
 
 
 
Programación .NET II 
Unidad 3. Manipulación de errores y conjuntos de objetos 
 53 División de Ciencias Exactas, Ingeniería y Tecnología | Ingeniería en Desarrollo de Software 
El comparador por placa es el siguiente: 
 
 
 
El comparador por modelo es el siguiente: 
 
 
 
El comparador por precio descendente es el siguiente: 
 
 
 
 
 
 
 
 
 
 
 
 
 
Programación .NET II 
Unidad 3. Manipulación de errores y conjuntos de objetos 
 54 División de Ciencias Exactas, Ingeniería y Tecnología | Ingeniería en Desarrollo de Software 
El comparador por precio ascendente es el siguiente: 
 
 
 
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 
 
El programa principal mostrará el lote ordenado por placa, modelo, precio ascendente y 
descendente. Esto se observa en el siguiente código. 
 
Se utilizará un List para generar estos resultados. 
 
 
 
 
Programación .NET II 
Unidad 3. Manipulación de errores y conjuntos de objetos 
 55 División de Ciencias Exactas, Ingeniería y Tecnología | Ingeniería en Desarrollo de Software 
 
 
 
 
Programación .NET II 
Unidad 3. Manipulación de errores y conjuntos de objetos 
 56 División de Ciencias Exactas, Ingeniería y Tecnología | Ingeniería en Desarrollo de Software 
 
 
En el momento de la ejecución del programa, 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 
 
Programación .NET II 
Unidad 3. Manipulación de errores y conjuntos de objetos 
 57 División de Ciencias Exactas, Ingeniería y Tecnología | Ingeniería en Desarrollo de Software 
YAT1101 Honda 
Civic Sedan Gris Plata 2010 98000 
YCS3932 Nissan 
Centra Lujo Perla 2000 95000 
YFG2100 Volkswagen 
Golf Estándar Azul Acero 2000 65000 
YTR1010 Ford 
Focus Básico Rojo 2001 80000 
YUH2010 Toyota 
Corola Típico Blanco 2005 90000 
 
YCS3932 Nissan 
Centra Lujo Perla 2000 95000 
YAT1101 Honda 
Civic Sedan Gris Plata 2010 98000 
YUH2010 Toyota 
Corola Típico Blanco 2005 90000 
YTR1010 Ford 
Focus Básico Rojo 2001 80000 
YFG2100 Volkswagen 
Golf Estándar Azul Acero 2000 65000 
 
YFG2100 Volkswagen 
Golf Estándar Azul Acero 2000 65000 
YTR1010 Ford 
Focus Básico Rojo 2001 80000 
YUH2010 Toyota 
Corola Típico Blanco 2005 90000 
YCS3932 Nissan 
Centra Lujo Perla 2000 95000 
YAT1101 Honda 
Civic Sedan Gris Plata 2010 98000 
 
YAT1101 Honda 
Civic Sedan Gris Plata 2010 98000 
YCS3932 Nissan 
Centra Lujo Perla 2000 95000 
YUH2010 Toyota 
Corola Típico Blanco 2005 90000 
YTR1010 Ford 
Focus Básico Rojo 2001 80000 
 
Programación .NET II 
Unidad 3. Manipulación de errores y conjuntos de objetos 
 58 División de Ciencias Exactas, Ingeniería y Tecnología | Ingeniería en Desarrollo de Software 
YFG2100 Volkswagen 
Golf Estándar Azul Acero 2000 65000 
 
¿Cómo funciona el comparador que utiliza SortedList? Realmente es muy simple su 
lógica de funcionamiento es: requiere indicaciones de cómo se ordenan 2 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: recordando la clase del lote de autos, 
ahora se desea desarrollar un comparador para ordenar por modelo. El ordenamiento es 
de forma descendente. 
 
Retomando un ejemplo del modelo de 2 autos, se nombrará auto1 y auto2, se comparará 
el modelo del auto1 con el modelo del auto2 (esta comparación es alfanumérica, la letra 
“A” es menor que la “B” y así sucesivamente, desde el punto de vista de palabras 
“ANGEL” es menor que “MANUEL” porque ANGEL inicia con A y MANUEL con M), si son 
iguales se regresa un 0, si el modelo del auto1 es mayor que el modelo del auto2 
regresará un número positivo indicando que no se deben intercambiar de posición, si es lo 
contrario el auto1 es menor que el auto2, se regresa un número negativo indicando 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 así: 
 
 
Se observa que es muy fácil obtener el valor positivo sólo restándolos cuando se trata de 
comparar valores numéricos. En el caso de comparar cadenas se utiliza el método 
compareTo de las cadenas que devuelve precisamente un -1, +1 o un 0. De esta manera 
se comparan cadenas. 
 
Se concluye con este tema recapitulando acerca de la utilidad de las colecciones, esto 
permiten contener una gran cantidad de datos sin necesidad de definir el número de 
ellos desde un inicio como se observó en todos los ejemplos la información se guarda sin 
preocuparse por los límites de almacenamiento y los métodos de manejo de información 
porque estos ya se encuentran implementados, es posible tener acceso a ellos de forma 
directa con sólo invocarlos. 
 
 
 
Programación .NET II 
Unidad 3. Manipulación de errores y conjuntos de objetos 
 59 División de Ciencias Exactas, Ingeniería y Tecnología | Ingeniería en Desarrollo de Software 
Actividad 4. Conjuntos de objetos mediante colecciones en C Sharp 
 
El propósito de la actividad es que soluciones un problema en donde sea necesario 
utilizar una de las colecciones que proporciona el Framework de .NET en CSharp. 
 
Para el desarrollo de la actividad tu facilitador te hará llegar un problema mediante el cual 
debes crear un objeto, y este objeto debe ser agregado a un contenedor de los que 
proporciona Framework de .NET, las operaciones de alta del objeto, listado del contenido 
del contenedor y ordenamiento del mismo, se hará mediante un menú simple. 
 
 
1. Construye el objeto solicitado con sus datos y propiedades indicadas por tu 
facilitador(a), debes sobre-escribir el método ToString(), mostrando el contenido 
del objeto en forma ordenada y clara. 
 
2. Construye las dos clases comparadoras para que puedas ordenar la colección 
por el dato solicitado. 
 
3. Desarrolla un menú con las siguientes opciones: 
a. Crea un nuevo objeto. Solicita sus datos miembro y adiciónalos al 
contenedor. 
b. Lista el contenido del contenedor. 
c. Lista en forma ordenada por 2 opciones el contenedor. 
d. Esta opción debe terminar de forma correcta el programa. 
 
4. Integra en el menú el uso de la clase desarrollada y los dos comparadores para 
que funcionen las diferentes opciones