INSTITUTO TECNOLÓGICO DE MÉXICO

INSTITUTO TECNOLÓGICO DE TLAXIACO

INGENIERÍA EN SISTEMAS COMPUTACIONALES

UNIDAD 3 THREADS

REPORTE DE PRACTICA 7

HILOS EN WINDOWS FORMS

INTEGRANTES DEL EQUIPO:

ARNOL JESÚS CRUZ ORTÍZ.

ISAAC CORONEL SANTIAGO.
GREGORIO OSORIO SARMIENTO.
SANDRA YOLOTZIN REYES GARCÍA.

DOCENTE:ING JOSE ALFREDO ROMÁN CRUZ

GRUPO: 4US

PERIODO: ENERO-JULIO 2022

HEROICA CIUDAD DE TLAXIACO OAX.

1
INDICE
INTRODUCCIÓN...........................................................................................3
OBJETIVO PRINCIPAL................................................................................3
OBJETIVOS SECUNDARIOS.......................................................................3
MATERIAL.....................................................................................................3
DESARROLLO...............................................................................................4
CONCLUSIONES.........................................................................................13

INDICE DE ILUSTRACIONES
Ilustración 1.....................................................................................................4
Ilustración 2.....................................................................................................5
Ilustración 3.....................................................................................................6
Ilustración 4.....................................................................................................7
Ilustración 5.....................................................................................................7
Ilustración 6.....................................................................................................8
Ilustración 7.....................................................................................................8
Ilustración 8.....................................................................................................9
Ilustración 9.....................................................................................................9
Ilustración 10...................................................................................................9
Ilustración 11...................................................................................................9
Ilustración 12...................................................................................................9
Ilustración 13.................................................................................................10
Ilustración 14.................................................................................................10
Ilustración 15.................................................................................................10
INTRODUCCIÓN.
De forma resumida, los hilos son un mecanismo mediante el cual podemos dividir una
aplicación en diferentes partes que se pueden ejecutar de forma paralela, existiendo
mecanismos por los que pueden compartir información. C# ofrece un mecanismo muy
sencillo de implementar hilos, basado en la utilización de la clase Thread. En el siguiente
reporte se realizara una forma de utilizar los hilos, con un ejemplo en que se emplean y tener
una idea mas general de lo que podemos hacer con su programación.
Recordemos las ventajas de los threads.
Un Thread (hilo) es simplemente una tarea que puede ser ejecutada al mismo tiempo que
otra tarea.

•Los thread’s hacen posible la ejecución concurrente de código.

•Los cambios de contexto son menos costosos en tiempo de ejecución
•Dependiendo de la arquitectura del sistema los thread tienen mejor desempeño.
•Java proporciona un API para el uso de hilos.

OBJETIVO PRINCIPAL.
• Implementar hilos en una aplicación de escritorio utilizando C#

OBJETIVOS SECUNDARIOS.
• Desarrollar en Windows Form para implementar hilos con una aplicación de escritorio
de Visual Studio
• La aplicación debe aplicar la multitarea para realizar diferentes tareas a la vez.

MATERIAL.
• Visual Studio.
• Editor de texto.
• Material de información.
DESARROLLO.
Crearemos un nuevo proyecto en visual estudio, el cual sera de tipo aplicación de Windows
Forms para aplicar los Threads y veamos como funciona, la aplicación sera sencilla.
1. Podemos crear nuestro proyecto abriendo el programa Visual Studio desde su menú.

Ilustración 1 Crear nuevo proyecto

1.1 Se nos mostrara algunos trabajos que habrimos recientemente, y al lado derecho,
podemos seleccionar las tarreas que podemos realizar en la aplicación, nosotros
realizaremos un nuevo proyecto por lo que seleccionamos Crear un Proyecto.
2. Nuestro nuevo proyecto sera en Windows Forms, esta sera la plantilla a utilizar, tiene que
ser C#, ya que es el lenguaje de programacion que emplearemos para su desarrollo.
Ilustración 2 Celesión de la plantilla Windows Forms

2.1 cuando seleccionemos la platilla nombrada Aplicación de Windows Forms(.NET

Framework) C#, que utilizaremos daremos en siguiente. Como se muestra en la ilustración 2.
Nota: es importante que la plantilla diga “Aplicación de Windows Forms(.NET Framework)
C#”, en caso de querer agregar otras plantillas a nuestro proyecto, estas tienen que ser de la
misma versión para que no tenga errores de compilación nuestro proyecto.
3. Nuestro proyecto tiene que tener un Nombre para identificarlo y saber sobre que estamos
trabajando, como el Tema es Threads, El proyecto se llama SolucionFomsHilos. Así
sabremos que se trata de una aplicación Forms empleando métodos de Threads(Hilos).
Ilustración 3 Configurar tu proyecto

3.1 Al Crear un nuevo Proyecto le daremos nombre “SolucionFormsHilos”, también podemos

guardar el proyecto en una nueva ubicación, en una nueva carpeta o dejarla en la carpeta
que por defecto crea Visual Studio para guardar los proyectos que se crean, entre algunas
otras opciones, cuando el proyecto tenga estas características seleccionaremos en crear y ya
hemos creado nuestro proyecto, al menos la plantilla donde aremos la verdadera
implementación de threads con Windows Forms.
4. Se creara el proyecto y tendremos una ventana la cual podremos modificar el tamaño que
tendrá y agregar elementos en ella que realizaran una función especifica, pero aquí solo
utilizaremos un botón, algo simple pero que nos dará una idea sobre como funciona el
emplear threads en nuestras apps.
 Ilustración 4 Ventana de Windows Froms.net

4.1 A nuestra Forma 1 le agregamos un botón que dice y dirá COMENZAR, el proceso para
hacerlo es el siguiente...
4.1.1 en la parte izquierda tendremos una barra de herramientas la cual nos permite trabajar
con la aplicación, utilizaremos el que dice Button y aremos click en cualquier parte dentro del
form1.

Ilustración 5 Insertar un Button

4.1.2 De esta manera tendremos un objeto Button. Para cambiar el Nombre que tiene por
defecto y asignarle uno con el cual podremos identificarlo mejor, tiene que estar seleccionado
y en la parte derecha superior tendremos una ventana con sus propiedades y modificaremos
algunas características como su Nombre, el texto que mostrara, color y tamaño ente muchas
cosas mas.

Ilustración 6 Boton por defecto

4.1.3 En las propiedades, cambiaremos las características Text, Diseño si así se pide y size.

Ilustración 7 Propiedades de el botton

obteniendo el botón de la siguiente manera, terminando su diseño.

Ilustración 8 Diseño final del

hilo
5. Para acceder al evento del Button daremos doble click en él, de esa forma nos
redirecionara a su evento donde podemos programar código siendo las instrucciones que
realizara al dar click mientras se ejecuta el programa.
Cuando estamos por primera vez en la clase donde escribiremos el código, habrá ya unas
lineas de código ya escritas que son necesarios para inicializar los componentes del
formulario.
Inicializaremos una variable la cual se llama Posición que tendrá cada barra de proceso,
6. En el evento button1_Click(object sender, EventArgs e) {} :

Ilustración 9 Evento del boton que usamos con valores que usara

7. Esta es nuestra función encargada de crear las barras. nuestro método recibe los
parámetros sX , sY , sAltura y sAncho, todos de tipo entero.

Ilustración 10 Método donde se generan las barras y los procesos, recibiendo valores por parámetros

8. Declaramos e instanciamos pb de modo que nos quede un nuevo objeto de tipo

ProgressBar.

Ilustración 11 el objeto pb instanciando

9. declaramos la variable ContarHasta de tipo entero y le asignamos un número al azar entre
cien mil y cinco millones. Luego utilizamos la propiedad SetBounds para establecer el
posicionamiento y le pasamos los parámetros recibidos.

Ilustración 12 Variable que se le asignan valores aleatorios y el metodo SetBunds.

10. Ahora le decimos a la propiedad Parent que el contenedor padre del control es este
mismo formulario (pb.Parent = this;), y por último llamamos al método CreateControl();.

Ilustración 13 llamada de los Metodos CreateControl()];

11. Lo siguiente es generar el retardo suficiente para llenar la barra de progresoYo elegí
hacer que el programa cuente de 0 hasta un número aleatorio alto (como mínimo 100 mil y
como máximo 5 millones en mi caso), para esto hice dos bucles For. el primero declara una
variable contador de tipo entero, la inicializa en uno y se va a repetir hasta que la variable
llegue a 100 incrementándola de uno en uno. En cada repetición aumenta el valor de la
propiedad Value de la barra. El segundo For es el que hace el trabajo sucio. Declara la
variable CuentaNumeros de tipo entero, la inicializa en cero y se repite hasta que la variable
llegue al valor aleatorio que tomó la variable ContarHasta al principio de la función.

Ilustración 14 bucles for para los procesos

12. Compilamos y ejecutamos el código.

Ilustración 15: Form1 resultado dela compilacion

Vemos el resultado.

Ilustración 16: Procesos, resultado simultaneo

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading;
using System.Windows.Forms;

namespace FormsHilos
{
public partial class Form1 : Form
{
int Posicion = 0;
public Form1()
{
InitializeComponent();
}

private void Form1_Load(object sender, EventArgs e)

{

}
 private void button1_Click(object sender, EventArgs e)
{
Posicion = Posicion + 30;
CrearProgressBars(23, Posicion, 23, 200);
}

private void CrearProgressBars(int sX, int sY, int sAltura, int sAncho)
{
ProgressBar pb = new ProgressBar();
int ContarHasta = new Random().Next(100000, 5000000);
pb.SetBounds(sX, sY, sAncho, sAltura);
pb.Parent = this;
pb.CreateControl();
for (int contador = 1; contador <= 100; contador++)
{
pb.Value = contador;

for (int CuentaNumeros = 0; CuentaNumeros <= ContarHasta; CuentaNumeros+

+) ;
}

}
}
}

CONCLUSIONES.