1. No category

Programación1 Guia#11
1
Facultad: Ingeniería
Escuela: Ingeniería en Computación
Asignatura: Programación I
Guia#11: Tema: “Estructuras en C#”.
Objetivos



Conocer el concepto de estructura y cómo se utilizan en C#.
Conocer las operaciones con estructuras y sus aplicaciones.
Desarrollar programas utilizando estructuras.
Introducción
En el desarrollo de aplicaciones se necesita trabajar con diferentes tipos de datos asignados dependiendo el
tipo de información con la que se trabaja.
En clases anteriores, se ha trabajado con la primera estructura de datos: los arreglos. Dicha estructura permite trabajar
con una colección de elementos del mismo tipo; sin embargo, hay problemas que requiere la utilización de varios
tipos de datos que describen una misma entidad.
¿Qué es una entidad?
Una entidad es todo aquello que se puede describir. La descripción puede hacerse en términos de atributos y
métodos.
Definición
Una estructura es un tipo de valor que se suele utilizar para encapsular pequeños grupos de variables relacionadas.
Las variables que se agrupan no necesariamente deben ser del mismo. Un registro o estructura se define con la
palabra clave struct.
¿Qué pueden contener las Estructuras?
 Constructores.
 Constantes.
 Campos.
 Métodos.
 Propiedades.
 Indizadores.
 Operadores.
 Eventos.
 Tipos anidados
Para declarar una estructura, se utiliza la siguiente sintaxis:
Modificador_Acceso struct Nombre_Estructura
{
Miembros; // Variables, Funciones y/o Procedimientos.
}
En C#, primero deberemos declarar cual va a ser la estructura de nuestro registro, lo que no se puede hacer
dentro de "Main". Más adelante, ya dentro de "Main", podremos declarar variables de ese nuevo tipo.
Los datos que forman un "struct" pueden ser públicos o privados. Por ahora, a nosotros nos interesará que sean
Programación1 Guia#11
accesibles desde el resto de nuestro programa, por lo que les añadiremos delante la palabra “public” para
indicar que queremos que sean públicos.
Ya desde el cuerpo del programa, para acceder a cada uno de los datos que forman el registro, tanto si
queremos leer su valor como si queremos cambiarlo, se debe indicar el nombre de la variable y el del dato
(o campo) separados por un punto:
En este contexto, al operador punto lo llamaremos operador de acceso, ya que permitirá acceder a cada uno
de los miembros que forman parte de la estructura, es decir, podremos acceder a las variables.
¿Cómo se realiza el acceso a los miembros de una estructura?
Variable_tipo_estructura.nombre_del_miembro
Material y Equipo
 Guía de laboratorio No. 11.
 Computadora con Visual Studio 2013 o superior.
 Dispositivo de almacenamiento (USB).
Procedimiento
G11 Ejemplo1. Forma de capturar y mostrar datos utilizando estructuras.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
using
using
using
using
using
System;
System.Collections.Generic;
System.Linq;
System.Text;
System.Threading.Tasks;
namespace G11_e1
{
class Program
{
struct Estudiante
{
public String Nombre;
public int Edad;
public String Colegio;
public int Tel;
}
public static void Main(string[] args)
{
Console.Title = "Primer ejemplo de estructuras";
String Opcion;
Estudiante Objeto = new Estudiante();
int Op;
do
{
Console.Clear();
Console.WriteLine("==========================");
Console.WriteLine("
Menu Principal
");
Console.WriteLine("1. Registrar");
Console.WriteLine("2. Mostrar");
Console.WriteLine("3. Salir");
Console.WriteLine("==========================");
Console.WriteLine("\n");
Console.WriteLine("Digitar su opcion (1-3)?");
Op = int.Parse(Console.ReadLine());
2
Programación1 Guia#11
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
switch (Op)
{
case 1:
Console.Clear();
Console.WriteLine("INGRESE LA INFORMACION DEL ESTUDIANTE");
Console.WriteLine("\nDigite su Primer Nombre y Primer Apellido: ");
Objeto.Nombre = Console.ReadLine();
Console.WriteLine("\nSu Edad: ");
Objeto.Edad = int.Parse(Console.ReadLine());
Console.WriteLine("\nColegio donde estudio su Bacillerato: ");
Objeto.Colegio = Console.ReadLine();
Console.WriteLine("\nTelefono: ");
Objeto.Tel = int.Parse(Console.ReadLine());
break;
case 2:
Console.Clear();
Console.WriteLine("INFORMACION DEL ESTUDIANTE");
Console.WriteLine("Nombre:
" + Objeto.Nombre);
Console.WriteLine("Edad:
" + Objeto.Edad);
Console.WriteLine("Colegio: " + Objeto.Colegio);
Console.WriteLine("Telefono: " + Objeto.Tel);
break;
case 3:
Environment.Exit(0);
break;
}
Console.WriteLine("\n");
Console.WriteLine("\tDesea continuar? (S/N)");
Opcion = Console.ReadLine();
} while (Opcion == "s");
Console.ReadKey();
}
}
}
G11 Ejemplo2: Arreglos de Estructuras
En ocasiones se trabajará con datos o campos que provienen de varias estructuras, entonces lo que se hace
es introducir una estructura dentro de otra. Veamos el siguiente ejemplo:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace G11_e2
{
class Program
{
struct Persona
{
public String Nombre;
public int Edad;
public String Direccion;
}
public static void Main(string[] args)
{
Console.Title = "Ejemplo2 de estructuras";
int max;
Console.WriteLine("¿Digitar la cantidad de personas?");
3
Programación1 Guia#11
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
max = int.Parse(Console.ReadLine());
Persona[] Acceso = new Persona[max];// Acceso es la variable timbre
Console.WriteLine("\n");
for (int i = 0; i < max; i++)
{
Console.WriteLine("Persona con ID:[" + (i + 1) + "]");
Console.Write("Nombre: ");
Acceso[i].Nombre = Console.ReadLine();// uso del timbre con la variable Nombre
Console.Write("Edad: ");
Acceso[i].Edad = int.Parse(Console.ReadLine());// uso del timbre con la variable Edad
Console.Write("Direccion: ");
Acceso[i].Direccion = Console.ReadLine();// uso del timbre con la variable Direccion
Console.WriteLine("\n");
}
Console.Clear();
Console.WriteLine("Las personas digitadas son:");
Console.WriteLine("\n");
for (int i = 0; i < max; i++)
{
Console.WriteLine("Persona con ID:[" + (i + 1) + "]");
Console.WriteLine("Nombre:" + Acceso[i].Nombre);
Console.WriteLine("Edad: " + Acceso[i].Edad);
Console.WriteLine("Direccion:" + Acceso[i].Dirreccion);
Console.WriteLine("--------------------------------------");
}
Console.ReadKey();
}
}
}
G11 Ejemplo3: Estructuras Anidadas
En ocasiones se trabajará con datos o campos que provienen de varias estructuras, entonces lo que se hace
es introducir una estructura dentro de otra. Veamos el siguiente ejemplo:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace G11_e3
{
class Program
{
struct programa
{
public String Universidad;
public String Carrera;
}
struct Estudiante
{
public String nombre;
public int edad;
public programa Estudios;
}
static void Main(string[] args)
{
Console.Title="Ejemplo3 de estructuras anidadas";
Estudiante student = new Estudiante();
4
Programación1 Guia#11
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
//Entrada de datos
Console.Write("Ingrese Nombre: ");
student.nombre = Console.ReadLine();
Console.Write("Edad: ");
student.edad = int.Parse(Console.ReadLine());
Console.Write("Carrera: ");
//Accedemos a miembros de otra estructura
student.Estudios.Carrera = Console.ReadLine();
Console.Write("Universidad: ");
student.Estudios.Universidad = Console.ReadLine();
Console.Clear();
Console.WriteLine("Mostrando datos: ");
Console.WriteLine("Estudiante:
" + student.nombre);
Console.WriteLine("Edad:
" + student.edad);
Console.WriteLine("Carrera:
" + student.Estudios.Carrera);
Console.WriteLine("Universidad: " + student.Estudios.Universidad);
Console.ReadKey();
}
}
}
G11 Ejemplo4: Estructuras y Procedimientos
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace G11_e4
{
class Program
{
struct Alumno
{
public String carnet;
public String Nombre;
public void Mostrar(Alumno X)
{
Console.WriteLine("\nNombre: " + X.Nombre);
Console.WriteLine("\nCarnet: " + X.carnet);
}
}
public static void Main()
{
Alumno Var = new Alumno();
int op, O;
Console.Title = "Ejemplo4 Utilizando procedimientos y estructuras";
do
{
Console.Clear();
Console.WriteLine("=======================");
Console.WriteLine("
MENU ");
Console.WriteLine("\n");
Console.WriteLine("
1.Ingresar.");
Console.WriteLine("
2.Mostrar.");
Console.WriteLine("\n");
Console.WriteLine("=======================");
5
Programación1 Guia#11
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
Console.WriteLine("Digitar la opcion (1-2)");
op = int.Parse(Console.ReadLine());
switch (op)
{
case 1:
Console.Clear();
Console.Write("Nombre: ");
Var.Nombre = Console.ReadLine();
Console.Write("Carnet: ");
Var.carnet = Console.ReadLine();
break;
case 2:
Console.Clear();
Var.Mostrar(Var);
break;
}
Console.WriteLine("Si desea continuar regresar al menu presione 1, para finalizar
presione 2");
O = int.Parse(Console.ReadLine());
} while (O == 1);
Console.ReadKey();
}
}
}
G11 Ejemplo5:
Paso de parámetros a método miembro de estructura:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace G11_e5
{
class Program
{
struct ejemplo
{
public String Name;
public String Equipo;
public int Edad;
public void Registrar(string n, string g, int e)
{
Name = n;
Equipo = g;
Edad = e;
}
}
static void Main(string[] args)
{
int opcion, op;
int tan;
Console.Title = "Ejemplo5 de estructura con paso de parametros";
Console.WriteLine("Digite el numero de estudiantes a registrar: ");
tan = int.Parse(Console.ReadLine());
ejemplo[] E = new ejemplo[tan];
6
Programación1 Guia#11
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
do
{
Console.Clear();
Console.WriteLine("\nMenu:");
Console.WriteLine("1.Registrar.");
Console.WriteLine("2.Mostrar.");
Console.WriteLine("3.Salir.");
Console.WriteLine("Digite su opcion.");
opcion = int.Parse(Console.ReadLine());
switch (opcion)
{
case 1:
for (int i = 0; i < tan; i++)
{
Console.Clear();
Console.Write("Nombre: ");
String n = Console.ReadLine();
Console.Write("EquipodeFutbol: ");
String g = Console.ReadLine();
Console.Write("Edad: ");
int e = int.Parse(Console.ReadLine());
E[i].Registrar(n, g, e);
}
break;
case 2:
Console.WriteLine("Informacion Ingresada...");
Console.WriteLine("------------------------");
for (int i = 0; i < tan; i++)
{
Console.WriteLine("Nombre: " + E[i].Name);
Console.WriteLine("Equipo: " + E[i].Equipo);
Console.WriteLine("Edad:
" + E[i].Edad);
Console.WriteLine("----------------------");
}
break;
case 3:
Environment.Exit(0);
break;
}
Console.WriteLine("Para continuar presione 1...");
op = int.Parse(Console.ReadLine());
} while (op == 1);
Console.ReadKey();
}
}
}
Analisis de Resultados
Desarrollar las siguientes aplicaciones en C#.
1. Modifique el ejemplo 4 para que acepte más de un registro.
2. Un "struct" que almacene datos de una canción en formato MP3: Artista, Título, Duración (en segundos),
Tamaño del fichero (en KB). Un programa debe pedir los datos de una canción al usuario, almacenarlos
en dicho "struct" y después mostrarlos en pantalla.
3. Un “struct” que guarde los datos de n vehículos. Los datos a solicitar son los siguientes: Placa, Color, Año,
7
Programación1 Guia#11
Marca, Modelo, Propietario. El programa debe solicitar los datos al usuario y mostrarlos haciendo uso
de un procedimiento.
Investigacion Complementaria
1. Desarrolle un programa haciendo uso de estructuras que simule una agenda. La aplicación debe solicitar
los datos y mantenerlos en tiempo de ejecución (el programa debe estar activo hasta que se escoja la opcion
de Salir).
Los datos que se deben solicitar son los siguientes:
Nombre, DUI, Dirección, Teléfono, Email, Profesión u Oficio.
El menú debe tener las opciones:
1. Ingresar Datos.
2. Mostrar Datos.
3. Buscar Persona.
4.Salir
En la opción 3, debe buscar por DUI, ya que es un datos que es único para cada usuario, al encontrar dicha
persona el programa debe mostrar los datos encontrados.
2. Investigar sobre el uso de archivos en C#.
Bibliografia
Deitel, Harvey M. y Paul J. Deitel, Cómo Programar en C#, Segunda Edición, México, 2007.
8