Ejercicio 4

Construir una aplicación que cumpla con los requisitos siguientes:
 
1. Declarar un tipo estructura Person (Persona) que contenga la siguiente información de una persona:
   - nombre
   - apellido
   - edad
   - número de seguro social
 
2. Implementar un método que reciba dos estructuras Person y devuelva la más antigua.
 
3. Declarar una matriz para almacenar las estructuras Person.
 
4. Implementar un método para ordenar la matriz por edad.
Nota: uno de los algoritmos más conocidos y sencillos para organizar es Bubble Sort.
 
5. Implementar un método para mostrar la información de cada Person contenida en la matriz.
 
6. Implementar un procedimiento que reciba la matriz antes definida y llenarla con la información proporcionada 
por el usuario. Utilizar un try catch para asegurar que el usuario proporcione información válida. Generar una
excepción en el bloque catch para indicar que se ingresó información inválida. Para detectar esta excepción, 
inserte un bloque try catch en el método principal.
 
7. Por ultimo, en la función principal, invoque los métodos para llenar, ordenar y mostrar la formación.
 
using System;
 
namespace CuartoEjercicio
{
   public struct Person //Aqui declaramos un tipo de datos que se llamara Person
   {
               public string Nombre,Apellido;          //Para el nombre
               public int Edad;                //Para la edad
               public int NSS;                             //Para el numero de Seguro Social
   }           
   
   class CuartoEjercicio
   {
               [STAThread]
 
               
               //A continuacion las funciones que utilizaremos
               public static void Llenar(Person[] Persona)//Recibimos un arreglo de datos de tipo Person
               {
                           try //Siempre ahi que llevar un control de errores
                           {
                                       for(int i=0; i < Persona.Length; i++)
                                       //mientras aun haya mas personas en la lista pedimos sus datos
                                       {
                                                   Console.Write("  Nombre: ");
                                                    //Imprimimos la petición de que nos den el nombre
                                                   Persona[i].Nombre = Console.ReadLine();
                                                   //Capturamos el dato en el arreglo
 
                                                   Console.Write("Apellido: ");
                                                   Persona[i].Apellido = Console.ReadLine();
                                                                
                                                   Console.Write("    Edad: ");
                                                   Persona[i].Edad = int.Parse(Console.ReadLine());
 
                                                   Console.Write("  N.S.S.: ");
                                                   Persona[i].NSS = int.Parse(Console.ReadLine());         
                                                   Console.WriteLine("");
                                       }
                           }
                           catch (Exception e)
                           //En caso de alguna anomalía se lanzará una excepción
                           {                                               
                                       throw new Exception("Dato no valido: " + e.Message,e);
                                       /*Aquí nosotros lanzaremos una excepción personalizada, dicha excepción dirá que
                                       es un dato invalido e imprimirá la descripción del problema, este tipo de excepciones
                                       nos permitén detener la ejecución del programa en un punto determinado sin necesidad
                                       de tratarla en la parte del código donde tratamos las demás excepciones*/
                           }
               }
 
               public static void Ordenar( Person[] Persona )//Recibimos un arreglo de datos de tipo Person
               {
                           Person p;//Declaramos una variable de tipo Person llamada p
               
                           /*Los dos ciclos for uno dentro de otro nos permitiran utilizar una técnica de ordenamiento
                           Conocida como bubble sort, en el articulo de metodos de ordenamiento se explicaran mas con
                           mas detalle las técnicas de ordenamiento*/
                           for(int i=0; i < Persona.Length; i++)
                           {
                                       for(int j=0; j Persona[j].Edad )
                                                   {
                                                                p = Persona[i];
                                                                Persona[i] = Persona[j];
                                                                Persona[j] = p;
                                                   }
                                       }
                           }
               }
 
               public static void Mostrar( Person[] Persona )//Recibimos un arreglo de elementos Person
               {
                           foreach( Person p in Persona )
                           //Por cada Person en Persona se imprimirán los datos de dicha persona
                           {
                                       Console.WriteLine("  Nombre: "+p.Nombre);
                                       Console.WriteLine("Apellido: "+p.Apellido);
                                       Console.WriteLine("    Edad: "+p.Edad);
                                       Console.WriteLine("  N.S.S.: "+p.NSS+"\n");
                           }
               }
 
               static void Main(string[] args)
               //Desde aqui controlaremos el flujo del programa
               {
                           Person[] Persona = new Person[2];
                           //Declaramos un array de datos Person llamado Persona con 2 elementos
                           try
                           //Nuestro control general de errores(aquellas no personalizadas)
                           {
                                       Llenar(Persona); //Llenamos el arreglo
                                       Ordenar(Persona);//Lo ordenamos
                                       Mostrar(Persona);//Lo mostramos
                           }
                           catch( Exception e )
                           //Si hubo algún error aquí lo podemos solucionar
                           {
                                       Console.WriteLine("\n"+e.Message);
                                       Console.WriteLine("*----------------------------------------------------*");
                           }
                           finally
                           //Finalmente haya habido o no errores este mensaje se imprimirá
                           {
                                       Console.WriteLine("\ngracias por usar nuestro programa");
                           }
                           Console.Read();
               	}
   	}
}

Aqui podemos ver los datos al ser introducidos
En esta imagen se ven los datos ya ordenados y el mensaje que pusimos en el bloque finally es desplegado
Por ultimo esta es la imagen en la que se lanza nuestra excepcion personalizada y como se puede apreciar el bloque finally igualmente es desplegado

AVISO: Impartiré unos cursos en linea TOTALMENTE GRATUITOS en la página 
http://groups.msn.com/MUGVeracruz

 

---

Anterior

Índice

Siguiente