Proyecto final de carrera

.NET
Ingeniería de sistemas e informática

INTEGRANTES:

Muchotrigo Perez Bashir

Palacios Roman Rodrigo

 Contenido

1. Introducción ................................................................................................................................ 3
2. Plan de proyecto ......................................................................................................................... 4
1.1 Descripción del proyecto..................................................................................................... 4
1.2 Objetivos de la aplicación.................................................................................................... 4
1.3 Contextos de uso. ................................................................................................................ 4
3. LOGICA DEL APLICATIVO ............................................................................................................ 5
1.1 C#......................................................................................................................................... 5
 Estructuras condicionales anidadas (if-else). ...................................................................... 5
 Estructura repetitiva do while ................................................................................................ 5
 Métodos..................................................................................................................................... 5
 Parámetros por referencia (ref) ............................................................................................. 6
 Vector ......................................................................................................................................... 6
 Clases.......................................................................................................................................... 6
 Objetos....................................................................................................................................... 6
 Constructores............................................................................................................................ 7
 Estructura repetitiva foreach.................................................................................................. 7
 Colección: Queue<T>.............................................................................................................. 7
 Estructuras dinámicas de Listas tipo Cola............................................................................ 7
4. Manual de usuario ...................................................................................................................... 8
1. VISUAL STUDIO ........................................................................................................................ 8
1.1.1. MODO DE EMPLEO DE NUESTRO APLICATIVO .............................................................. 10
5. Conclusiones ............................................................................................................................. 14
6. REFERENCIAS ............................................................................................................................ 15
1. Introducción

Este proyecto, aparte de ser la asignatura de cierre a un largo y duro camino, es una síntesis de
todos los conocimientos adquiridos hasta la fecha, universitarios y no universitarios, porque a mi
entender, una gran ventaja que he adquirido durante estos meses de estudio, es la metodología o
la destreza de buscar soluciones a los problemas de forma más o menos autónoma. En la
elaboración he intentado aprender una nueva tecnología como es: C# y crear un producto útil y
utilizable en el mundo real.

El siguiente aplicativo es una versión C# de un programa que permite reservar citas médicas por
Consola.

Es necesario saber que función cumple el programa Visual Studio para poder entender que función
cumple en nuestro aplicativo
2. Plan de proyecto

1.1 Descripción del proyecto.

El proyecto estará basado en una aplicación de consola que permitirá reservar citas médicas y
escoger el horario en el que desea ser atendido. También permitirá buscar los elementos agregados
en la pila y eliminar las reservaciones o cambiarlas.

1.2 Objetivos de la aplicación

El proyecto está enfocado a mejorar la documentación de las incidencias y su posterior control.
Además, aumentará la productividad del cuerpo técnico, dado que permitirá controlar las
asistencias realizadas mediante números de incidencia. De este modo al registrar cada incidencia
unitariamente, se evitará la duplicación de informes por diferentes técnicos.

Además, permite tanto a los usuarios mantener una cola de trabajo ordenada, como al responsable
controlar las tareas de sus técnicos e insertar tareas nuevas.

1.3 Contextos de uso.

El usuario administrador, tendrá acceso a todas las funcionalidades de la aplicación incluso acceso
a los datos DNI, nombre y cita reservada.

 La aplicación estará implementada en castellano, por lo tanto deberá conocer el idioma

oficial del país.

 Deberá tener un mínimo de conocimientos de informática, como puede ser utilizar los
periféricos principales (ratón y teclado).
3. LOGICA DEL APLICATIVO

1.1 C#.
La lógica del aplicativo está compuesta de métodos, clases, estructuras repetitivas y de control, etc.,
las cuales nombraremos y explicaremos a continuación:

 Estructuras condicionales anidadas (if-else).

Decimos que una estructura condicional es anidada cuando por la rama del verdadero o el falso de
una estructura condicional hay otra estructura condicional.

 Estructura condicional switch

La estructura switch es una instrucción de control que controla múltiples selecciones y

enumeraciones pasando el control a una de las instrucciones case de su cuerpo.

 Estructura repetitiva do while

La estructura do while es otra estructura repetitiva, la cual ejecuta al menos una vez su bloque
repetitivo, a diferencia del while o del for que podían no ejecutar el bloque.
Esta estructura repetitiva se utiliza cuando conocemos de antemano que por lo menos una vez se
ejecutará el bloque repetitivo.

 Métodos
Los métodos son un bloque de código que contiene una serie de instrucciones. En C#, cada
instrucción se ejecuta en el contexto de un método.
Los métodos se declaran en una clase o estructura especificando el nivel de acceso, el valor
devuelto, el nombre del método y los parámetros de método.
  Parámetros de métodos
Para pasar argumentos a un método simplemente hay que proporcionarlos entre paréntesis cuando
se llama al método. En el método al que se llama, los argumentos de entrada se
denominan parámetros.
Los parámetros que un método recibe también se proporcionan entre paréntesis, pero se debe
especificar el tipo y nombre de cada parámetro. El nombre no tiene por qué ser igual que el
argumento.

 Parámetros por referencia (ref)

Si queremos que un método retorne más de un dato es común utilizar los parámetros por referencia.
La idea central es pasar a un método las direcciones de las variables para que el método pueda
modificar los datos de las variables pasadas.
Para indicar que un parámetro es por referencia debemos anteceder la palabra clave "ref"
Cuando llamamos a un método que tiene uno o más parámetros por referencia debemos anteceder
la palabra ref previo a la variable.

 Vector
Un vector es una estructura de datos que permite almacenar un CONJUNTO de datos del MISMO
tipo.
Con un único nombre se define un vector y por medio de un subíndice hacemos referencia a cada
elemento del mismo (componente).

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

 Objetos
Aunque se utilizan a veces de forma intercambiable, una clase y un objeto son cosas diferentes. Una
clase define un tipo de objeto, pero no es propiamente un objeto. Un objeto es una entidad
concreta basada en una clase y, a veces, se denomina instancia de una clase.
  Constructores
Cada vez que se crea una clase o estructura, se llama a su constructor. Una clase o estructura puede
tener varios constructores que toman argumentos diferentes. Los constructores permiten al
programador establecer valores predeterminados, limitar la creación de instancias y escribir código
flexible y fácil de leer.
Las clases y estructuras estáticas también pueden tener constructores.
El constructor tiene las siguientes características:

 Tiene el mismo nombre de la clase.

 Es el primer método que se ejecuta.
 Se ejecuta en forma automática.
 No puede retornar datos.
 Se ejecuta una única vez.
 Un constructor tiene por objetivo inicializar atributos.

 Estructura repetitiva foreach

La estructura repetitiva foreach es utilizada para recorrer colecciones de datos (por ejemplo
vectores), si bien podemos utilizar de forma tradicional las otras estructuras repetitivas el empleo
del foreach hacen más natural el acceso a los elementos.

 Colección: Queue<T>
En el espacio de nombres: 'System.Collections.Generic' se encuentran la clase Queue<T>.
Queue<T>: Implementa el concepto de una cola (FIFO - Fist In First Out - Primero en entrar primero
en salir)

 Estructuras dinámicas de Listas tipo Cola

Una lista se comporta como una cola si las inserciones las hacemos al final y las extracciones las
hacemos por el frente de la lista. También se las llama listas FIFO (First In First Out - primero en
entrar primero en salir).
4. Manual de usuario

1. VISUAL STUDIO
Microsoft Visual Studio es un entorno de desarrollo integrado (IDE, por sus siglas en inglés) para
sistemas operativos Windows. Soporta múltiples lenguajes de programación, tales como C++, C#,
Visual Basic .NET, F#, Java, Python, Ruby y PHP, al igual que entornos de desarrollo web, como
ASP.NET MVC, Django, etc., a lo cual hay que sumarle las nuevas capacidades online bajo Windows
Azure en forma del editor Monaco.

Visual Studio permite a los desarrolladores crear sitios y aplicaciones web, así como servicios web
en cualquier entorno que soporte la plataforma .NET (a partir de la versión .NET 2002). Así, se
pueden crear aplicaciones que se comuniquen entre estaciones de trabajo, páginas web,
dispositivos móviles, dispositivos embebidos y consolas, entre otros.

Antes de proceder a compilar el aplicativo, es conveniente hacer algunos comentarios generales

que irán ayudando a comprender mejor este programa.

 En este aplicativo se están empleando la gran mayoría de temas trabajados en clases.

 El método Main es especialmente importante ya que es el punto de entrada del
programa, el método que se ejecuta en primer lugar. Tiene 3 palabras que le
preceden:

o void indica que este método no devuelve nada. La palabra inmediatamente

anterior a un método, indica el tipo de dato que devuelve el método Main().
o public: con este modificador se indica que este método es público y que por lo
tanto puede ser llamado desde el código de cualquier clase
o static: indica que Main() es un método de clase estático, es decir, que puede ser
invocado sin necesidad de crear un objeto.
 Las pilas (Stack) y las colas (Queue) son dos colecciones muy similares entre si ya
que solo varia la forma en que guardan y extraen los elementos que contienen.

 La cola (Queue), tiene el comportamiento contrario a la pila. Todo nuevo elemento

se agrega al principio de la colección y solo se puede extraer el último elemento. Por
esta razón, la cola se conoce como una colección FIFO (Fisrt Input First Output) ya
que el primer elemento que ingresa a la cola es el primer elemento que sale.

 Las colecciones Stack y Queue se encuentran en el espacio de nombres

System.Collections como todas las colecciones no genéricas.
1.1.1. MODO DE EMPLEO DE NUESTRO APLICATIVO

1. En primer lugar compilamos nuestro aplicativo con la tecla F5 o en su defecto

presionamos en start (iniciar) en la barra de menús

2. Una vez compilado el programa con éxito saldrá la nueva ventana donde nos pide
ingresar los datos para poder reservar la cita médica o en caso contrario salir del
aplicativo.

3. En esta ocasión escogeremos la opción nro. 1 para poder ver el funcionamiento del
aplicativo creado.
4. Habiendo seleccionado la opción 1, nos pide ingresar primero nuestro Nombre
Completo.

5. Luego ingresamos nuestro nro. De DNI para completar el ingreso de nuestros datos
personales.

6. Una vez ingresado el DNI el aplicativo nos muestra las especialidades que tiene y a
su vez nos pide ingresar la opción que deseemos.
7. Una vez escogida la especialidad, ingresamos el turno en que nos deseamos
atender.

8. Luego de escoger el turno de atención, elegimos el horario que deseamos.

9. Para terminar de registrar nuestra cita, elegimos el horario y el aplicativo nos
resumirá los pasos ya elegidos con el siguiente mensaje:

10. Una vez terminado el registro del paciente, si se desea agregar otra persona
escogemos la opción “S”, de lo contrario escogemos la opción “N” para terminar y
salir del aplicativo.
5. Conclusiones

Como experiencia personal, creo que ha sido un trabajo muy satisfactorio, aunque ha habido
algunos momentos desesperantes. Supongo que es una de las partes buenas de la programación,
ver que tu producto se mueve y lo que haces sirve para algo.

Trabajar con tecnología .NET tiene la gran ventaja de que existe infinidad de información disponible
en la web, muchas de las necesidades que te surgen, ya hay alguien que la ha solucionado o bien
algo muy parecido, por lo tanto es muy propenso a reutilizar código. Por el contrario, también hay
que decir que el 90% de dicha información está en inglés, por lo tanto, es un punto a tener en cuenta;
el nivel de inglés es importante para este tipo de trabajos.
6. REFERENCIAS
http://www.tutorialesprogramacionya.com/csharpya/

https://msdn.microsoft.com/es-es/library/ms173109(v=vs.80).aspx

https://es.wikipedia.org/wiki/C_Sharp