“PROYECTO SOCIO FORMATIVO”

Desarrollo e Implementación de un Software para Monitorear el

Promedio de Conocimientos en Programación Básica.

Docente: Robert Wilson Cruz Claure

Materia: Programación 1

Estudiantes: Miguel Ángel Pérez Vallejos

Valentina Domínguez Salvatierra

Luar Matías Berdeja

María José Pessoa Caumol

Ariel Mamani Huanca

Fecha: 02/09/24

1
Indicé

Carátula…………………………………………………………………………………..1

Índice o Tabla de Contenido…………………………………………………………….2

Dedicatoria……………………………………………………………………………….3

Justificación………………………………………………………………………………4

Objetivos……………..........................................................................................................5

Objetivo General………........................................................................................................6

Objetivos Específicos…………………………………………………………………….....7

I: Antecedentes……………………………………………………………………………..8

Software (Problema y Solución)……………………………………………………………9

Lista de Requerimientos Funcionales……………………………………………………..10

II: Marco Conceptual…………………………………………………………………….11

Estructuras de Control…………………………………………………………………….12

Programación Modular……………………………………………………………………13
Cadena de Caracteres……………………………………………………………………...14

Programación con Estructuras Unidimensionales…………………………………………15

III: Desarrollo…………………………………………………………………………….16

Interfaces de Usuario………………………………………………………………………17

Captura de Interfaces de Usuario………………………………………………………….18

Mapa de Navegación……………………………………………………………………….19

Código……………………………………………………………………………………...20

Código Fuente por Formulario…………………………………………………………….21

Conclusiones………………………………………………………………………………22

Recomendaciones…………………………………………………………………………23

Bibliografía……………………………………………………………………………….24

Glosario……………………………………………………………………………………25

2
Dedication

This project, titled ”Development and Implementation of Software to Monitor Basic

Programming Knowledge Average”, is the result of joint effort and collaboration from a
dedicated team. We would like to dedicate this work to all those who, in one way or another,
contributed to its completion.

Firstly, we dedicate this project to our instructor, Robert Wilson Cruz Claure, whose teaching
and guidance have been crucial in overcoming the challenges we faced during the
development. Thank you for sharing your extensive knowledge and inspiring us to achieve
our goals.

To our colleagues and friends, we sincerely appreciate your support and collaboration. Your
willingness to exchange ideas and work as a team has been key to reaching our objectives.

We also want to express our gratitude to the institutions and platforms that provided us with
the resources and technical support necessary to carry out this project. Your support has been
fundamental to the successful execution of our ideas.

In addition, we extend our gratitude to all those who provided feedback and constructive
criticism throughout the development process. Your insights and suggestions helped refine
our work and enhance its quality, making it a more robust and effective tool.

Finally, we dedicate this project to all those who, in some way, were part of this process,
whether through their advice, experience, or simply their presence. Each of you has left a
mark on this work, and for that, we are deeply grateful.

3
Justificación

La programación básica es una habilidad que abre muchas puertas en el mundo actual, pero
aprenderla puede ser un reto. Muchos estudiantes se enfrentan a la incertidumbre de no saber
si están avanzando adecuadamente, y los docentes a menudo desean herramientas más
precisas para poder acompañar mejor a sus alumnos en este proceso de aprendizaje. En este
contexto, surge la necesidad de una solución que facilite el monitoreo y el apoyo constante
tanto para estudiantes como para docentes.

Nuestro proyecto, ”Desarrollo e Implementación de un Software para Monitorear el

Promedio de Conocimientos en Programación Básica”, está pensado para ser esa solución.
Imaginamos un software que actúe como un puente entre estudiantes y docentes, brindando
claridad sobre el desempeño de cada alumno. Más allá de ser solo un sistema de evaluación,
queremos que este software se convierta en un aliado en el proceso de aprendizaje, ayudando
a los estudiantes a comprender mejor sus avances y a los docentes a ajustar sus estrategias de
enseñanza según las necesidades reales de su clase.

Este proyecto nace del deseo de ofrecer una herramienta que, con la información correcta,
permita a los estudiantes sentirse más seguros y conscientes de su progreso, y a los docentes
tener una visión más clara y detallada del rendimiento de sus alumnos. Creemos que con las
herramientas adecuadas, cada estudiante puede superar los desafíos que presenta la
programación básica y cada docente puede potenciar el aprendizaje de su clase.

En definitiva, este proyecto es más que un simple software; es nuestra manera de contribuir
a una educación más efectiva y cercana, donde cada estudiante tiene la oportunidad de
alcanzar su máximo potencial, y cada docente cuenta con el apoyo necesario para guiar a sus
alumnos de la mejor manera posible.

4
Objetivos

Objetivo General

Desarrollar e implementar un software integral que no solo permita el monitoreo eficiente

del promedio de conocimientos en programación básica, sino que también ofrezca
herramientas avanzadas para identificar a los cinco estudiantes más destacados en la
participación de preguntas y respuestas, así como para calcular y analizar el promedio de
rendimiento académico entre hombres y mujeres. Este software tiene como fin proporcionar
a docentes y estudiantes una plataforma robusta y versátil que facilite el seguimiento
detallado del progreso académico, promueva la competencia sana, y fomente una
comprensión más profunda de las dinámicas de aprendizaje en el aula.

Al integrar la identificación de los estudiantes más participativos, el software busca motivar

a los alumnos a involucrarse activamente en las actividades de clase, destacando no solo su
rendimiento en las evaluaciones, sino también su participación en el proceso de aprendizaje.
De esta manera, se pretende reconocer y recompensar el esfuerzo y la participación constante,
elementos clave para un aprendizaje efectivo y significativo.

Por otro lado, el análisis del promedio de rendimiento entre hombres y mujeres permitirá a
los docentes obtener una visión más completa y equitativa del progreso de sus alumnos,
identificando posibles brechas de género y facilitando la implementación de estrategias
pedagógicas más inclusivas y adaptadas a las necesidades de todos los estudiantes. Este
enfoque permitirá una enseñanza más justa y equilibrada, contribuyendo al objetivo de
ofrecer una educación de calidad para todos.

Además, el software estará diseñado con una interfaz intuitiva y amigable, que permitirá a
los usuarios interactuar con la plataforma de manera sencilla y efectiva. Este enfoque en la
usabilidad garantizará que tanto estudiantes como docentes puedan acceder fácilmente a las
funcionalidades del software, aprovechando al máximo sus capacidades sin necesidad de una
formación técnica extensa. La simplicidad en el diseño, combinada con potentes
herramientas analíticas, hará que el software sea una herramienta indispensable en el aula,

5
facilitando la toma de decisiones informadas y el desarrollo de estrategias de enseñanza
personalizadas.

Objetivo Específico

Desarrollar y perfeccionar un módulo dentro del software que permita identificar de manera
automática y en tiempo real a los cinco estudiantes con mayor participación en las preguntas
de clase, creando un ranking que refleje su compromiso y contribución al aprendizaje. Este
ranking no solo tiene como objetivo reconocer a los alumnos más activos, sino también
inspirar a toda la clase a participar más, fomentando un ambiente de colaboración y
motivación.

El módulo capturará cada intervención de los estudiantes, evaluando tanto la frecuencia como
la calidad de sus respuestas. Utilizando un sistema inteligente, el software valorará las
aportaciones de los alumnos, considerando su relevancia y el impacto que tienen en las
discusiones del aula. Con esta información, el ranking destacará a aquellos que, con sus
aportaciones valiosas, enriquecen la experiencia de aprendizaje para todos.

Además, el módulo permitirá a los docentes personalizar los criterios de participación,

adaptando la herramienta a las necesidades específicas de su grupo. Aunque los docentes no
tendrán acceso a reportes detallados, podrán observar el ranking de participación y utilizar
esta información para fomentar la participación activa, motivar a los estudiantes y ajustar sus
métodos de enseñanza según lo que observe en el aula.

Este enfoque no solo busca mejorar el rendimiento académico, sino también fortalecer
habilidades blandas cruciales como la autoconfianza, la comunicación y el liderazgo. Al
valorar la participación activa y reconocer el esfuerzo, el software ayudará a los estudiantes
a sentirse más valorados y motivados. De esta manera, se crea un entorno de aprendizaje en
el que todos los estudiantes tienen la oportunidad de brillar, ya sea que sean naturalmente
participativos o necesiten un pequeño empujón para involucrarse más.

6
En última instancia, el objetivo de este módulo es transformar la experiencia educativa,
haciendo del aula un lugar más dinámico y centrado en el estudiante. Al destacar y premiar
la participación activa, el software no solo contribuirá a un aprendizaje más profundo y
significativo, sino que también preparará a los estudiantes para enfrentar los desafíos futuros
con confianza y habilidad, tanto en el ámbito académico como en el personal.

Antecedentes

I.1. Software (Problema y Solución)

Problema

En la enseñanza de programación básica, uno de los mayores desafíos es evaluar de manera

efectiva y completa el progreso y la participación de los estudiantes. Los métodos
tradicionales, como exámenes y tareas, a menudo no reflejan el verdadero compromiso de
los alumnos ni capturan la dinámica diaria del aula. Esto se complica aún más cuando los
docentes necesitan entender quiénes están participando activamente y cómo se comparan el
rendimiento entre diferentes grupos, como hombres y mujeres. Sin una herramienta
adecuada, los docentes pueden tener dificultades para identificar a los estudiantes más
comprometidos y ajustar sus estrategias pedagógicas de manera efectiva.

Además, muchos sistemas actuales no permiten una visión clara de la participación en tiempo
real ni proporcionan un análisis equitativo del rendimiento académico. Esto puede llevar a
una falta de motivación en los estudiantes que no se sienten reconocidos y a desafíos para los
docentes que buscan implementar métodos de enseñanza más inclusivos y efectivos. La
necesidad de un software que combine estas funcionalidades en un sistema fácil de usar es
evidente.

Solución

Para abordar estos desafíos, se propone el desarrollo de un software modular diseñado para
mejorar el seguimiento y la evaluación en la enseñanza de programación básica. Este
software integrará varias características clave para ofrecer una solución completa. En primer
lugar, incluirá un módulo para generar un ranking en tiempo real de los cinco estudiantes con
mayor participación en las preguntas de clase. Este ranking ayudará a destacar a los alumnos

7
más activos y a motivar a todos los estudiantes a involucrarse más en el proceso de
aprendizaje.

El software también contará con una herramienta para calcular y comparar el promedio de
rendimiento académico entre hombres y mujeres, proporcionando a los docentes una visión
clara y equilibrada del progreso de los diferentes grupos. Este análisis permitirá a los docentes
identificar posibles brechas de rendimiento y ajustar sus enfoques de enseñanza para
fomentar una educación más equitativa.

Además, el sistema estará dividido en tres niveles de análisis: un nivel básico que
proporcionará un resumen general de la participación, un nivel intermedio que mostrará el
ranking detallado de los cinco mejores estudiantes, y un nivel avanzado que ofrecerá un
análisis comparativo del rendimiento por género. Este enfoque modular asegura que el
software sea flexible y pueda adaptarse a las necesidades cambiantes del aula.

En resumen, el software no solo ayudará a los docentes a gestionar la participación y el

rendimiento académico de manera más efectiva, sino que también contribuirá a crear un
entorno de aprendizaje más motivador e inclusivo. Al integrar estas funcionalidades,
buscamos transformar la manera en que se evalúa y se fomenta la participación en el aula,
apoyando tanto a estudiantes como a docentes en su camino hacia un aprendizaje más
enriquecedor y justo.

8
I.2. Lista de Requerimientos Funcionales

1. Módulo de Participación Estudiantil en Tiempo Real

El software debe incluir un módulo que capture y registre la participación de los estudiantes
en tiempo real durante las clases.

El módulo debe evaluar cada intervención basándose en criterios predefinidos como la

frecuencia, calidad y relevancia de las respuestas.

Debe permitir la generación de un ranking dinámico que destaque a los cinco estudiantes
con mayor participación, actualizando este ranking continuamente a lo largo de la clase.

2. Sistema de Ranking de Participación

El software debe ofrecer un sistema de ranking que identifique y muestre a los cinco
estudiantes más participativos de manera clara y accesible tanto para los docentes como para
los estudiantes.

El ranking debe ser ajustable en función de los criterios establecidos por el docente,
permitiendo personalizar la forma en que se valora la participación.

3. Herramienta de Análisis Comparativo por Género

El software debe proporcionar una herramienta para calcular y mostrar el promedio de

rendimiento académico entre hombres y mujeres.

Esta herramienta debe permitir al docente comparar de manera equitativa el progreso de los
estudiantes y detectar posibles disparidades en el rendimiento.

9
 La funcionalidad debe incluir opciones para visualizar estadísticas y gráficos que faciliten
la interpretación de los datos.

4. Tres Niveles de Análisis de Participación

El software debe estar diseñado para ofrecer tres niveles de análisis:

1. Nivel Básico: Presentación de un resumen general de la participación de todos los

estudiantes, con estadísticas básicas y tendencias.

2. Nivel Intermedio: Presentación del ranking de los cinco estudiantes más participativos,
con detalles sobre sus intervenciones en la clase.

3. Nivel Avanzado: Análisis comparativo que permita al docente explorar el rendimiento de

grupos específicos, como hombres y mujeres, con visualización de gráficos y tendencias a lo
largo del tiempo.

5. Interfaz de Usuario Intuitiva y Adaptable

El software debe contar con una interfaz de usuario intuitiva y fácil de navegar, diseñada para
ser accesible tanto para docentes como para estudiantes.

Debe permitir la personalización de la interfaz según las necesidades del docente, facilitando
la gestión de la clase y el acceso rápido a las herramientas principales del software.

6. Registro y Almacenamiento de Datos

El software debe ser capaz de registrar y almacenar datos de participación y rendimiento de

los estudiantes, manteniendo un historial que pueda ser consultado en cualquier momento.
El almacenamiento debe ser seguro y proteger la privacidad de los datos de los estudiantes,
cumpliendo con las normativas de protección de datos aplicables.

7. Sistema de Personalización de Criterios de Evaluación

El software debe permitir a los docentes personalizar los criterios de evaluación y

participación, ajustando los pesos y valores según las necesidades específicas de su clase.

Esta personalización debe ser sencilla de configurar y aplicar, asegurando que el sistema se
adapte a diferentes contextos y estilos de enseñanza.

10
8. Actualización y Mantenimiento del Software

El software debe contar con un sistema de actualización automática que permita la

incorporación de nuevas funcionalidades y mejoras sin interrumpir su funcionamiento.

Debe incluir soporte técnico y documentación completa para facilitar su uso y mantenimiento
a largo plazo.

9. Funcionalidad de Notificaciones

El software debe incluir una funcionalidad de notificaciones que informe a los estudiantes
sobre su posición en el ranking y sus niveles de participación.

Las notificaciones deben ser configurables y permitir a los docentes enviar recordatorios o
mensajes motivacionales personalizados a los estudiantes.

11
II. Marco conceptual

1. Estructuras de Control en el Proyecto de Gestión de Estudiantes

1.1. Introducción a las Estructuras de Control

En la programación, las estructuras de control son fundamentales para manejar el flujo de

ejecución del código. Permiten tomar decisiones, ejecutar bloques de código repetidamente
y controlar el flujo del programa según ciertas condiciones. En el contexto de nuestro
proyecto de gestión de estudiantes, estas estructuras de control son esenciales para
implementar la lógica de negocios y garantizar que el software funcione de manera adecuada
en diferentes situaciones.

1.2. Estructuras de Decisión

Las estructuras de decisión permiten que un programa elija entre diferentes opciones
basándose en condiciones específicas. En nuestro proyecto, estas estructuras son utilizadas
para determinar el resultado de las pruebas de los estudiantes y la navegación entre
formularios.

1.2.1. Ejemplo en FrmFinalTest

12
En el formulario FrmFinalTest, se usa una estructura de decisión para evaluar la puntuación
del estudiante y generar un mensaje adecuado. A continuación se muestra cómo se utiliza el
if-else en el método CargarSalida:

Explicación:

if (PunE <= 40): Si la puntuación (PunE) es menor o igual a 40, el mensaje será “FALTA DE
SKILL!”.
else if (PunE >= 60 && PunE <= 80): Si la puntuación está en el rango de 60 a 80, el mensaje
será “NIVEL ACEPTABLE!”.

else: Para cualquier otra puntuación mayor a 80, el mensaje será “NIVEL MARK
ZUCKERBERG”.

Este uso de if-else permite adaptar el mensaje mostrado al usuario según su desempeño en el
test.

1.2.2. Ejemplo en FrmInfo

En el formulario FrmInfo, se utilizan estructuras de decisión para manejar eventos de botones

y realizar búsquedas. Aquí se muestra cómo se utiliza el `if` en el método Buscar para filtrar
los estudiantes por nombre:

13
Explicación:

if ([Link] == 0): Verifica si no hay estudiantes registrados. Si es el caso, muestra un

mensaje y sale del método.

if ([Link] == 0): Verifica si no se encontraron estudiantes que coincidan

con la búsqueda. Si no hay coincidencias, muestra un mensaje informativo.

1.3. Estructuras de Repetición

Las estructuras de repetición permiten ejecutar un bloque de código varias veces. Son
fundamentales para procesar listas de datos, como en la gestión de los estudiantes en el
proyecto.

1.3.1. Ejemplo en FrmInfo

En el formulario FrmInfo, el método MostrarEstudiantes utiliza un bucle for para llenar un

DataGridView con la información de los estudiantes:

14
Explicación:

for (int i = 0; i < Vis; i++)`: Itera sobre todos los estudiantes (Vis es el número de estudiantes).

Dentro del bucle, se asignan los valores de cada estudiante a las celdas correspondientes del
`DataGridView.

1.3.2. Ejemplo en FrmFinalTest

En FrmFinalTest, el bucle for también puede ser utilizado para actualizar datos si se
necesitara iterar sobre múltiples elementos en una versión extendida del software.

1.4. Estructuras de Control de Flujo Adicionales

Además de las estructuras básicas, existen estructuras adicionales que permiten un control
más fino sobre el flujo del programa.

1.4.1. Ejemplo en FrmInfo

15
En el método MostrarBusqueda, se utiliza [Link]() para limpiar el DataGridView antes
de mostrar los resultados de una búsqueda:

Explicación:

[Link](): Limpia las filas existentes en el DataGridView antes de mostrar nuevos

datos.

Utiliza el operador ?? para determinar si se deben mostrar los estudiantes filtrados o todos
los estudiantes.

1.5. Aplicación Práctica de las Estructuras de Control

En el desarrollo de tu software, las estructuras de control son cruciales para implementar la

lógica de negocio. Aseguran que el programa pueda manejar diferentes escenarios, desde la
presentación de resultados de pruebas hasta la navegación entre formularios y la gestión de
datos.

Navegación entre Formularios: En FrmFinalTest, la estructura de control if en el evento

button1_Click permite determinar si se debe actualizar el formulario principal y luego ocultar
el formulario actual:

16
Procesamiento de Datos En FrmInfo, el uso de for para iterar sobre los estudiantes y
actualizar el DataGridView muestra cómo las estructuras de repetición manejan la
visualización de datos.

Programación Modular en el Proyecto

La programación modular es una técnica fundamental en la ingeniería de software que

promueve la organización del código en unidades independientes, llamadas módulos. Estos
módulos son funciones, procedimientos o clases que tienen una responsabilidad específica y
que interactúan entre sí para formar un sistema completo. A continuación, se muestran
ejemplos de cómo se implementa la modularidad en nuestro proyecto.

17
 1. Constructor de Formulario FrmInfo

Explicación:

Este constructor forma parte de la modularidad al encapsular la lógica de inicialización de un

formulario específico (`FrmInfo`). Al recibir como parámetros un array de estudiantes y el
número de visitas, el constructor se asegura de que cada instancia del formulario pueda operar
con datos específicos. Esto permite que `FrmInfo` sea reutilizable en diferentes contextos
dentro de la aplicación, lo que reduce la duplicación de código y facilita el mantenimiento.

2. Método MostrarEstudiantes en FrmInfo

18
Explicación:

Este método es un ejemplo claro de programación modular. `MostrarEstudiantes` tiene la

única responsabilidad de poblar un `DataGridView` con la información de los estudiantes. Al
mantener esta funcionalidad dentro de un método separado, el código es más legible y fácil
de depurar. Además, si en el futuro se requiere modificar cómo se muestran los estudiantes,
solo se necesita ajustar este método, sin afectar otras partes del código.

3. Método Buscar en FrmInfo

Explicación:
El método Buscar es modular porque encapsula la lógica de búsqueda de estudiantes en
función de un nombre dado. Este enfoque permite que la funcionalidad de búsqueda sea

19
aislada, lo que facilita su prueba y reutilización en otros formularios o partes de la aplicación.
La llamada al método MostrarBusqueda al final también muestra cómo los módulos
interactúan entre sí, proporcionando una salida coherente basada en la búsqueda realizada.

4. Método CargarSalida en FrmFinalTest

Explicación:

CargarSalida es un método que ilustra la modularidad al encapsular la lógica de evaluación

del puntaje de un estudiante en función de su rendimiento. Este método se puede invocar en
cualquier parte del código donde se necesite esta evaluación, lo que lo hace reutilizable y
fácil de actualizar si las reglas de evaluación cambian.

5. Evento button3_Click en FrmInfo

Explicación:

20
Este evento modulariza la interacción con otro formulario (FrmTeam). Al mantener la
creación y presentación de FrmTeam dentro de un método de evento específico, se sigue el
principio de responsabilidad única. Si la lógica para abrir `FrmTeam` cambia, solo será
necesario modificar este método, evitando impactos en otras partes de la aplicación.

21
Manipulación de Cadenas de Caracteres en el Proyecto

Las cadenas de caracteres son secuencias de caracteres utilizadas comúnmente para

representar texto en un programa. En C#, las cadenas (string) son objetos inmutables, lo que
significa que no se pueden modificar una vez creadas; cualquier operación que parezca
modificar una cadena en realidad crea una nueva cadena. A continuación, se presentan
ejemplos de cómo se manejan las cadenas de caracteres en nuestro proyecto.

1. Concatenación de Cadenas en FrmFinalTest

Explicación:

En este ejemplo, se realiza la concatenación de cadenas para formar mensajes que contienen
información sobre el estudiante, el modo de test, el tiempo y el resultado final. En C#, la
concatenación se realiza utilizando el operador `+`. A pesar de su simplicidad, este método
de concatenación es eficiente para unir un pequeño número de cadenas, como se muestra
aquí. Sin embargo, para operaciones más intensivas, se podrían considerar otras técnicas,
como el uso de StringBuilder, que es más eficiente en situaciones donde se requiere
manipular cadenas repetidamente.

2. Búsqueda de Subcadenas en FrmInfo

22
Explicación:

Aquí, el método Contains se utiliza para buscar subcadenas dentro de los nombres de los
estudiantes. Este método es parte de la clase `string` y devuelve un valor booleano (`true` o
`false`) dependiendo de si la subcadena especificada (en este caso, `nombreBuscar`) se
encuentra dentro de otra cadena ([Link]). Esta operación es común cuando se necesita
filtrar o buscar texto dentro de un conjunto de datos. Convertir las cadenas a minúsculas
(`ToLower`) garantiza que la búsqueda sea insensible a mayúsculas.

3. Manipulación de Cadenas en FrmInfo

Explicación:

En esta línea de código, se utilizan los métodos Trim y ToLower para manipular la cadena de
caracteres. Trim elimina los espacios en blanco al principio y al final de la cadena, lo que es
útil para limpiar el input del usuario antes de procesarlo. ToLower convierte todos los
caracteres de la cadena a minúsculas, lo que ayuda a realizar comparaciones insensibles a
mayúsculas y minúsculas. Estos métodos son ejemplos de cómo se pueden preparar y
manipular cadenas para cumplir con los requisitos de procesamiento específicos.

4. Conversión de Números a Cadenas en FrmFinalTest

23
Explicación:

La conversión de un valor numérico a una cadena de caracteres se realiza aquí con el método
[Link](). Este método es útil cuando se necesita representar valores numéricos
como texto, por ejemplo, al mostrarlos en controles de UI como etiquetas o cuadros de texto.
Es una forma directa y sencilla de asegurar que el valor se convierte correctamente a una
cadena, manteniendo la legibilidad del código.

5. Generación de Mensajes Dinámicos en CargarSalida

Explicación:

Este método genera mensajes dinámicos basados en la puntuación (`PunE`) del estudiante.
La cadena SalFin se actualiza con diferentes mensajes dependiendo del valor de la
puntuación. Este tipo de manipulación es común en aplicaciones donde es necesario
proporcionar retroalimentación o resultados personalizados basados en las entradas del
usuario. Los mensajes se almacenan como cadenas y se devuelven al llamador para que sean
utilizados en la interfaz de usuario.

24
Programación con Estructuras Unidimensionales

Ejemplo 1: Declaración y Uso de Arreglo en FrmInfo

Explicación:

En este ejemplo, `obj` es un arreglo unidimensional de tipo TEstudiant. El propósito del

arreglo es almacenar la información de múltiples estudiantes, lo que permite gestionar y
manipular esta información en el formulario `FrmInfo`. Al utilizar un arreglo, el formulario
puede fácilmente recorrer, buscar y mostrar datos relacionados con cada estudiante en
diversas partes de la interfaz.

Concepto Clave:
El uso de arreglos unidimensionales permite la agrupación de elementos relacionados bajo
una sola variable. Esto es útil para manejar colecciones de datos homogéneos como la lista
de estudiantes en este caso.

25
Ejemplo 2: Iteración sobre un Arreglo en MostrarEstudiantes

Explicación:

Este código muestra cómo recorrer un arreglo unidimensional para llenar un `DataGridView`
con la información de los estudiantes. El bucle `for` permite acceder secuencialmente a cada
elemento del arreglo `obj`, utilizando el índice `i`. Cada propiedad del objeto `TEstudiante`
(como `Nombre`, `Genero`, etc.) se asigna a una celda específica del `DataGridView`.

Concepto Clave:

Las estructuras unidimensionales como los arreglos permiten el almacenamiento y acceso

secuencial de datos, facilitando operaciones como la iteración a través de bucles para mostrar
o procesar la información almacenada.

Ejemplo 3: Filtrado de Arreglo en Buscar

Explicación:

26
En este ejemplo, se realiza una operación de filtrado sobre el arreglo `obj` utilizando LINQ.
La función Where filtra los elementos del arreglo que contienen el texto de búsqueda en la
propiedad Nombre. El resultado se almacena en un nuevo arreglo `estudiantesFiltrados`, que
contiene solo los estudiantes que coinciden con el criterio de búsqueda.

Concepto Clave:

El filtrado de arreglos permite extraer subconjuntos de datos que cumplen con condiciones
específicas, lo cual es fundamental en aplicaciones que requieren búsqueda y clasificación
de información.

27
II. Desarrollo

II.1 Interface de usuario

Diseño Intuitivo y Accesible: En el desarrollo de tu software, la interfaz de usuario ha sido

diseñada para facilitar una interacción intuitiva. La disposición clara de los elementos en los
formularios, como FrmFinalTest y FrmInfo, permite a los usuarios acceder fácilmente a la
información y realizar acciones sin confusión. La organización de botones, cuadros de texto
y etiquetas sigue principios de usabilidad, asegurando que los usuarios puedan navegar por
la aplicación de manera eficiente.

28
Consistencia en la Experiencia del Usuario: Se ha mantenido una consistencia visual en
todos los formularios del proyecto, desde FrmHome hasta FrmTeam. Esta consistencia en el
uso de colores, fuentes y estilos de botones ayuda a los usuarios a familiarizarse
rápidamente con la aplicación, reduciendo el tiempo necesario para adaptarse a nuevas
funciones y aumentando la eficiencia en el uso del software.

29
Interacción Clara y Efectiva: La interacción entre el usuario y la aplicación está diseñada
para ser clara y efectiva. Por ejemplo, en el formulario FrmFinalTest, los controles como los
botones de “Regresar” y “Actualizar Estadísticas” tienen acciones bien definidas y
proporcionan retroalimentación inmediata. Esto asegura que los usuarios puedan realizar sus
tareas sin enfrentar problemas o malentendidos.

30
Consideraciones de Usabilidad: Los elementos de la interfaz, como los botones para buscar
y actualizar en FrmInfo, están diseñados para ser accesibles y funcionales. Sin embargo, sería
beneficioso considerar una retroalimentación más detallada para acciones específicas, como
confirmaciones al realizar búsquedas o actualizaciones, para mejorar aún más la experiencia
del usuario.

31
Manejo de Datos y Resultados: La interfaz de usuario también se encarga de presentar datos
de manera comprensible. En FrmInfo, el DataGridView se utiliza para mostrar la información
de los estudiantes de manera ordenada. La capacidad de buscar y filtrar datos directamente
desde la interfaz facilita la gestión de grandes volúmenes de información, mejorando la
eficiencia del usuario en el manejo de datos.

Adaptación a Necesidades Específicas: La interfaz está adaptada para cumplir con las
necesidades específicas del proyecto, como la gestión de inventarios y la evaluación del
rendimiento de los estudiantes. Esto demuestra que la interfaz no solo es visualmente
atractiva, sino también funcional y adaptada a los requisitos del usuario final.

32
Código fuente por formulario:

Using System;

Using [Link];

Using [Link];

Using [Link];
Using [Link];

Namespace FINAL_24

Public partial class fmrHome : Form

// Estructura para almacenar la información de cada estudiante

Public struct TEstudiante

33
 {

Public string Nombre; // Nombre del estudiante

Public string Genero; // Género del estudiante

Public string Modo; // Modo del test tomado (Fácil, Normal, Difícil, Completo)

Public int Puntaje; // Puntaje obtenido en el test

Public string Tiempo; // Tiempo que tomó completar el test

Public DateTime FechaHora; // Fecha y hora cuando se tomó el test

TEstudiante[] VEstudiante = new TEstudiante[100]; // Arreglo para almacenar hasta 100

estudiantes

Public int Vis = 0; // Contador de cuántos estudiantes hay

Public fmrHome()
{

InitializeComponent();

// Cuando se carga el formulario, no hacemos nada por ahora.

Private void fmrHome_Load(object sender, EventArgs e) { }

// Al hacer clic en el botón “Ingresar”, se ejecuta este código.

Private void button2_Click(object sender, EventArgs e)

Ingresar();

34
// Este método maneja lo que pasa cuando el usuario quiere ingresar al cuestionario.

Private void Ingresar()

String Genero = “”;

String Modo = “”;

// Verificamos que el campo del nombre no esté vacío.

If ([Link]([Link]))

[Link](“Por favor escriba su nombre”);

Else

// Determinar el género seleccionado (Hombre o Mujer).

If ([Link])

Genero = “Hombre”;

Else
{

Genero = “Mujer”;

// Determinar el modo seleccionado (Fácil, Normal, Difícil o Completo).

If ([Link])

{
Modo = “Facil”;

35
 }

Else if ([Link])

Modo = “Normal”;

Else

Modo = “Dificil”;

// Mostrar el formulario de preguntas con los datos del usuario.

FrmQuiz Obj = new FrmQuiz(VEstudiante, Vis, [Link], Genero, Modo);

[Link](); // Muestra la ventana de preguntas.

}
}

Private void button3_Click(object sender, EventArgs e)

FrmTeam Obj = new FrmTeam();

[Link]();

Private void button1_Click(object sender, EventArgs e)

[Link]();

36
 Public void ActualizarEstadisticas()

Int totalParticipantes = 0;

Int promedioGeneral = 0, promedioHombres = 0, promedioMujeres = 0;

String modoSeleccionado = “Facil”;

// Determinar el modo seleccionado basado en los RadioButtons

If ([Link])

modoSeleccionado = “Facil”;

Else if ([Link])

{
modoSeleccionado = “Normal”;

Else if ([Link])

modoSeleccionado = “Dificil”;
}

// Filtrar los estudiantes que tomaron el test en el modo seleccionado y ordenarlos por
puntaje

Var top5 = VEstudiante

.Where(p => [Link] == modoSeleccionado)

.OrderByDescending(p => [Link])

.ThenBy(p => [Link]([Link])) // Desempatar por tiempo (menor es

mejor)

37
 .Take(5)

.ToArray();

// Asignar los valores de los primeros cinco estudiantes al cuadro de estadísticas

If ([Link] > 0)

[Link] = top5[0].Nombre;

[Link] = top5[0].[Link]();

Else

[Link] = “-“;

[Link] = “-“;

If ([Link] > 1)

[Link] = top5[1].Nombre;

[Link] = top5[1].[Link]();
}

Else

[Link] = “-“;

[Link] = “-“;

If ([Link] > 2)

38
{

[Link] = top5[2].Nombre;

[Link] = top5[2].[Link]();

Else

[Link] = “-“;

[Link] = “-“;

If ([Link] > 3)

[Link] = top5[3].Nombre;

[Link] = top5[3].[Link]();
}

Else

[Link] = “-“;

[Link] = “-“;
}

If ([Link] > 4)

[Link] = top5[4].Nombre;

[Link] = top5[4].[Link]();

}
Else

39
 {

[Link] = “-“;

[Link] = “-“;

// Mostrar una imagen aleatoria si hay estudiantes en la lista

If ([Link] > 0)

MostrarImagenAleatoria();

Else

[Link] = null;

// Calcular las estadísticas generales

CalcularEstadisticas(out totalParticipantes, out promedioGeneral, out

promedioHombres, out promedioMujeres);

// Mostramos las estadísticas generales (total de participantes, promedio general, etc.).

[Link] = [Link]();

[Link] = [Link]();

[Link] = [Link]();

[Link] = [Link]();

Private void pictureBox4_Click(object sender, EventArgs e) { }

40
 Private void button6_Click(object sender, EventArgs e)

FrmInfo Obj = new FrmInfo(VEstudiante, Vis);

[Link]();

Private void Gym_Click(object sender, EventArgs e)

FrmGym Obj = new FrmGym();

[Link]();

Public void CalcularEstadisticas(out int totalParticipantes, out int promedioGeneral, out

int promedioHombres, out int promedioMujeres)

// Inicializamos variables para acumular los puntajes y contar participantes por género

Int totalPuntos = 0;

Int totalPuntosHombres = 0;

Int totalPuntosMujeres = 0;
Int contadorHombres = 0;

Int contadorMujeres = 0;

// Iteramos sobre todos los estudiantes registrados

For (int i = 0; i <= Vis; i++)

// Sumamos el puntaje total

41
 totalPuntos += VEstudiante[i].Puntaje;

// Dependiendo del género, sumamos el puntaje a la categoría correspondiente

If (VEstudiante[i].Genero == “Hombre”)

totalPuntosHombres += VEstudiante[i].Puntaje;

contadorHombres++;

Else if (VEstudiante[i].Genero == “Mujer”)

totalPuntosMujeres += VEstudiante[i].Puntaje;

contadorMujeres++;

// Calculamos el total de participantes, que es el número de entradas válidas en el

arreglo

totalParticipantes = Vis;

// Calculamos el promedio general de puntajes, asegurándonos de no dividir por cero

If (totalParticipantes > 0)

promedioGeneral = totalPuntos / totalParticipantes;

Else

promedioGeneral = 0;

42
 }

// Calculamos el promedio de puntajes para hombres y mujeres, asegurándonos de no

dividir por cero

If (contadorHombres > 0)

promedioHombres = totalPuntosHombres / contadorHombres;

Else

promedioHombres = 0;

If (contadorMujeres > 0)
{

promedioMujeres = totalPuntosMujeres / contadorMujeres;

Else

promedioMujeres = 0;
}

Private void MostrarImagenAleatoria()

// Ruta relativa a la carpeta “Imágenes”

String rutaCarpeta = @”Imágenes”;

43
 // Obtener todas las rutas de las imágenes en la carpeta

String[] archivosImagen = [Link](rutaCarpeta, “*.jpeg”);

// Verificar si hay imágenes en la carpeta

If ([Link] > 0)

// Seleccionar aleatoriamente una imagen

Random random = new Random();

Int indiceAleatorio = [Link]([Link]);

String imagenSeleccionada = archivosImagen[indiceAleatorio];

// Cargar la imagen en el PictureBox

[Link] = [Link](imagenSeleccionada);
}

Else

// Si no hay imágenes, limpiar el PictureBox.

[Link] = null;
}

Private void OpRank1_CheckedChanged(object sender, EventArgs e)

// Actualizar las estadísticas cuando se selecciona el primer modo de ranking

ActualizarEstadisticas();
}

44
 Private void OpRank2_CheckedChanged(object sender, EventArgs e)

// Actualizar las estadísticas cuando se selecciona el segundo modo de ranking

ActualizarEstadisticas();

Private void OpRank3_CheckedChanged(object sender, EventArgs e)

// Actualizar las estadísticas cuando se selecciona el tercer modo de ranking

ActualizarEstadisticas();

Formulario 2

Using System;

45
Using [Link];

Using WMPLib;

Using [Link];

Namespace FINAL_24

Public partial class FrmQuiz : Form

// Estructura para almacenar preguntas y respuestas del test

Struct TPreguntas

Public string Pregunta; // Texto de la pregunta

Public bool Respuesta; // Respuesta correcta (true para Verdadero, false para Falso)

TPreguntas[] VPregFac;

TPreguntas[] VPregNor;

TPreguntas[] VPregDif;

[Link][] obj; // Instancia de la clase CTest para manejar la información

del test
string NomE, GenE, ModE; // Variables para almacenar el nombre, género y modo del
test

int puntaje, conP, puntosRespuesta, Vis; // Variables para puntaje, conteo de preguntas
y puntos por respuesta

string TieE; // Variable para almacenar el tiempo final

DateTime FecE;

Private int TieTrans;

46
 Private Timer timer; // Temporizador

// Constructor del formulario que inicializa las variables

Public FrmQuiz([Link][] objEst, int Visit, string Nom, string Gen, string
Mod)

InitializeComponent();

Obj = objEst; // Inicializa la instancia de CTest

Vis = Visit;

NomE = Nom; // Nombre del estudiante

GenE = Gen; // Género del estudiante

ModE = Mod; // Modo del test

conP = 0; // Inicializa el conteo de preguntas

puntaje = 0; // Inicializa el puntaje

puntosRespuesta = 0; // Inicializa los puntos por respuesta

// Inicialización del temporizador

Timer = new Timer();

[Link] = 1000; // Intervalo de 1 segundo

[Link] += timer1_Tick; // Asocia el evento Tick del temporizador al método

timer1_Tick

// Arreglos para almacenar las preguntas de los distintos niveles de dificultad

VPregFac = new TPreguntas[5]; // Preguntas para el modo Fácil

VPregNor = new TPreguntas[5]; // Preguntas para el modo Normal

VPregDif = new TPreguntas[5]; // Preguntas para el modo Difícil

// Inicialización de preguntas para el modo Fácil

47
 VPregFac[0].Pregunta = “En C#, los tipos de datos primitivos son objetos. (Falso)”;

VPregFac[0].Respuesta = false;

VPregFac[1].Pregunta = “El operador ‘&&’ en C# significa ‘O lógico’. (Falso)”;

VPregFac[1].Respuesta = false;

VPregFac[2].Pregunta = “Un método en C# puede devolver múltiples valores.

(Falso)”;

VPregFac[2].Respuesta = false;

VPregFac[3].Pregunta = “En C#, un ‘class’ puede ser instanciado. (Verdadero)”;

VPregFac[3].Respuesta = true;

VPregFac[4].Pregunta = “En C#, la palabra clave ‘public’ significa que el miembro

\n es accesible desde cualquier lugar. (Verdadero)”;

VPregFac[4].Respuesta = true;

// Inicialización de preguntas para el modo Normal

VPregNor[0].Pregunta = “Los ‘struct’ en C# son tipos de referencia. (Falso)”;

VPregNor[0].Respuesta = false;

VPregNor[1].Pregunta = “En C#, un ‘interface’ puede contener implementaciones de

métodos.\n (Falso)”;

VPregNor[1].Respuesta = false;

VPregNor[2].Pregunta = “Los ‘enum’ en C# pueden tener valores de tipo ‘double’.

(Falso)”;
VPregNor[2].Respuesta = false;

VPregNor[3].Pregunta = “El modificador ‘static’ en un método indica que el

método\n pertenece a la instancia de la clase. (Falso)”;

VPregNor[3].Respuesta = false;

VPregNor[4].Pregunta = “Un ‘delegate’ en C# es un tipo que representa referencias\n

a métodos. (Verdadero)”;

VPregNor[4].Respuesta = true;

48
 // Inicialización de preguntas para el modo Difícil

VPregDif[0].Pregunta = “La palabra clave ‘abstract’ se utiliza para declarar una

clase\n que puede ser instanciada. (Falso)”;

VPregDif[0].Respuesta = false;

VPregDif[1].Pregunta = “Los métodos en una clase abstracta pueden ser

implementados\n directamente. (Falso)”;

VPregDif[1].Respuesta = false;

VPregDif[2].Pregunta = “En C#, una clase puede heredar de múltiples clases.

(Falso)”;

VPregDif[2].Respuesta = false;

VPregDif[3].Pregunta = “El operador ‘is’ en C# verifica el tipo de una instancia.

(Verdadero)”;

VPregDif[3].Respuesta = true;

VPregDif[4].Pregunta = “En C#, los métodos estáticos no pueden ser sobrecargados.

(Falso)”;

VPregDif[4].Respuesta = false;

// Evento que se ejecuta cuando se carga el formulario

Private void FrmQuiz_Load(object sender, EventArgs e)

{
// Inicializa los controles con los datos proporcionados

[Link] = NomE;

[Link] = [Link](conP + 1);

[Link] = ObtenerPregunta(conP, ModE);

[Link] = [Link](puntaje);

puntosRespuesta = 20;

// Inicia el temporizador con el tiempo límite

49
 [Link] = [Link](TieTrans).ToString(@”mm\:ss”);

[Link](); // Comienza el temporizador

// Método que se ejecuta cada vez que el temporizador hace “tick” (cada segundo)

Private void timer1_Tick(object sender, EventArgs e)

TieTrans++;

[Link] = [Link](TieTrans).ToString(@”mm\:ss”);

// Evento que se ejecuta al hacer clic en el botón para pasar a la siguiente pregunta

Private void btnSigPre_Click(object sender, EventArgs e)

{
// Verifica si se ha seleccionado una respuesta

If ([Link] == false && [Link] == false)

[Link](“Debe seleccionar una respuesta.”);

}
Else

// Valida la respuesta y actualiza el puntaje

Bool respuestaUsu = [Link];

Bool respuestaCorrecta;

If (ModE == “Facil”)
{

50
 respuestaCorrecta = VPregFac[conP].Respuesta;

Else

If (ModE == “Normal”)

respuestaCorrecta = VPregNor[conP].Respuesta;

Else

respuestaCorrecta = VPregDif[conP].Respuesta;

If (respuestaUsu == respuestaCorrecta)

Puntaje += puntosRespuesta;

ReproducirSonidoCorrecto();

}
Else

ReproducirSonidoIncorrecto();

// Avanza a la siguiente pregunta o finaliza el test si es la última pregunta

If (conP < 4)
{

51
 [Link] = [Link](puntaje);

conP += 1;

[Link] = [Link](conP + 1);

[Link] = ObtenerPregunta(conP, ModE);

[Link] = false;

[Link] = false;

Else

If (respuestaUsu == respuestaCorrecta)

ReproducirSonidoCorrecto();

Else
{

ReproducirSonidoIncorrecto();

FinalizarTest(); // Llama al método para finalizar el test

}
}

// Método para finalizar el test

Private void FinalizarTest()

[Link]();
TieE = [Link]; // Guarda el tiempo final

52
 FecE = [Link];

GuardarTest(NomE, GenE, ModE, puntaje, TieE, FecE); // Guarda los resultados del
test

// Muestra el formulario de resultados finales

FrmFinalTest ObjFin = new FrmFinalTest(obj, Vis, NomE, ModE, puntaje, TieE);

[Link]();

[Link]();

// Métodos para eventos no implementados (pueden eliminarse si no son necesarios)

Private void button1_Click(object sender, EventArgs e) { }

Private void Nombre_Click(object sender, EventArgs e) { }

Private void btn_team_Click(object sender, EventArgs e) { }

Private void radioButton2_CheckedChanged(object sender, EventArgs e) { }

Private void btn_gr_Click(object sender, EventArgs e) { }

Private void button1_Click_1(object sender, EventArgs e)

[Link]();
}

Private void btn_2_CheckedChanged(object sender, EventArgs e) { }

Private void label1_Click(object sender, EventArgs e) { }

Private void pictureBox1_Click(object sender, EventArgs e) { }

Public string ObtenerPregunta(int index, string modo)

53
 {

If (modo == “Facil”)

Return VPregFac[index].Pregunta; // Obtener pregunta del modo Fácil

Else

If (modo == “Normal”)

Return VPregNor[index].Pregunta; // Obtener pregunta del modo Normal

Else

Return VPregDif[index].Pregunta; // Obtener pregunta del modo Difícil

}

// Método para guardar los datos del test de un estudiante

Public void GuardarTest(string Nom, string Gen, string Mod, int Pun, string Tie,
DateTime Fec)

If (Vis < [Link] – 1)

Obj[Vis].Nombre = Nom;

Obj[Vis].Genero = Gen;

Obj[Vis].Modo = Mod;

54
 Obj[Vis].Puntaje = Pun;

Obj[Vis].Tiempo = Tie;

Obj[Vis].FechaHora = Fec;

Vis++;

Else

[Link](“No hay más espacio para almacenar estudiantes.”);

Private void ReproducirSonidoCorrecto()

WindowsMediaPlayer player = new WindowsMediaPlayer();

[Link] = “Sonidos/Correcto.mp3”;

[Link]();

Private void ReproducirSonidoIncorrecto()

{

WindowsMediaPlayer player = new WindowsMediaPlayer();

[Link] = “Sonidos/Incorrecto.mp3”;

[Link]();

55
Formulario 3

Using System;

Using [Link];

Using WMPLib;

Using [Link];

Namespace FINAL_24

{
Public partial class FrmQuiz : Form

56
 {

// Estructura para almacenar preguntas y respuestas del test

Struct TPreguntas

Public string Pregunta; // Texto de la pregunta

Public bool Respuesta; // Respuesta correcta (true para Verdadero, false para Falso)

TPreguntas[] VPregFac;

TPreguntas[] VPregNor;

TPreguntas[] VPregDif;

[Link][] obj; // Instancia de la clase CTest para manejar la información

del test

string NomE, GenE, ModE; // Variables para almacenar el nombre, género y modo del
test

int puntaje, conP, puntosRespuesta, Vis; // Variables para puntaje, conteo de preguntas
y puntos por respuesta

string TieE; // Variable para almacenar el tiempo final

DateTime FecE;

Private int TieTrans;

Private Timer timer; // Temporizador

// Constructor del formulario que inicializa las variables

Public FrmQuiz([Link][] objEst, int Visit, string Nom, string Gen, string
Mod)

InitializeComponent();

57
 Obj = objEst; // Inicializa la instancia de CTest

Vis = Visit;

NomE = Nom; // Nombre del estudiante

GenE = Gen; // Género del estudiante

ModE = Mod; // Modo del test

conP = 0; // Inicializa el conteo de preguntas

puntaje = 0; // Inicializa el puntaje

puntosRespuesta = 0; // Inicializa los puntos por respuesta

// Inicialización del temporizador

Timer = new Timer();

[Link] = 1000; // Intervalo de 1 segundo

[Link] += timer1_Tick; // Asocia el evento Tick del temporizador al método

timer1_Tick

// Arreglos para almacenar las preguntas de los distintos niveles de dificultad

VPregFac = new TPreguntas[5]; // Preguntas para el modo Fácil

VPregNor = new TPreguntas[5]; // Preguntas para el modo Normal

VPregDif = new TPreguntas[5]; // Preguntas para el modo Difícil

// Inicialización de preguntas para el modo Fácil

VPregFac[0].Pregunta = “En C#, los tipos de datos primitivos son objetos. (Falso)”;

VPregFac[0].Respuesta = false;

VPregFac[1].Pregunta = “El operador ‘&&’ en C# significa ‘O lógico’. (Falso)”;

VPregFac[1].Respuesta = false;

VPregFac[2].Pregunta = “Un método en C# puede devolver múltiples valores.

(Falso)”;

VPregFac[2].Respuesta = false;

58
 VPregFac[3].Pregunta = “En C#, un ‘class’ puede ser instanciado. (Verdadero)”;

VPregFac[3].Respuesta = true;

VPregFac[4].Pregunta = “En C#, la palabra clave ‘public’ significa que el miembro

\n es accesible desde cualquier lugar. (Verdadero)”;

VPregFac[4].Respuesta = true;

// Inicialización de preguntas para el modo Normal

VPregNor[0].Pregunta = “Los ‘struct’ en C# son tipos de referencia. (Falso)”;

VPregNor[0].Respuesta = false;

VPregNor[1].Pregunta = “En C#, un ‘interface’ puede contener implementaciones de

métodos.\n (Falso)”;

VPregNor[1].Respuesta = false;

VPregNor[2].Pregunta = “Los ‘enum’ en C# pueden tener valores de tipo ‘double’.

(Falso)”;
VPregNor[2].Respuesta = false;

VPregNor[3].Pregunta = “El modificador ‘static’ en un método indica que el

método\n pertenece a la instancia de la clase. (Falso)”;

VPregNor[3].Respuesta = false;

VPregNor[4].Pregunta = “Un ‘delegate’ en C# es un tipo que representa referencias\n

a métodos. (Verdadero)”;

VPregNor[4].Respuesta = true;

// Inicialización de preguntas para el modo Difícil

VPregDif[0].Pregunta = “La palabra clave ‘abstract’ se utiliza para declarar una

clase\n que puede ser instanciada. (Falso)”;

VPregDif[0].Respuesta = false;

VPregDif[1].Pregunta = “Los métodos en una clase abstracta pueden ser

implementados\n directamente. (Falso)”;

VPregDif[1].Respuesta = false;

59
 VPregDif[2].Pregunta = “En C#, una clase puede heredar de múltiples clases.
(Falso)”;

VPregDif[2].Respuesta = false;

VPregDif[3].Pregunta = “El operador ‘is’ en C# verifica el tipo de una instancia.

(Verdadero)”;

VPregDif[3].Respuesta = true;

VPregDif[4].Pregunta = “En C#, los métodos estáticos no pueden ser sobrecargados.

(Falso)”;

VPregDif[4].Respuesta = false;

// Evento que se ejecuta cuando se carga el formulario

Private void FrmQuiz_Load(object sender, EventArgs e)

{
// Inicializa los controles con los datos proporcionados

[Link] = NomE;

[Link] = [Link](conP + 1);

[Link] = ObtenerPregunta(conP, ModE);

[Link] = [Link](puntaje);

puntosRespuesta = 20;

// Inicia el temporizador con el tiempo límite

[Link] = [Link](TieTrans).ToString(@”mm\:ss”);

[Link](); // Comienza el temporizador

// Método que se ejecuta cada vez que el temporizador hace “tick” (cada segundo)
Private void timer1_Tick(object sender, EventArgs e)

60
{

TieTrans++;

[Link] = [Link](TieTrans).ToString(@”mm\:ss”);

// Evento que se ejecuta al hacer clic en el botón para pasar a la siguiente pregunta

Private void btnSigPre_Click(object sender, EventArgs e)

// Verifica si se ha seleccionado una respuesta

If ([Link] == false && [Link] == false)

[Link](“Debe seleccionar una respuesta.”);

Else
{

// Valida la respuesta y actualiza el puntaje

Bool respuestaUsu = [Link];

Bool respuestaCorrecta;

If (ModE == “Facil”)

respuestaCorrecta = VPregFac[conP].Respuesta;

Else

If (ModE == “Normal”)
{

61
 respuestaCorrecta = VPregNor[conP].Respuesta;

Else

respuestaCorrecta = VPregDif[conP].Respuesta;

If (respuestaUsu == respuestaCorrecta)

Puntaje += puntosRespuesta;

ReproducirSonidoCorrecto();

Else
{

ReproducirSonidoIncorrecto();

// Avanza a la siguiente pregunta o finaliza el test si es la última pregunta

If (conP < 4)

[Link] = [Link](puntaje);

conP += 1;

[Link] = [Link](conP + 1);

[Link] = ObtenerPregunta(conP, ModE);

[Link] = false;
[Link] = false;

62
 }

Else

If (respuestaUsu == respuestaCorrecta)

ReproducirSonidoCorrecto();

Else

ReproducirSonidoIncorrecto();

FinalizarTest(); // Llama al método para finalizar el test

}
}

// Método para finalizar el test

Private void FinalizarTest()

{
[Link]();

TieE = [Link]; // Guarda el tiempo final

FecE = [Link];

GuardarTest(NomE, GenE, ModE, puntaje, TieE, FecE); // Guarda los resultados del
test

// Muestra el formulario de resultados finales

FrmFinalTest ObjFin = new FrmFinalTest(obj, Vis, NomE, ModE, puntaje, TieE);

63
 [Link]();

[Link]();

// Métodos para eventos no implementados (pueden eliminarse si no son necesarios)

Private void button1_Click(object sender, EventArgs e) { }

Private void Nombre_Click(object sender, EventArgs e) { }

Private void btn_team_Click(object sender, EventArgs e) { }

Private void radioButton2_CheckedChanged(object sender, EventArgs e) { }

Private void btn_gr_Click(object sender, EventArgs e) { }

Private void button1_Click_1(object sender, EventArgs e)

[Link]();
}

Private void btn_2_CheckedChanged(object sender, EventArgs e) { }

Private void label1_Click(object sender, EventArgs e) { }

Private void pictureBox1_Click(object sender, EventArgs e) { }

Public string ObtenerPregunta(int index, string modo)

If (modo == “Facil”)

Return VPregFac[index].Pregunta; // Obtener pregunta del modo Fácil

}
Else

64
 {

If (modo == “Normal”)

Return VPregNor[index].Pregunta; // Obtener pregunta del modo Normal

Else

Return VPregDif[index].Pregunta; // Obtener pregunta del modo Difícil

// Método para guardar los datos del test de un estudiante

Public void GuardarTest(string Nom, string Gen, string Mod, int Pun, string Tie,
DateTime Fec)

If (Vis < [Link] – 1)

Obj[Vis].Nombre = Nom;

Obj[Vis].Genero = Gen;
Obj[Vis].Modo = Mod;

Obj[Vis].Puntaje = Pun;

Obj[Vis].Tiempo = Tie;

Obj[Vis].FechaHora = Fec;

Vis++;

Else

65
 {

[Link](“No hay más espacio para almacenar estudiantes.”);

Private void ReproducirSonidoCorrecto()

WindowsMediaPlayer player = new WindowsMediaPlayer();

[Link] = “Sonidos/Correcto.mp3”;

[Link]();

Private void ReproducirSonidoIncorrecto()

{
WindowsMediaPlayer player = new WindowsMediaPlayer();

[Link] = “Sonidos/Incorrecto.mp3”;

[Link]();

}
}

66
Formulario 4

Using System;

Using [Link];

Using WMPLib;

Using [Link];

Namespace FINAL_24
{

Public partial class FrmQuiz : Form

// Estructura para almacenar preguntas y respuestas del test

Struct TPreguntas

Public string Pregunta; // Texto de la pregunta

Public bool Respuesta; // Respuesta correcta (true para Verdadero, false para Falso)

67
 }

TPreguntas[] VPregFac;

TPreguntas[] VPregNor;

TPreguntas[] VPregDif;

[Link][] obj; // Instancia de la clase CTest para manejar la información

del test

string NomE, GenE, ModE; // Variables para almacenar el nombre, género y modo del
test

int puntaje, conP, puntosRespuesta, Vis; // Variables para puntaje, conteo de preguntas
y puntos por respuesta

string TieE; // Variable para almacenar el tiempo final

DateTime FecE;

Private int TieTrans;

Private Timer timer; // Temporizador

// Constructor del formulario que inicializa las variables

Public FrmQuiz([Link][] objEst, int Visit, string Nom, string Gen, string
Mod)

{
InitializeComponent();

Obj = objEst; // Inicializa la instancia de CTest

Vis = Visit;

NomE = Nom; // Nombre del estudiante

GenE = Gen; // Género del estudiante

ModE = Mod; // Modo del test

conP = 0; // Inicializa el conteo de preguntas

68
 puntaje = 0; // Inicializa el puntaje

puntosRespuesta = 0; // Inicializa los puntos por respuesta

// Inicialización del temporizador

Timer = new Timer();

[Link] = 1000; // Intervalo de 1 segundo

[Link] += timer1_Tick; // Asocia el evento Tick del temporizador al método

timer1_Tick

// Arreglos para almacenar las preguntas de los distintos niveles de dificultad

VPregFac = new TPreguntas[5]; // Preguntas para el modo Fácil

VPregNor = new TPreguntas[5]; // Preguntas para el modo Normal

VPregDif = new TPreguntas[5]; // Preguntas para el modo Difícil

// Inicialización de preguntas para el modo Fácil

VPregFac[0].Pregunta = “En C#, los tipos de datos primitivos son objetos. (Falso)”;

VPregFac[0].Respuesta = false;

VPregFac[1].Pregunta = “El operador ‘&&’ en C# significa ‘O lógico’. (Falso)”;

VPregFac[1].Respuesta = false;

VPregFac[2].Pregunta = “Un método en C# puede devolver múltiples valores.

(Falso)”;

VPregFac[2].Respuesta = false;

VPregFac[3].Pregunta = “En C#, un ‘class’ puede ser instanciado. (Verdadero)”;

VPregFac[3].Respuesta = true;

VPregFac[4].Pregunta = “En C#, la palabra clave ‘public’ significa que el miembro

\n es accesible desde cualquier lugar. (Verdadero)”;

VPregFac[4].Respuesta = true;

69
 // Inicialización de preguntas para el modo Normal

VPregNor[0].Pregunta = “Los ‘struct’ en C# son tipos de referencia. (Falso)”;

VPregNor[0].Respuesta = false;

VPregNor[1].Pregunta = “En C#, un ‘interface’ puede contener implementaciones de

métodos.\n (Falso)”;

VPregNor[1].Respuesta = false;

VPregNor[2].Pregunta = “Los ‘enum’ en C# pueden tener valores de tipo ‘double’.

(Falso)”;
VPregNor[2].Respuesta = false;

VPregNor[3].Pregunta = “El modificador ‘static’ en un método indica que el

método\n pertenece a la instancia de la clase. (Falso)”;

VPregNor[3].Respuesta = false;

VPregNor[4].Pregunta = “Un ‘delegate’ en C# es un tipo que representa referencias\n

a métodos. (Verdadero)”;
VPregNor[4].Respuesta = true;

// Inicialización de preguntas para el modo Difícil

VPregDif[0].Pregunta = “La palabra clave ‘abstract’ se utiliza para declarar una

clase\n que puede ser instanciada. (Falso)”;

VPregDif[0].Respuesta = false;

VPregDif[1].Pregunta = “Los métodos en una clase abstracta pueden ser

implementados\n directamente. (Falso)”;

VPregDif[1].Respuesta = false;

VPregDif[2].Pregunta = “En C#, una clase puede heredar de múltiples clases.

(Falso)”;

VPregDif[2].Respuesta = false;

VPregDif[3].Pregunta = “El operador ‘is’ en C# verifica el tipo de una instancia.

(Verdadero)”;

VPregDif[3].Respuesta = true;

70
 VPregDif[4].Pregunta = “En C#, los métodos estáticos no pueden ser sobrecargados.
(Falso)”;

VPregDif[4].Respuesta = false;

// Evento que se ejecuta cuando se carga el formulario

Private void FrmQuiz_Load(object sender, EventArgs e)

// Inicializa los controles con los datos proporcionados

[Link] = NomE;

[Link] = [Link](conP + 1);

[Link] = ObtenerPregunta(conP, ModE);

[Link] = [Link](puntaje);

puntosRespuesta = 20;

// Inicia el temporizador con el tiempo límite

[Link] = [Link](TieTrans).ToString(@”mm\:ss”);

[Link](); // Comienza el temporizador

// Método que se ejecuta cada vez que el temporizador hace “tick” (cada segundo)

Private void timer1_Tick(object sender, EventArgs e)

TieTrans++;

[Link] = [Link](TieTrans).ToString(@”mm\:ss”);

71
// Evento que se ejecuta al hacer clic en el botón para pasar a la siguiente pregunta

Private void btnSigPre_Click(object sender, EventArgs e)

// Verifica si se ha seleccionado una respuesta

If ([Link] == false && [Link] == false)

[Link](“Debe seleccionar una respuesta.”);

Else

// Valida la respuesta y actualiza el puntaje

Bool respuestaUsu = [Link];

Bool respuestaCorrecta;

If (ModE == “Facil”)

respuestaCorrecta = VPregFac[conP].Respuesta;

Else
{

If (ModE == “Normal”)

respuestaCorrecta = VPregNor[conP].Respuesta;

Else

{
respuestaCorrecta = VPregDif[conP].Respuesta;

72
 }

If (respuestaUsu == respuestaCorrecta)

Puntaje += puntosRespuesta;

ReproducirSonidoCorrecto();

Else

ReproducirSonidoIncorrecto();

// Avanza a la siguiente pregunta o finaliza el test si es la última pregunta

If (conP < 4)

[Link] = [Link](puntaje);

conP += 1;

[Link] = [Link](conP + 1);

[Link] = ObtenerPregunta(conP, ModE);

[Link] = false;

[Link] = false;

Else

If (respuestaUsu == respuestaCorrecta)
{

73
 ReproducirSonidoCorrecto();

Else

ReproducirSonidoIncorrecto();

FinalizarTest(); // Llama al método para finalizar el test

// Método para finalizar el test

Private void FinalizarTest()

{
[Link]();

TieE = [Link]; // Guarda el tiempo final

FecE = [Link];

GuardarTest(NomE, GenE, ModE, puntaje, TieE, FecE); // Guarda los resultados del
test

// Muestra el formulario de resultados finales

FrmFinalTest ObjFin = new FrmFinalTest(obj, Vis, NomE, ModE, puntaje, TieE);

[Link]();

[Link]();

// Métodos para eventos no implementados (pueden eliminarse si no son necesarios)

74
Private void button1_Click(object sender, EventArgs e) { }

Private void Nombre_Click(object sender, EventArgs e) { }

Private void btn_team_Click(object sender, EventArgs e) { }

Private void radioButton2_CheckedChanged(object sender, EventArgs e) { }

Private void btn_gr_Click(object sender, EventArgs e) { }

Private void button1_Click_1(object sender, EventArgs e)

[Link]();

Private void btn_2_CheckedChanged(object sender, EventArgs e) { }

Private void label1_Click(object sender, EventArgs e) { }

Private void pictureBox1_Click(object sender, EventArgs e) { }

Public string ObtenerPregunta(int index, string modo)

If (modo == “Facil”)

{
Return VPregFac[index].Pregunta; // Obtener pregunta del modo Fácil

Else

If (modo == “Normal”)

Return VPregNor[index].Pregunta; // Obtener pregunta del modo Normal

}

75
 Else

Return VPregDif[index].Pregunta; // Obtener pregunta del modo Difícil

// Método para guardar los datos del test de un estudiante

Public void GuardarTest(string Nom, string Gen, string Mod, int Pun, string Tie,
DateTime Fec)

If (Vis < [Link] – 1)

Obj[Vis].Nombre = Nom;
Obj[Vis].Genero = Gen;

Obj[Vis].Modo = Mod;

Obj[Vis].Puntaje = Pun;

Obj[Vis].Tiempo = Tie;

Obj[Vis].FechaHora = Fec;

Vis++;
}

Else

[Link](“No hay más espacio para almacenar estudiantes.”);

76
 Private void ReproducirSonidoCorrecto()

WindowsMediaPlayer player = new WindowsMediaPlayer();

[Link] = “Sonidos/Correcto.mp3”;

[Link]();

Private void ReproducirSonidoIncorrecto()

WindowsMediaPlayer player = new WindowsMediaPlayer();

[Link] = “Sonidos/Incorrecto.mp3”;

[Link]();

}
}

77
Conclusión

A lo largo de este proyecto, hemos desarrollado una aplicación integral que gestiona
eficientemente información sobre estudiantes, evaluaciones, y resultados de rendimiento en
un entorno educativo. Este proyecto ha sido un ejercicio de aplicación práctica de múltiples
conceptos de programación en C#, como estructuras de control, programación modular, y el
manejo de estructuras unidimensionales y cadenas de caracteres. Cada uno de estos
elementos ha desempeñado un papel clave en la construcción de un sistema robusto, eficiente
y fácil de mantener.

Modularidad y Mantenibilidad:

El enfoque modular implementado en el proyecto permitió segmentar el código en

componentes independientes, cada uno con una responsabilidad específica. Esta estructura
modular no solo facilitó el desarrollo, sino que también simplificó las pruebas y la
depuración. Además, la modularidad garantiza que futuras actualizaciones o ampliaciones
del software puedan realizarse de manera más eficiente, sin comprometer la integridad del
sistema existente.

Estructuras de Control:

El uso efectivo de estructuras de control, como condicionales y bucles, permitió implementar

la lógica del programa de manera clara y eficiente. Estas estructuras fueron fundamentales
para gestionar las decisiones automatizadas dentro del sistema, desde la evaluación del

78
rendimiento de los estudiantes hasta la personalización de la interfaz de usuario en función
de los datos procesados.

Gestión de Datos y Eficiencia:

La implementación de arreglos unidimensionales para el almacenamiento y manipulación de

datos fue esencial en la gestión eficiente de la información. Estos arreglos permitieron un
acceso rápido y ordenado a los datos de los estudiantes, facilitando la búsqueda, clasificación
y evaluación en diferentes partes del sistema. Asimismo, el manejo de cadenas de caracteres
permitió la personalización del contenido textual, mejorando la experiencia del usuario y la
claridad de la información presentada.

Integración y Colaboración:

El proyecto es un claro ejemplo de cómo diferentes componentes de un sistema pueden

integrarse de manera cohesiva para lograr un objetivo común. Desde la gestión de inventarios
hasta la evaluación de estudiantes, cada módulo de la aplicación colaboró eficazmente para
ofrecer una solución integral. El trabajo con varios formularios y la interacción entre ellos
demostraron la importancia de una arquitectura bien diseñada y la capacidad de los
formularios para trabajar juntos como un solo sistema.

Aprendizaje y Futuras Perspectivas:

Este proyecto ha sido una experiencia enriquecedora que ha permitido aplicar conceptos
teóricos en un contexto práctico. El proceso de desarrollo ha fortalecido la comprensión de
las buenas prácticas de programación y ha subrayado la importancia de la planificación y la
organización en el desarrollo de software. Este proyecto sienta las bases para futuros
desarrollos, donde la capacidad de diseñar sistemas modulares, eficientes y fáciles de
mantener será crucial para el éxito.

En conclusión, el proyecto no solo ha cumplido con los objetivos técnicos propuestos, sino
que también ha servido como un valioso proceso de aprendizaje en el que se han consolidado
habilidades y conocimientos clave en el desarrollo de software. La experiencia adquirida y

79
las soluciones implementadas constituyen un sólido punto de partida para enfrentar nuevos
desafíos en el ámbito del desarrollo tecnológico.

Recomendaciones para el Lector del Informe

[Link]ón Completa del Informe:

Lectura Detallada: Se recomienda leer el informe en su totalidad para obtener una

comprensión completa del proyecto, incluyendo los conceptos de estructuras de control,
programación modular, cadenas de caracteres y estructuras unidimensionales. Cada sección
está interconectada y ofrece un panorama integral del desarrollo y la implementación del
software.

[Link] en los Ejemplos Prácticos:

Estudio de Casos de Código: Preste especial atención a los ejemplos de código incluidos en
el informe. Estos ejemplos ilustran cómo se aplican las teorías y técnicas en el contexto del
proyecto real. Analizar estos casos le ayudará a entender cómo se implementan las soluciones
en el software desarrollado.

80
3. Comprensión de Conceptos Clave:

Conceptos de Control y Modularidad: Asegúrese de comprender los conceptos de estructuras

de control y programación modular que se aplican en el proyecto. Estos conceptos son
fundamentales para el diseño y la funcionalidad del software. La sección de programación
modular muestra cómo se divide el código en módulos funcionales, facilitando su
mantenimiento y escalabilidad.

4. Aplicación Práctica:

Implementación de Recomendaciones:** Las recomendaciones finales ofrecen sugerencias

para mejorar y mantener el software. Considere aplicar estas recomendaciones en futuras
mejoras del proyecto o en el desarrollo de proyectos similares para optimizar el rendimiento
y la calidad del software.

[Link] Cruzadas:

Relacionar Secciones: Utilice las referencias cruzadas entre las diferentes secciones del
informe para obtener una comprensión más profunda. Por ejemplo, relacionar las estructuras
de control con ejemplos específicos de programación modular puede ayudar a visualizar
cómo se implementan estos conceptos en el código.

6. Consulta de Recursos Adicionales:

Profundización en Temas: Si algún concepto o técnica presentada en el informe no está

completamente claro, se recomienda consultar recursos adicionales o literatura especializada
sobre el tema. Esto puede proporcionar una comprensión más detallada y técnicas avanzadas
relacionadas con el desarrollo de software.

7. Aplicación en Contexto Real:

Adopción de Buenas Prácticas:Al revisar el informe, considere cómo las buenas prácticas
descritas pueden ser adoptadas en proyectos similares. La implementación de técnicas
efectivas de programación y diseño puede mejorar significativamente la calidad y el
rendimiento del software.

81
8. Feedback y Mejoras:

Retroalimentación: Si tiene sugerencias o comentarios sobre el informe, compártalos para

que se puedan hacer mejoras en futuras versiones. La retroalimentación constructiva es
valiosa para refinar y optimizar la documentación y el contenido presentado.

Bibliografía

1. Deitel, H. M., & Deitel, P. J. (2021). C# Cómo Programar (9ª ed.). Pearson Educación.

2. Miller, B., & Ranum, D. (2020). Fundamentals of Computer Programming with C#.
CreateSpace Independent Publishing Platform.

3. Gaddis, T. (2022). Starting Out with C#: From Control Structures through Objects (9ª
ed.). Pearson.

4. Schildt, H. (2019). C# Programming: From Problem Analysis to Program Design.

McGraw-Hill Education.

82
5. Microsoft. (2023). Microsoft Docs: C# Programming Guide. Recuperado de
[[Link]
guide/]([Link]

6. Pérez, M. J. (2022). Introducción a la Programación en C#. Editorial Técnica

Boliviana.

7. García, A. (2021). Programación Orientada a Objetos en C#. Editorial Universitaria

Santa Cruz.

8. López, J. (2023). Fundamentos de C# para Desarrolladores. Editorial Tecnológica de

Bolivia.

9. Torres, R. (2022). C# en la Práctica: Guía para Estudiantes Universitarios. Editorial

Académica Santa Cruz.

10. Instituto Tecnológico de Santa Cruz. (2023). Guía de Programación en C#.

Recuperado de
[[Link]
rogramacion_csharp)

Glosario

Algoritmo: Conjunto de instrucciones ordenadas y finitas que se deben seguir para

realizar una tarea o resolver un problema.

Control de Flujo: Conjunto de estructuras que determinan el orden de ejecución de

las instrucciones en un programa, como las estructuras de decisión (if, switch) y
repetición (for, while).

83
Estructura de Datos: Formato en el que se organizan y gestionan los datos en un
programa, como arreglos, listas o estructuras.

Modularidad: Característica del software que permite dividir el código en módulos

o componentes independientes para mejorar la organización, la reutilización y el
mantenimiento del código.

Programación Orientada a Objetos (POO): Paradigma de programación que

organiza el software en objetos, los cuales son instancias de clases que encapsulan
datos y métodos.

Cadena de Caracteres: Secuencia de caracteres utilizada para representar texto en

la programación, comúnmente manipulada con funciones específicas para realizar
operaciones sobre texto.

Arreglo Unidimensional: Estructura de datos que almacena una colección de

elementos del mismo tipo, accesibles mediante un índice único.

DataGridView: Control en Windows Forms que permite mostrar y editar datos en

una tabla con múltiples filas y columnas.

Formularios (Forms): Ventanas o diálogos en aplicaciones de Windows Forms que

permiten la interacción con el usuario, organizando y gestionando la interfaz gráfica
del software.

Evento: Acción o suceso que ocurre en la aplicación, como un clic en un botón, y

que puede ser manejado mediante métodos específicos para proporcionar una
respuesta o realizar una acción.

Método: Bloque de código que realiza una tarea específica, puede ser llamado desde
otras partes del código y puede recibir parámetros y devolver resultados.

84
85